Merge branch 'main' into 'devel'

Draft: Add custom image and gif support for G835L

See merge request asus-linux/asusctl!249

.cargo-husky/hooks/pre-commit

@@ -1,6 +1,6 @@
 #!/bin/sh
 set -e
 
-echo '+cargo +nightly fmt --all -- --check'
-cargo +nightly fmt --all -- --check
+echo '+cargo fmt --all -- --check'
+cargo fmt --all -- --check
 git add -u

.cargo-husky/hooks/pre-push

@@ -2,8 +2,8 @@
 
 set -e
 
-echo '+cargo +nightly fmt --all -- --check'
-cargo +nightly fmt --all -- --check
+echo '+cargo fmt --all -- --check'
+cargo fmt --all -- --check
 echo '+cargo clippy --all -- -D warnings'
 cargo clippy --all -- -D warnings
 echo '+cargo cranky'

.gitignore

@@ -9,6 +9,7 @@ vendor_*
 .vscode
 .~lock.*
 *.ods#
+*.patch
 
 # gnome extension
 node-modules
@@ -19,3 +20,8 @@ desktop-extensions/gnome*/@types/gir-generated
 desktop-extensions/gnome*/node_modules
 desktop-extensions/gnome*/schemas/gschemas.compiled
 desktop-extensions/gnome*/*.zip
+
+# agents and reference
+CLAUDE.md
+AGENTS.md
+/reference

.gitlab-ci.yml

@@ -1,22 +1,26 @@
 image: rust:latest
 
+# Use shallow clone to reduce checkout size
+variables:
+  GIT_DEPTH: "1"
+  # Put cargo home and target under project dir so we can clean them easily
+  CARGO_HOME: "$CI_PROJECT_DIR/.cargo"
+  CARGO_TARGET_DIR: "$CI_PROJECT_DIR/ci-target"
+  GIT_SUBMODULE_STRATEGY: normal
+
+# Cache only cargo registries/git metadata to speed dependency fetches.
+# Avoid caching compiled `target` artifacts which are large and easily fill disk.
 .rust_cache: &rust_cache
   cache:
-    # key: $CI_COMMIT_REF_SLUG
+    key: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
     paths:
-      # Don't include `incremental` to save space
-      # Debug
-      - target/debug/build/
-      - target/debug/deps/
-      - target/debug/.fingerprint/
-      - target/debug/.cargo-lock
-      # Release
-      - target/release/build/
-      - target/release/deps/
-      - target/release/.fingerprint/
-      - target/release/.cargo-lock
+      - .cargo/registry
+      - .cargo/git
 
 before_script:
+  - df -h
+  - echo "Cleaning stale targets to free space if present"
+  - rm -rf "$CI_PROJECT_DIR/target" "$CI_PROJECT_DIR/ci-target" || true
   - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev libsdl2-dev libsdl2-gfx-dev
 
 stages:
@@ -31,20 +35,24 @@ format:
     - tags
   <<: *rust_cache
   script:
-    - echo "nightly" > rust-toolchain
-    - rustup component add rustfmt
+    - rustup component add rustfmt || true
     - cargo fmt --check
+  after_script:
+    - du -sh "$CI_PROJECT_DIR/ci-target" || true
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
 
 check:
   except:
     - tags
   <<: *rust_cache
   script:
-    - rustup component add clippy
-    - cargo check
+    - rustup component add clippy || true
+    - cargo check --locked --workspace
     # deny currently catches too much
     #- cargo install cargo-deny && cargo deny
     - cargo install cargo-cranky && cargo cranky
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
 
 test:
   except:
@@ -52,7 +60,9 @@ test:
   <<: *rust_cache
   script:
     - mkdir -p .git/hooks > /dev/null
-    - cargo test --all -- --test-threads=1
+    - cargo test --locked --all
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true
 
 release:
   only:
@@ -60,11 +70,15 @@ release:
   <<: *rust_cache
   script:
     - cargo install cargo-vendor-filterer
-    - make && make vendor
+    - cargo fetch
+    - make FROZEN=1 && make vendor
   artifacts:
     paths:
       - vendor_asusctl*.tar.xz
       - cargo-config
+    expire_in: 1 week
+  after_script:
+    - rm -rf vendor vendor_asusctl*.tar.xz "$CI_PROJECT_DIR/ci-target" || true
 
 pages:
   stage: deploy
@@ -72,14 +86,14 @@ pages:
     - tags
   <<: *rust_cache
   script:
-    - cargo doc --document-private-items --no-deps --workspace
+    - cargo doc --locked --document-private-items --no-deps --workspace
     - rm -rf public
     - mkdir public
-    - cp -R target/doc/* public
-    - cp extra/index.html 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
   artifacts:
     paths:
       - public
-
-variables:
-  GIT_SUBMODULE_STRATEGY: normal
+    expire_in: 1 week
+  after_script:
+    - rm -rf "$CI_PROJECT_DIR/ci-target" || true

CHANGELOG.md

@@ -1,6 +1,94 @@
 # Changelog
 
-## [Unreleased]
+## [6.3.2]
+
+### Changes
+- Improve the notification area, @shevchenko0013 strikes again!
+- Improve firmware attributes handling
+
+## [6.3.1]
+
+### 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]
+
+### Changed
+- Added aura support for FX607V: thanks @jomp16
+- Added testing support for G835LW
+- Added support for GU605C models slash lighting: thanks @Otters
+- Restore fedora: thanks @ali205412
+- Add support to G614F models slash lighting
+
+## [6.1.22]
+
+### Changed
+- Allow configuration of nv_tgp
+- Treat dGPU attributes as power profiles
+- Add EXPERTBOOK DMI match to ensure the service is loaded
+- Support G815L thanks to @solost !
+
+## [6.1.21]
+
+### Changed
+- Kill Fedora: screw your cursed cargo bullshit
+- Restore CI building
+
+## [6.1.20]
+
+### Changed
+- Addded support for G635L: thanks @luca_pisl !
+- Suppress verbose output in applications too, not just daemon
+
+## [6.1.18]
+
+### Changed
+- Add aura support for G614FR (ROG Strix G16 2025)
+- all notifications now respects the timeout 
+- improve udev daemon-starting rule
+- reduce log noise
+
+## [v6.1.17]
+
+### Changed
+- Fix Makefile
+- Share a single HID device
+
+## [v6.1.16]
+
+### Changed
+- Expose more properties via rog-control-center
+- Add support for a few more models
+
+## [v6.1.15]
+
+### Changed
+- Reflect the current asus-armoury status on AC plug connection status change
+
+## [v6.1.14]
+
+### Changed
+- Fix formatting
+- Attempt to fix tests
+
+## [v6.1.13]
+
+### Changed
+- Fix a problem in reloading the service (@evertvorster)
+- Add Azerbaijani language (@rashadgasimli)
+- Add Ubuntu installation instructions
 
 ## [v6.1.12]
 

Cargo.toml

@@ -1,9 +1,12 @@
 [workspace.package]
-version = "6.1.12"
+version = "6.3.1"
 rust-version = "1.82"
 license = "MPL-2.0"
 readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
+authors = [
+  "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"
@@ -44,7 +47,7 @@ smol = "^2.0"
 mio = "0.8.11"
 
 futures-util = "0.3.31"
-zbus = "5.5.0"
+zbus = "5.13.1"
 logind-zbus = { version = "5.2.0" } #, default-features = false, features = ["non_blocking"] }
 
 serde = { version = "^1.0", features = ["serde_derive"] }
@@ -57,12 +60,12 @@ glam = { version = "^0.22", features = ["serde"] }
 gumdrop = "^0.8"
 udev = { version = "^0.8", features = ["mio"] }
 rusb = "^0.9"
-inotify = "^0.10.0"
+inotify = "^0.10"
 
 png_pong = "^0.8"
 pix = "^0.13"
-tinybmp = "^0.4.0"
-gif = "^0.12.0"
+tinybmp = "^0.4"
+gif = "^0.12"
 
 versions = "6.2"
 

Makefile

@@ -17,6 +17,8 @@ BIN_D := asusd
 BIN_U := asusd-user
 LEDCFG := aura_support.ron
 
+DESTDIR_REALPATH = $(shell realpath $(DESTDIR))
+
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
 STRIP_BINARIES ?= 0
@@ -35,6 +37,15 @@ ifeq ($(X11),1)
 	ARGS += --features "rog-control-center/x11"
 endif
 
+# Always use the versions in Cargo.lock by default
+ARGS += --locked
+
+# Allow optionally freezing the build to avoid any network access and enforce Cargo.lock strictly
+FROZEN ?= 0
+ifeq ($(FROZEN),1)
+	ARGS += --frozen
+endif
+
 VENDORED ?= 0
 ifeq ($(VENDORED),1)
 	ARGS += --frozen
@@ -48,24 +59,38 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install-program:
-	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+target/$(TARGET)/$(BIN_D): $(SRC)
+	$(MAKE) build
 
-	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+target/$(TARGET)/$(BIN_C): $(SRC)
+	$(MAKE) build
+
+target/$(TARGET)/$(BIN_U): $(SRC)
+	$(MAKE) build
+
+target/$(TARGET)/$(BIN_ROG): $(SRC)
+	$(MAKE) build
+
+install-asusd: target/$(TARGET)/$(BIN_D)
 	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
+
+install-asusctl: target/$(TARGET)/$(BIN_C)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+
+install-asusd_user: target/$(TARGET)/$(BIN_U)
 	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
 
-install-data:
+install-rog_gui: target/$(TARGET)/$(BIN_ROG)
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+.PHONY: install-asusd install-asusctl install-asusd_user install-rog_gui
+
+install-program: install-asusd install-asusctl install-asusd_user install-rog_gui
+
+install-data-rog_gui:
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
-	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
-
-	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
-	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
-	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
-
-	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR_REALPATH)$(datarootdir)/rog-gui/layouts/{}" \;
 
 	$(INSTALL_DATA) "./data/icons/asus_notif_yellow.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
@@ -81,9 +106,24 @@ install-data:
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
 	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
 
-	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+install-data-asusd:
+	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
+
+	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
+
+	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR_REALPATH)$(datarootdir)/asusd/{}" \;
+
+install-data-asusd_user:
+	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+
+.PHONY: install-data-asusd install-data-asusd_user
+
+install-data: install-data-asusd install-data-asusd_user install-data-rog_gui
 
 install: install-program install-data
+	$(INSTALL_DATA) "./LICENSE" "$(DESTDIR)$(datarootdir)/asusctl/LICENSE"
 
 uninstall:
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
@@ -118,6 +158,8 @@ vendor:
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
 	rm -rf vendor
+	# Ensure cargo-vendor-filterer is installed (CI installs it already)
+	command -v cargo-vendor-filterer >/dev/null 2>&1 || cargo install --locked cargo-vendor-filterer
 	cargo vendor-filterer --all-features --platform x86_64-unknown-linux-gnu vendor
 	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
 	rm -rf vendor

README.md

@@ -13,9 +13,7 @@ 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 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)
+Support for TDP is tied to the new asus-armoury driver: available mainline since linux 6.19: everything older is not supported.
 
 ## X11 support
 
@@ -46,13 +44,13 @@ See the [rog-aura readme](./rog-aura/README.md) for more details.
 Most ASUS gaming laptops that have a USB keyboard. If `lsusb` shows something similar
 to this:
 
-```
+```plain
 Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
 
 or
 
-```
+```plain
 Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
 ```
 
@@ -74,43 +72,56 @@ The list is a bit outdated as many features have been enabled in the Linux kerne
 - [x] Toggle bios setting for boot/POST sound
 - [x] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
-# GUI
+## GUI
 
 A gui is now in the repo - ROG Control Center. At this time it is still a WIP, but it has almost all features in place already.
 
 **NOTE**: Xorg is not supported.
 
-# BUILDING
+## BUILDING
 
-Rust and cargo are required, they can be installed from [rustup.rs](https://rustup.rs/) or from the distro repos if newer than 1.75.
+Rust and cargo are required, they can be installed from [rustup.rs](https://rustup.rs/).
+
+Distro packaging should work with the stable toolchain. If your distro does not provide a recent Rust toolchain, install rustup and use the stable toolchain.
 
 **fedora:**
 
-    dnf install cmake clang-devel  libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
-    make
-    sudo make install
+```sh
+dnf install cmake clang-devel  libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
+make
+sudo make install
+```
 
 **openSUSE:**
 
 Works with KDE Plasma (without GTK packages)
 
-    zypper in -t pattern devel_basis
-    zypper in rustup make cmake clang-devel libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
-    make
-    sudo make install
+```sh
+zypper in -t pattern devel_basis
+zypper in rustup make cmake clang-devel libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
+make
+sudo make install
+```
 
 **Debian(unsuported):**
 
 officially unsuported,but you can still try and test it by yourself(some features may not be available).
 
-    sudo apt install libclang-dev libudev-dev libfontconfig-dev build-essential cmake libxkbcommon-dev
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-    make
-    sudo make install
+```sh
+sudo apt install libclang-dev libudev-dev libfontconfig-dev build-essential cmake libxkbcommon-dev
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+make
+sudo make install
+```
 
 **Ubuntu, Popos (unsuported):**
 
-instructions removed as outdated
+```sh
+sudo apt install make cargo gcc pkg-config openssl libasound2-dev cmake build-essential python3 libfreetype6-dev libexpat1-dev libxcb-composite0-dev libssl-dev libx11-dev libfontconfig1-dev curl libclang-dev libudev-dev checkinstall libseat-dev libinput-dev libxkbcommon-dev libgbm-dev
+
+make
+sudo make install
+```
 
 ## Installing
 
@@ -128,15 +139,15 @@ You may also need to activate the service for debian install. If running Pop!\_O
 
 If you are upgrading from a previous installed version, you will need to restart the service or reboot.
 
-```
-$ systemctl daemon-reload && systemctl restart asusd
+```sh
+systemctl daemon-reload && systemctl restart asusd
 ```
 
 ## Uninstalling
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
-# Contributing
+## Contributing
 
 See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
 
@@ -144,17 +155,17 @@ Generation of the bindings with `make bindings` requires `typeshare` to be insta
 
 Dbus introsepction XML requires with `make introspection` requires `anime_sim` to be running before starting `asusd`.
 
-# OTHER
+## OTHER
 
-## AniMe Matrix simulator
+### AniMe Matrix simulator
 
 A simulator using SDL2 can be built using `cargo build --package rog_simulators` and run with `./target/debug/anime_sim`. Once started `asusd` will need restarting to pick it up. If running this sim on a laptop _with_ the display, the simulated display will be used instead of the physical display.
 
-## Supporting more laptops
+### Supporting more laptops
 
 Please file a support request.
 
-# License & Trademarks
+## License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)
 
@@ -167,3 +178,7 @@ 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,6 +24,19 @@ env_logger.workspace = true
 ron.workspace = true
 gumdrop.workspace = true
 zbus.workspace = true
+argh = "0.1"
 
 [dev-dependencies]
 rog_dbus = { path = "../rog-dbus" }
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+An utility for Linux to control many aspects of various ASUS laptops
+but can also be used with non-asus laptops with reduced features."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusctl", "usr/bin/", "755"],
+]

asusctl/examples/anime-gif.rs

@@ -21,11 +21,14 @@ fn main() {
     let brightness = args[2].parse::<f32>().unwrap();
     let anime_type = get_anime_type();
     let mut seq = Sequences::new(anime_type);
-    seq.insert(0, &ActionLoader::AsusAnimation {
-        file: path.into(),
-        time: rog_anime::AnimTime::Infinite,
-        brightness,
-    })
+    seq.insert(
+        0,
+        &ActionLoader::AsusAnimation {
+            file: path.into(),
+            time: rog_anime::AnimTime::Infinite,
+            brightness,
+        },
+    )
     .unwrap();
 
     loop {

asusctl/examples/anime-led-scan.rs

@@ -0,0 +1,547 @@
+//! LED scanning tool for discovering AniMe Matrix buffer-to-LED mappings.
+//!
+//! This tool lights up one buffer index at a time, allowing you to observe
+//! which physical LED corresponds to each buffer position. This is essential
+//! for mapping new device types like G835L where the exact layout is unknown.
+//!
+//! You might want to use it slowly, as it sometimes doesn't work properly.
+//! Maybe there's better ways to make this reliable but for now it works for my use case.
+//!
+//! # Usage
+//! ```
+//! cargo run --example anime-led-scan -- [options]
+//! ```
+//!
+//! # Controls
+//! - `n` or `Enter`: Next index
+//! - `p` or `Backspace`: Previous index
+//! - `j` followed by number: Jump to specific index
+//! - `+` / `-`: Adjust step size (default 1)
+//! - `s`: Save current index to notes file
+//! - `r`: Mark current index as row start
+//! - `q` or `Ctrl+C`: Quit
+//!
+//! # Output
+//! Creates a `led-scan-notes.txt` file with recorded observations.
+
+use std::env;
+use std::fs::OpenOptions;
+use std::io::{self, BufRead, Write};
+
+use rog_anime::usb::{get_anime_type, Brightness};
+use rog_anime::{AnimeDataBuffer, AnimeType};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+/// Saved device state for restoration on exit
+struct SavedState {
+    builtins_enabled: bool,
+    brightness: Brightness,
+    display_enabled: bool,
+}
+
+fn print_help(scan_len: usize, buffer_len: usize) {
+    println!("\n=== LED Scan Tool ===");
+    println!(
+        "Scan range: 0-{} (buffer size: {})",
+        scan_len - 1,
+        buffer_len
+    );
+    println!("Commands:");
+    println!("  n, Enter     - Next index");
+    println!("  p, Backspace - Previous index");
+    println!("  j <num>      - Jump to index");
+    println!("  + / -        - Increase/decrease step size");
+    println!("  s            - Save note for current index");
+    println!("  r            - Mark as row start");
+    println!("  a            - Auto-scan (runs through all indices)");
+    println!("  f            - Fill all buffer bytes");
+    println!("  f <start> <end> - Fill range (inclusive)");
+    println!("  p1/p2/p3     - Fill pane 1/2/3 only (each is 627 bytes)");
+    println!("  hold         - Hold current LED (press Enter to release)");
+    println!("  hold <s> <e> - Hold range (press Enter to release)");
+    println!("  c            - Clear display");
+    println!("  row          - Step through rows (G835L, provisional)");
+    println!("  row <n>      - Show specific row (G835L, provisional)");
+    println!("  allrows      - Light all rows sequentially (G835L)");
+    println!("  rowmap       - Print the full row mapping (G835L)");
+    println!("  h            - Show this help");
+    println!("  q            - Quit and restore state");
+    println!();
+}
+
+fn save_note(index: usize, note: &str) -> io::Result<()> {
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open("led-scan-notes.txt")?;
+    writeln!(file, "Index {}: {}", index, note)?;
+    Ok(())
+}
+
+fn write_single_led(
+    proxy: &AnimeProxyBlocking,
+    anime_type: AnimeType,
+    index: usize,
+    brightness: u8,
+) {
+    let mut buffer = AnimeDataBuffer::new(anime_type);
+    let data = buffer.data_mut();
+    if index < data.len() {
+        data[index] = brightness;
+    }
+    if let Err(e) = proxy.write(buffer) {
+        eprintln!("Error writing to device: {}", e);
+    }
+}
+
+fn clear_display(proxy: &AnimeProxyBlocking, anime_type: AnimeType) {
+    let buffer = AnimeDataBuffer::new(anime_type);
+    let _ = proxy.write(buffer);
+}
+
+fn fill_display(proxy: &AnimeProxyBlocking, anime_type: AnimeType, brightness: u8) {
+    let mut buffer = AnimeDataBuffer::new(anime_type);
+    let data = buffer.data_mut();
+    for byte in data.iter_mut() {
+        *byte = brightness;
+    }
+    if let Err(e) = proxy.write(buffer) {
+        eprintln!("Error writing to device: {}", e);
+    }
+}
+
+/// Fill a range of LEDs. Both start and end are INCLUSIVE.
+fn fill_range(
+    proxy: &AnimeProxyBlocking,
+    anime_type: AnimeType,
+    start: usize,
+    end: usize,
+    brightness: u8,
+) {
+    let mut buffer = AnimeDataBuffer::new(anime_type);
+    let data = buffer.data_mut();
+    for i in start..=end.min(data.len().saturating_sub(1)) {
+        data[i] = brightness;
+    }
+    if let Err(e) = proxy.write(buffer) {
+        eprintln!("Error writing to device: {}", e);
+    }
+}
+
+fn fill_pane(proxy: &AnimeProxyBlocking, anime_type: AnimeType, pane: usize, brightness: u8) {
+    const PANE_LEN: usize = 627;
+    let start = pane * PANE_LEN;
+    let end = start + PANE_LEN - 1;
+    fill_range(proxy, anime_type, start, end, brightness);
+}
+
+/// G835L row pattern (PROVISIONAL - needs hardware verification):
+/// - Rows 0-1: 1 LED each
+/// - Rows 2-3: 2 LEDs each
+/// - ... (pairs of rows with same length)
+/// - Rows 26-27: 14 LEDs each
+/// - Rows 28+: 15 LEDs each (constant)
+///
+/// Returns (start_index, end_index_inclusive, row_length)
+fn g835l_row_bounds(row: usize) -> (usize, usize, usize) {
+    let triangle_rows = 28;
+    let triangle_leds = 210;
+
+    if row < triangle_rows {
+        let length = row / 2 + 1;
+        let mut start = 0usize;
+        for r in 0..row {
+            start += r / 2 + 1;
+        }
+        (start, start + length - 1, length)
+    } else {
+        let rows_after_triangle = row - triangle_rows;
+        let start = triangle_leds + rows_after_triangle * 15;
+        (start, start + 14, 15)
+    }
+}
+
+fn g835l_total_rows() -> usize {
+    28 + 40
+}
+
+fn save_state(proxy: &AnimeProxyBlocking) -> SavedState {
+    SavedState {
+        builtins_enabled: proxy.builtins_enabled().unwrap_or(false),
+        brightness: proxy.brightness().unwrap_or(Brightness::Med),
+        display_enabled: proxy.enable_display().unwrap_or(true),
+    }
+}
+
+fn restore_state(proxy: &AnimeProxyBlocking, state: &SavedState) {
+    let _ = proxy.set_builtins_enabled(state.builtins_enabled);
+    let _ = proxy.set_brightness(state.brightness);
+    let _ = proxy.set_enable_display(state.display_enabled);
+    let _ = proxy.run_main_loop(true);
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+
+    let mut start_index = 0usize;
+    let mut brightness = 200u8;
+    let mut scan_limit: Option<usize> = None;
+
+    let mut i = 1;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--start" | "-s" => {
+                if i + 1 < args.len() {
+                    start_index = args[i + 1].parse().unwrap_or(0);
+                    i += 1;
+                }
+            }
+            "--brightness" | "-b" => {
+                if i + 1 < args.len() {
+                    brightness = args[i + 1].parse().unwrap_or(200);
+                    i += 1;
+                }
+            }
+            "--limit" | "-l" => {
+                if i + 1 < args.len() {
+                    scan_limit = args[i + 1].parse().ok();
+                    i += 1;
+                }
+            }
+            "--help" | "-h" => {
+                println!("LED Scan Tool for AniMe Matrix");
+                println!();
+                println!("Usage: anime-led-scan [options]");
+                println!();
+                println!("Options:");
+                println!("  -s, --start <N>      Start at index N (default: 0)");
+                println!("  -b, --brightness <N> LED brightness 0-255 (default: 200)");
+                println!("  -l, --limit <N>      Cap scan range to N indices (e.g. 810 for G835L)");
+                println!("  -h, --help           Show this help");
+                return;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    let conn = match Connection::system() {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("Failed to connect to D-Bus: {}", e);
+            eprintln!("Make sure asusd is running.");
+            return;
+        }
+    };
+
+    let proxy = match AnimeProxyBlocking::new(&conn) {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("Failed to create Anime proxy: {}", e);
+            eprintln!("Make sure asusd supports your device.");
+            return;
+        }
+    };
+
+    let anime_type = get_anime_type();
+    let buffer_len = anime_type.data_length();
+    let scan_len = scan_limit.unwrap_or(buffer_len).min(buffer_len);
+
+    println!("=== LED Scan Tool ===");
+    println!("Device type: {:?}", anime_type);
+    println!("Buffer length: {} bytes", buffer_len);
+    println!("Scan range: 0-{}", scan_len - 1);
+    println!("Brightness: {}", brightness);
+    println!();
+
+    // Save current state for restoration
+    let saved_state = save_state(&proxy);
+    println!("Saved device state for restoration on exit.");
+
+    // Stop system animations
+    if let Err(e) = proxy.run_main_loop(false) {
+        eprintln!("Warning: Could not stop main loop: {}", e);
+    }
+    println!("Stopped system animations.");
+
+    print_help(scan_len, buffer_len);
+
+    let mut current_index = start_index.min(scan_len - 1);
+    let mut step = 1usize;
+
+    write_single_led(&proxy, anime_type, current_index, brightness);
+    println!(">>> Index: {} (step: {})", current_index, step);
+
+    let stdin = io::stdin();
+    let mut input = String::new();
+
+    loop {
+        input.clear();
+        print!("> ");
+        io::stdout().flush().unwrap();
+
+        if stdin.lock().read_line(&mut input).is_err() {
+            break;
+        }
+
+        let cmd = input.trim();
+
+        match cmd {
+            "q" | "quit" | "exit" => {
+                clear_display(&proxy, anime_type);
+                restore_state(&proxy, &saved_state);
+                println!("Restored device state. Goodbye!");
+                break;
+            }
+            "n" | "" => {
+                current_index = (current_index + step).min(scan_len - 1);
+                write_single_led(&proxy, anime_type, current_index, brightness);
+                println!(">>> Index: {} (step: {})", current_index, step);
+            }
+            "p" => {
+                current_index = current_index.saturating_sub(step);
+                write_single_led(&proxy, anime_type, current_index, brightness);
+                println!(">>> Index: {} (step: {})", current_index, step);
+            }
+            "+" => {
+                step = step.saturating_mul(2).max(1);
+                println!("Step size: {}", step);
+            }
+            "-" => {
+                step = step.saturating_div(2).max(1);
+                println!("Step size: {}", step);
+            }
+            "r" => {
+                if let Err(e) = save_note(current_index, "ROW START") {
+                    eprintln!("Error saving note: {}", e);
+                } else {
+                    println!("Saved: Index {} marked as ROW START", current_index);
+                }
+            }
+            "h" | "help" | "?" => {
+                print_help(scan_len, buffer_len);
+            }
+            cmd if cmd.starts_with('j') => {
+                let num_str = cmd.trim_start_matches('j').trim();
+                if let Ok(idx) = num_str.parse::<usize>() {
+                    if idx < scan_len {
+                        current_index = idx;
+                        write_single_led(&proxy, anime_type, current_index, brightness);
+                        println!(">>> Index: {} (step: {})", current_index, step);
+                    } else {
+                        println!("Index {} out of range (max: {})", idx, scan_len - 1);
+                    }
+                } else {
+                    println!("Usage: j <number>");
+                }
+            }
+            cmd if cmd.starts_with('s') && !cmd.starts_with("show") => {
+                let note = cmd.trim_start_matches('s').trim();
+                let note = if note.is_empty() { "observed" } else { note };
+                if let Err(e) = save_note(current_index, note) {
+                    eprintln!("Error saving note: {}", e);
+                } else {
+                    println!("Saved note for index {}", current_index);
+                }
+            }
+            "a" => {
+                println!("Auto-scan mode (0 to {})...", scan_len - 1);
+                let delay = std::time::Duration::from_millis(10);
+                for idx in current_index..scan_len {
+                    write_single_led(&proxy, anime_type, idx, brightness);
+                    print!("\rIndex: {} / {}   ", idx, scan_len - 1);
+                    io::stdout().flush().unwrap();
+                    std::thread::sleep(delay);
+                    current_index = idx;
+                }
+                println!();
+                println!("Auto-scan complete. Current index: {}", current_index);
+            }
+            "c" => {
+                clear_display(&proxy, anime_type);
+                println!("Display cleared");
+            }
+            "f" => {
+                fill_display(&proxy, anime_type, brightness);
+                println!("All buffer bytes filled at brightness {}", brightness);
+            }
+            "p1" => {
+                fill_pane(&proxy, anime_type, 0, brightness);
+                println!("Pane 1 (indices 0-626) filled");
+            }
+            "p2" => {
+                fill_pane(&proxy, anime_type, 1, brightness);
+                println!("Pane 2 (indices 627-1253) filled");
+            }
+            "p3" => {
+                fill_pane(&proxy, anime_type, 2, brightness);
+                println!("Pane 3 (indices 1254-1880) filled");
+            }
+            cmd if cmd.starts_with("f ") => {
+                let parts: Vec<&str> = cmd.split_whitespace().collect();
+                if parts.len() == 3 {
+                    if let (Ok(start), Ok(end)) =
+                        (parts[1].parse::<usize>(), parts[2].parse::<usize>())
+                    {
+                        fill_range(&proxy, anime_type, start, end, brightness);
+                        println!("Filled indices {} to {}", start, end);
+                    } else {
+                        println!("Usage: f <start> <end>");
+                    }
+                } else {
+                    println!("Usage: f <start> <end>");
+                }
+            }
+            "show" => {
+                write_single_led(&proxy, anime_type, current_index, brightness);
+                println!(">>> Index: {} (step: {})", current_index, step);
+            }
+            "row" => {
+                if anime_type != AnimeType::G835L {
+                    println!("Warning: Row commands use G835L mapping (provisional). You can add to this code to support other types. `examples/anime-led-scan.rs[402:425]`");
+                }
+                println!("Row stepping mode. Press Enter for next row, 'q' to quit.");
+                let total = g835l_total_rows();
+                for row_num in 0..total {
+                    let (start, end, len) = g835l_row_bounds(row_num);
+                    if end >= scan_len {
+                        println!("Row {} exceeds scan limit, stopping.", row_num);
+                        break;
+                    }
+                    println!("Row {}: indices {}-{} ({} LEDs)", row_num, start, end, len);
+                    fill_range(&proxy, anime_type, start, end, brightness);
+                    input.clear();
+                    print!("(Enter=next, q=quit) > ");
+                    io::stdout().flush().unwrap();
+                    if stdin.lock().read_line(&mut input).is_err() {
+                        break;
+                    }
+                    if input.trim() == "q" {
+                        break;
+                    }
+                    clear_display(&proxy, anime_type);
+                }
+                println!("Row stepping done.");
+            }
+            cmd if cmd.starts_with("row ") => {
+                if anime_type != AnimeType::G835L {
+                    println!("Warning: Row commands use G835L mapping (provisional).");
+                }
+                let row_str = cmd.trim_start_matches("row ").trim();
+                if let Ok(row_num) = row_str.parse::<usize>() {
+                    let total = g835l_total_rows();
+                    if row_num < total {
+                        let (start, end, len) = g835l_row_bounds(row_num);
+                        if end < scan_len {
+                            println!("Row {}: indices {}-{} ({} LEDs)", row_num, start, end, len);
+                            fill_range(&proxy, anime_type, start, end, brightness);
+                        } else {
+                            println!("Row {} exceeds scan limit", row_num);
+                        }
+                    } else {
+                        println!("Row {} out of range (max: {})", row_num, total - 1);
+                    }
+                } else {
+                    println!("Usage: row <number>");
+                }
+            }
+            "allrows" => {
+                if anime_type != AnimeType::G835L {
+                    println!("Warning: Row commands use G835L mapping (provisional).");
+                }
+                println!("Lighting all rows sequentially (200ms each)...");
+                let total = g835l_total_rows();
+                let delay = std::time::Duration::from_millis(200);
+                for row_num in 0..total {
+                    let (start, end, len) = g835l_row_bounds(row_num);
+                    if end >= scan_len {
+                        println!("\nRow {} exceeds scan limit, stopping.", row_num);
+                        break;
+                    }
+                    print!(
+                        "\rRow {}/{}: indices {}-{} ({} LEDs)    ",
+                        row_num,
+                        total - 1,
+                        start,
+                        end,
+                        len
+                    );
+                    io::stdout().flush().unwrap();
+                    fill_range(&proxy, anime_type, start, end, brightness);
+                    std::thread::sleep(delay);
+                    clear_display(&proxy, anime_type);
+                }
+                println!("\nDone.");
+            }
+            "rowmap" => {
+                if anime_type != AnimeType::G835L {
+                    println!("Warning: Row map is for G835L (provisional).");
+                }
+                println!("G835L Row Map:");
+                let total = g835l_total_rows();
+                for row_num in 0..total {
+                    let (start, end, len) = g835l_row_bounds(row_num);
+                    let marker = if end >= scan_len {
+                        " (exceeds limit)"
+                    } else {
+                        ""
+                    };
+                    println!(
+                        "  Row {:2}: indices {:4}-{:4} ({:2} LEDs){}",
+                        row_num, start, end, len, marker
+                    );
+                }
+            }
+            "hold" => {
+                // Single write, wait for Enter to release
+                println!("Holding index {}. Press Enter to release...", current_index);
+                write_single_led(&proxy, anime_type, current_index, brightness);
+                input.clear();
+                let _ = stdin.lock().read_line(&mut input);
+                clear_display(&proxy, anime_type);
+                println!("Released.");
+            }
+            cmd if cmd.starts_with("hold ") => {
+                let arg = cmd.trim_start_matches("hold ").trim();
+                let (start, end): (usize, usize) = match arg {
+                    "p1" | "1" => (0, 626),
+                    "p2" | "2" => (627, 1253),
+                    _ => {
+                        let parts: Vec<&str> = arg.split_whitespace().collect();
+                        if parts.len() == 2 {
+                            if let (Ok(s), Ok(e)) = (parts[0].parse(), parts[1].parse()) {
+                                (s, e)
+                            } else {
+                                println!("Usage: hold p1, hold p2, or hold <start> <end>");
+                                continue;
+                            }
+                        } else {
+                            println!("Usage: hold p1, hold p2, or hold <start> <end>");
+                            continue;
+                        }
+                    }
+                };
+                println!("Holding range {}-{}. Press Enter to release...", start, end);
+                fill_range(&proxy, anime_type, start, end, brightness);
+                input.clear();
+                let _ = stdin.lock().read_line(&mut input);
+                clear_display(&proxy, anime_type);
+                println!("Released.");
+            }
+            _ => {
+                if let Ok(idx) = cmd.parse::<usize>() {
+                    if idx < scan_len {
+                        current_index = idx;
+                        write_single_led(&proxy, anime_type, current_index, brightness);
+                        println!(">>> Index: {} (step: {})", current_index, step);
+                    } else {
+                        println!("Index {} out of range (max: {})", idx, scan_len - 1);
+                    }
+                } else {
+                    println!("Unknown command: '{}'. Type 'h' for help.", cmd);
+                }
+            }
+        }
+    }
+}

asusctl/src/anime_cli.rs

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

asusctl/src/aura_cli.rs

@@ -1,68 +1,67 @@
+use std::fmt;
 use std::str::FromStr;
 
-use gumdrop::Options;
+use argh::FromArgs;
 use rog_aura::error::Error;
 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 ROGs and TUF laptops)"
+)]
 pub struct LedPowerCommand1 {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")]
+    #[argh(
+        option,
+        description = "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(Options, Debug)]
+#[derive(FromArgs, Debug, Clone)]
+#[argh(subcommand, name = "aura-power", description = "aura power")]
 pub struct LedPowerCommand2 {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(command)]
+    #[argh(subcommand)]
     pub command: Option<SetAuraZoneEnabled>,
 }
 
-#[derive(Options, Debug)]
+/// Subcommands to enable/disable specific aura zones
+#[derive(FromArgs, Debug, Clone)]
+#[argh(subcommand)]
 pub enum SetAuraZoneEnabled {
-    /// Applies to both old and new models
-    #[options(help = "")]
-    Keyboard(AuraPowerStates),
-    #[options(help = "")]
-    Logo(AuraPowerStates),
-    #[options(help = "")]
-    Lightbar(AuraPowerStates),
-    #[options(help = "")]
-    Lid(AuraPowerStates),
-    #[options(help = "")]
-    RearGlow(AuraPowerStates),
-    #[options(help = "")]
-    Ally(AuraPowerStates),
+    Keyboard(KeyboardPower),
+    Logo(LogoPower),
+    Lightbar(LightbarPower),
+    Lid(LidPower),
+    RearGlow(RearGlowPower),
+    Ally(AllyPower),
 }
 
-#[derive(Debug, Clone, Options)]
-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)]
+/// Keyboard brightness argument helper
+#[derive(Debug, Clone)]
 pub struct LedBrightness {
     level: Option<u8>,
 }
+
 impl LedBrightness {
     pub fn new(level: Option<u8>) -> Self {
         LedBrightness { level }
@@ -72,174 +71,302 @@ 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(LedBrightness { level: Some(0x00) }),
-            "low" => Ok(LedBrightness { level: Some(0x01) }),
-            "med" => Ok(LedBrightness { level: Some(0x02) }),
-            "high" => Ok(LedBrightness { level: Some(0x03) }),
-            _ => {
-                print!("Invalid argument, must be one of: off, low, med, high");
-                Err(Error::ParseBrightness)
-            }
+            "off" => Ok(Self::new(Some(0x00))),
+            "low" => Ok(Self::new(Some(0x01))),
+            "med" => Ok(Self::new(Some(0x02))),
+            "high" => Ok(Self::new(Some(0x03))),
+            _ => Err(Error::ParseBrightness),
         }
     }
 }
-#[allow(clippy::to_string_trait_impl)]
-impl ToString for LedBrightness {
-    fn to_string(&self) -> String {
+
+impl fmt::Display for LedBrightness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = match self.level {
-            Some(0x00) => "low",
-            Some(0x01) => "med",
-            Some(0x02) => "high",
+            Some(0x00) => "off",
+            Some(0x01) => "low",
+            Some(0x02) => "med",
+            Some(0x03) => "high",
             _ => "unknown",
         };
-        s.to_owned()
+        write!(f, "{}", s)
     }
 }
 
-#[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 {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
+    #[argh(option, description = "set the speed: low, med, high")]
     pub speed: Speed,
-    #[options(
-        no_long,
-        meta = "",
-        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+
+    #[argh(
+        option,
+        default = "AuraZone::None",
+        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     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 {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
+    #[argh(option, description = "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(
-        no_long,
-        meta = "",
-        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+
+    #[argh(
+        option,
+        default = "AuraZone::None",
+        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     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 {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    #[argh(option, short = 'c', description = "set the RGB value e.g. ff00ff")]
     pub colour: Colour,
-    #[options(
-        no_long,
-        meta = "",
-        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+
+    #[argh(
+        option,
+        default = "AuraZone::None",
+        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     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 {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    #[argh(option, short = 'c', description = "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(
-        no_long,
-        meta = "",
-        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+
+    #[argh(
+        option,
+        default = "AuraZone::None",
+        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     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 {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
+    #[argh(option, description = "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(
-        no_long,
-        meta = "",
-        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+
+    #[argh(
+        option,
+        default = "AuraZone::None",
+        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-#[derive(Debug, Clone, Default, Options)]
+/// Multi-zone colour settings
+#[derive(FromArgs, Debug, Clone, Default)]
+#[allow(dead_code)]
+#[argh(description = "multi-zone colour settings")]
 pub struct MultiZone {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    #[argh(option, short = 'a', description = "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,
 }
 
-#[derive(Debug, Clone, Default, Options)]
+/// Multi-colour with speed
+#[derive(FromArgs, Debug, Clone, Default)]
+#[allow(dead_code)]
+#[argh(description = "multi-colour with speed")]
 pub struct MultiColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    #[argh(option, short = 'a', description = "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,
 }
 
-/// Byte value for setting the built-in mode.
-///
-/// Enum corresponds to the required integer value
-// NOTE: The option names here must match those in rog-aura crate
-#[derive(Options)]
+/// Builtin aura effects
+#[derive(FromArgs, Debug)]
+#[argh(subcommand)]
 pub enum SetAuraBuiltin {
-    #[options(help = "set a single static colour")]
-    Static(SingleColour), // 0
-    #[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")]
+    Static(SingleColour),              // 0
+    Breathe(TwoColourSpeed),           // 1
+    RainbowCycle(SingleSpeed),         // 2
     RainbowWave(SingleSpeedDirection), // 3
-    #[options(help = "rain pattern mimicking raindrops")]
-    Stars(TwoColourSpeed), // 4
-    #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed), // 5
-    #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed), // 6
-    #[options(help = "pressed keys generate horizontal laser")]
-    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
+    Stars(TwoColourSpeed),             // 4
+    Rain(SingleSpeed),                 // 5
+    Highlight(SingleColourSpeed),      // 6
+    Laser(SingleColourSpeed),          // 7
+    Ripple(SingleColourSpeed),         // 8
+    Pulse(SingleColour),               // 10
+    Comet(SingleColour),               // 11
+    Flash(SingleColour),               // 12
 }
 
 impl Default for SetAuraBuiltin {

asusctl/src/cli_opts.rs

@@ -1,4 +1,4 @@
-use gumdrop::Options;
+use argh::FromArgs;
 use rog_platform::platform::PlatformProfile;
 
 use crate::anime_cli::AnimeCommand;
@@ -7,118 +7,308 @@ use crate::fan_curve_cli::FanCurveCommand;
 use crate::scsi_cli::ScsiCommand;
 use crate::slash_cli::SlashCommand;
 
-#[derive(Default, Options)]
+#[derive(FromArgs, Default, Debug)]
+/// asusctl command-line options
 pub struct CliStart {
-    #[options(help_flag, help = "print help message")]
-    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>,
+    #[argh(subcommand)]
+    pub command: CliCommand,
 }
 
-#[derive(Options)]
+/// Top-level subcommands for asusctl
+#[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),
-    #[options(help = "Set or select platform_profile")]
+    Brightness(BrightnessCommand),
     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),
 }
 
-#[derive(Debug, Clone, Options)]
+impl Default for CliCommand {
+    fn default() -> Self {
+        CliCommand::Info(InfoCommand::default())
+    }
+}
+
+#[derive(FromArgs, Debug)]
+#[argh(subcommand, name = "profile", description = "profile management")]
 pub struct ProfileCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-
-    #[options(help = "toggle to next profile in list")]
-    pub next: bool,
-
-    #[options(help = "list available profiles")]
-    pub list: bool,
-
-    #[options(help = "get profile")]
-    pub profile_get: bool,
-
-    #[options(meta = "", help = "set the active profile")]
-    pub profile_set: Option<PlatformProfile>,
+    #[argh(subcommand)]
+    pub command: ProfileSubCommand,
 }
 
-#[derive(Options)]
+#[derive(FromArgs, Debug)]
+#[argh(subcommand)]
+pub enum ProfileSubCommand {
+    Next(ProfileNextCommand),
+    List(ProfileListCommand),
+    Get(ProfileGetCommand),
+    Set(ProfileSetCommand),
+}
+
+impl Default for ProfileSubCommand {
+    fn default() -> Self {
+        ProfileSubCommand::List(ProfileListCommand::default())
+    }
+}
+
+#[derive(FromArgs, Debug, Default)]
+#[argh(
+    subcommand,
+    name = "next",
+    description = "toggle to next profile in list"
+)]
+pub struct ProfileNextCommand {}
+
+#[derive(FromArgs, Debug, Default)]
+#[argh(subcommand, name = "list", description = "list available profiles")]
+pub struct ProfileListCommand {}
+
+#[derive(FromArgs, Debug, Default)]
+#[argh(subcommand, name = "get", description = "get profile")]
+pub struct ProfileGetCommand {}
+
+#[derive(FromArgs, Debug, Default)]
+#[argh(subcommand, name = "set", description = "set profile")]
+pub struct ProfileSetCommand {
+    #[argh(positional, description = "profile to set")]
+    pub profile: PlatformProfile,
+
+    #[argh(
+        switch,
+        short = 'a',
+        description = "set the profile to use on AC power"
+    )]
+    pub ac: bool,
+
+    #[argh(
+        switch,
+        short = 'b',
+        description = "set the profile to use on battery power"
+    )]
+    pub battery: bool,
+}
+
+#[derive(FromArgs, Debug, Default)]
+#[argh(subcommand, name = "aura", description = "led mode commands")]
 pub struct LedModeCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(help = "switch to next aura mode")]
+    #[argh(switch, description = "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(Options)]
-pub struct GraphicsCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-}
-
-#[derive(Options, Debug)]
+#[derive(FromArgs, Debug, Default)]
+#[argh(
+    subcommand,
+    name = "armoury",
+    description = "armoury / firmware attributes"
+)]
 pub struct ArmouryCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(
-        free,
-        help = "append each value name followed by the value to set. `-1` sets to default"
-    )]
-    pub free: Vec<String>,
+    #[argh(subcommand)]
+    pub command: ArmourySubCommand,
 }
 
-#[derive(Options)]
+#[derive(FromArgs, Debug)]
+#[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,
+
+    #[argh(positional, description = "value to set for the given attribute")]
+    pub value: i32,
+}
+
+#[derive(FromArgs, Debug, Default)]
+#[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 {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(meta = "", help = "Set screen brightness <0-100>")]
+    #[argh(option, description = "set screen brightness <0-100>")]
     pub screenpad_brightness: Option<i32>,
-    #[options(
-        meta = "",
-        help = "Set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
+
+    #[argh(
+        option,
+        description = "set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
     )]
     pub screenpad_gamma: Option<f32>,
-    #[options(
-        meta = "",
-        help = "Set screenpad brightness to sync with primary display"
+
+    #[argh(
+        option,
+        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,49 +1,44 @@
-use gumdrop::Options;
+use argh::FromArgs;
 use rog_platform::platform::PlatformProfile;
 use rog_profiles::fan_curve_set::CurveData;
 use rog_profiles::FanCurvePU;
 
-#[derive(Debug, Clone, Options)]
+#[derive(FromArgs, Debug, Clone)]
+#[argh(subcommand, name = "fan-curve", description = "fan curve commands")]
 pub struct FanCurveCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-
-    #[options(help = "get enabled fan profiles")]
+    #[argh(switch, description = "get enabled fan profiles")]
     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,
 
-    #[options(
-        meta = "",
-        help = "profile to modify fan-curve for. Shows data if no options provided"
+    #[argh(
+        option,
+        description = "profile to modify fan-curve for. shows data if no options provided"
     )]
     pub mod_profile: Option<PlatformProfile>,
 
-    #[options(
-        meta = "",
-        help = "enable or disable <true/false> fan all curves for a profile. `--mod_profile` \
-                required"
+    #[argh(
+        option,
+        description = "enable or disable <true/false> fan all curves for a profile; --mod_profile required"
     )]
     pub enable_fan_curves: Option<bool>,
 
-    #[options(
-        meta = "",
-        help = "enable or disable <true/false> a single fan curve for a profile. `--mod_profile` \
-                and `--fan` required"
+    #[argh(
+        option,
+        description = "enable or disable <true/false> a single fan curve for a profile; --mod_profile and --fan required"
     )]
     pub enable_fan_curve: Option<bool>,
 
-    #[options(
-        meta = "",
-        help = "select fan <cpu/gpu/mid> to modify. `--mod_profile` required"
+    #[argh(
+        option,
+        description = "select fan <cpu/gpu/mid> to modify; --mod_profile required"
     )]
     pub fan: Option<FanCurvePU>,
 
-    #[options(
-        meta = "",
-        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"
+    #[argh(
+        option,
+        description = "data format = 30c:1%,49c:2%,...; --mod-profile required. If '%' is omitted the fan range is 0-255"
     )]
     pub data: Option<CurveData>,
 }

asusctl/src/main.rs

@@ -1,5 +1,4 @@
 use std::convert::TryFrom;
-use std::env::args;
 use std::path::Path;
 use std::process::Command;
 use std::thread::sleep;
@@ -8,12 +7,11 @@ 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};
+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, AuraDeviceType, AuraEffect, PowerZones};
+use rog_aura::{self, AuraEffect, PowerZones};
 use rog_dbus::asus_armoury::AsusArmouryProxyBlocking;
 use rog_dbus::list_iface_blocking;
 use rog_dbus::scsi_aura::ScsiAuraProxyBlocking;
@@ -32,7 +30,6 @@ 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;
 
@@ -44,30 +41,19 @@ mod scsi_cli;
 mod slash_cli;
 
 fn main() {
+    // Ensure tracing spans are quiet by default unless user overrides
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "warn,tracing=error,zbus=error");
+    }
     let mut logger = env_logger::Builder::new();
     logger
         .parse_default_env()
-        .target(env_logger::Target::Stdout)
+        .filter_level(LevelFilter::Info)
+        .target(env_logger::Target::Stderr)
         .format_timestamp(None)
-        .filter_level(log::LevelFilter::Debug)
         .init();
 
-    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 parsed: CliStart = argh::from_env();
 
     let conn = Connection::system().unwrap();
     if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| {
@@ -86,6 +72,7 @@ fn main() {
             }
         };
 
+        let self_version = env!("CARGO_PKG_VERSION");
         if asusd_version != self_version {
             println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
             return;
@@ -106,12 +93,6 @@ 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);
         }
@@ -138,9 +119,9 @@ fn print_info() {
     let dmi = DMIID::new().unwrap_or_default();
     let board_name = dmi.board_name;
     let prod_family = dmi.product_family;
-    println!("asusctl version: {}", env!("CARGO_PKG_VERSION"));
-    println!(" Product family: {}", prod_family.trim());
-    println!("     Board name: {}", board_name.trim());
+    println!("Software version: {}", env!("CARGO_PKG_VERSION"));
+    println!("  Product family: {}", prod_family.trim());
+    println!("      Board name: {}", board_name.trim());
 }
 
 fn check_service(name: &str) -> bool {
@@ -205,149 +186,63 @@ fn do_parsed(
     conn: Connection,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
-        Some(CliCommand::Aura(mode)) => handle_led_mode(mode)?,
-        Some(CliCommand::AuraPowerOld(pow)) => handle_led_power1(pow)?,
-        Some(CliCommand::AuraPower(pow)) => handle_led_power2(pow)?,
-        Some(CliCommand::Profile(cmd)) => {
-            handle_throttle_profile(&conn, supported_properties, cmd)?
-        }
-        Some(CliCommand::FanCurve(cmd)) => {
-            handle_fan_curve(&conn, cmd)?;
-        }
-        Some(CliCommand::Graphics(_)) => do_gfx(),
-        Some(CliCommand::Anime(cmd)) => handle_anime(cmd)?,
-        Some(CliCommand::Slash(cmd)) => handle_slash(cmd)?,
-        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");
-            }
+        CliCommand::Aura(mode) => handle_led_mode(mode)?,
+        CliCommand::AuraPowerOld(pow) => handle_led_power1(pow)?,
+        CliCommand::AuraPower(pow) => handle_led_power2(pow)?,
+        CliCommand::Brightness(cmd) => handle_brightness(cmd)?,
+        CliCommand::Profile(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)?
         }
     }
 
-    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))?,
-                }
+    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) => {
+            let proxy = PlatformProxyBlocking::new(conn)?;
+            if let Some(p) = o.percent {
+                proxy.set_charge_control_end_threshold(p)?;
             }
-        } else {
-            println!("No aura interface found");
+            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);
         }
     }
 
-    if parsed.next_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.next())?;
-            }
-        } else {
-            println!("No aura interface found");
-        }
-    }
+    Ok(())
+}
 
-    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");
-        }
-    }
+fn handle_info(
+    info_opt: &InfoCommand,
+    supported_interfaces: &[String],
+    supported_properties: &[Properties],
+) -> Result<(), Box<dyn std::error::Error>> {
+    println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+    println!();
+    print_info();
+    println!();
 
-    if parsed.show_supported {
+    if info_opt.show_supported {
         println!("Supported Core Functions:\n{:#?}", supported_interfaces);
         println!(
             "Supported Platform Properties:\n{:#?}",
@@ -368,35 +263,14 @@ fn do_parsed(
         }
     }
 
-    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.help
+        && cmd.sync_screenpad_brightness.is_none()
     {
-        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:");
@@ -429,8 +303,50 @@ 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()
@@ -438,13 +354,9 @@ 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.help
+        && !cmd.clear
     {
-        println!("Missing arg or command\n\n{}", cmd.self_usage());
-        if let Some(lst) = cmd.self_command_list() {
-            println!("\n{}", lst);
-        }
+        println!("Missing arg or command; run 'asusctl anime --help' for usage");
     }
 
     let animes = find_iface::<AnimeProxyBlocking>("xyz.ljones.Anime").map_err(|e| {
@@ -491,11 +403,10 @@ 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.help_requested() || image.path.is_empty() {
-                        println!("Missing arg or command\n\n{}", image.self_usage());
-                        if let Some(lst) = image.self_command_list() {
-                            println!("\n{}", lst);
-                        }
+                    if image.path.is_empty() {
+                        println!(
+                            "Missing arg or command; run 'asusctl anime image --help' for usage"
+                        );
                         return Ok(());
                     }
                     verify_brightness(image.bright);
@@ -512,11 +423,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     proxy.write(<AnimeDataBuffer>::try_from(&matrix)?)?;
                 }
                 AnimeActions::PixelImage(image) => {
-                    if image.help_requested() || image.path.is_empty() {
-                        println!("Missing arg or command\n\n{}", image.self_usage());
-                        if let Some(lst) = image.self_command_list() {
-                            println!("\n{}", lst);
-                        }
+                    if image.path.is_empty() {
+                        println!("Missing arg or command; run 'asusctl anime pixel-image --help' for usage");
                         return Ok(());
                     }
                     verify_brightness(image.bright);
@@ -531,11 +439,10 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     proxy.write(matrix.into_data_buffer(anime_type)?)?;
                 }
                 AnimeActions::Gif(gif) => {
-                    if gif.help_requested() || gif.path.is_empty() {
-                        println!("Missing arg or command\n\n{}", gif.self_usage());
-                        if let Some(lst) = gif.self_command_list() {
-                            println!("\n{}", lst);
-                        }
+                    if gif.path.is_empty() {
+                        println!(
+                            "Missing arg or command; run 'asusctl anime gif --help' for usage"
+                        );
                         return Ok(());
                     }
                     verify_brightness(gif.bright);
@@ -565,11 +472,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     }
                 }
                 AnimeActions::PixelGif(gif) => {
-                    if gif.help_requested() || gif.path.is_empty() {
-                        println!("Missing arg or command\n\n{}", gif.self_usage());
-                        if let Some(lst) = gif.self_command_list() {
-                            println!("\n{}", lst);
-                        }
+                    if gif.path.is_empty() {
+                        println!("Missing arg or command; run 'asusctl anime pixel-gif --help' for usage");
                         return Ok(());
                     }
                     verify_brightness(gif.bright);
@@ -596,14 +500,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     }
                 }
                 AnimeActions::SetBuiltins(builtins) => {
-                    if builtins.help_requested() || builtins.set.is_none() {
-                        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);
-                        }
+                    if builtins.set.is_none() {
+                        println!("Missing arg; run 'asusctl anime set-builtins --help' for usage");
                         return Ok(());
                     }
 
@@ -630,24 +528,19 @@ 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.help
+        && !cmd.disable
     {
-        println!("Missing arg or command\n\n{}", cmd.self_usage());
-        if let Some(lst) = cmd.self_command_list() {
-            println!("\n{}", lst);
-        }
+        println!("Missing arg or command; run 'asusctl slash --help' for usage");
     }
 
     let slashes = find_iface::<SlashProxyBlocking>("xyz.ljones.Slash")?;
@@ -698,13 +591,8 @@ 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())
-        || cmd.help
-    {
-        println!("Missing arg or command\n\n{}", cmd.self_usage());
-        if let Some(lst) = cmd.self_command_list() {
-            println!("\n{}", lst);
-        }
+    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");
     }
 
     let scsis = find_iface::<ScsiAuraProxyBlocking>("xyz.ljones.ScsiAura")?;
@@ -770,38 +658,15 @@ 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 {
-        if !mode.help {
-            println!("Missing arg or command\n");
-        }
-        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")?;
+        println!("Missing arg or command; run 'asusctl aura --help' for usage");
+        // print available modes when possible
+        if let Ok(aura) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
             let modes = aura.first().unwrap().supported_basic_modes()?;
-            for command in commands.iter().filter(|command| {
-                for mode in &modes {
-                    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!("Available modes:");
+            for m in modes {
+                println!("  {:?}", m);
             }
         }
-
-        println!("\nHelp can also be requested on modes, e.g: static --help");
         return Ok(());
     }
 
@@ -833,10 +698,6 @@ 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))?;
         }
@@ -859,10 +720,7 @@ fn handle_led_power1(power: &LedPowerCommand1) -> Result<(), Box<dyn std::error:
             && !power.keyboard
             && !power.lightbar
         {
-            if !power.help {
-                println!("Missing arg or command\n");
-            }
-            println!("{}\n", power.self_usage());
+            println!("Missing arg or command; run 'asusctl aura-power-old --help' for usage");
             return Ok(());
         }
 
@@ -914,51 +772,47 @@ fn handle_led_power2(power: &LedPowerCommand2) -> Result<(), Box<dyn std::error:
             continue;
         }
 
-        if power.command().is_none() {
-            if !power.help {
-                println!("Missing arg or command\n");
-            }
-            println!("{}\n", power.self_usage());
+        if power.command.is_none() {
+            println!("Missing arg or command; run 'asusctl aura-power --help' for 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 pow.help_requested() {
-                println!("{}", pow.self_usage());
-                return Ok(());
-            }
-
+        if let Some(_pow) = power.command.as_ref() {
             let mut states = aura.led_power()?;
-            let mut set = |zone: PowerZones, set_to: &AuraPowerStates| {
-                for state in states.states.iter_mut() {
-                    if state.zone == zone {
-                        state.boot = set_to.boot;
-                        state.awake = set_to.awake;
-                        state.sleep = set_to.sleep;
-                        state.shutdown = set_to.shutdown;
-                        break;
+            let mut set =
+                |zone: PowerZones, boot_v: bool, awake_v: bool, sleep_v: bool, shutdown_v: bool| {
+                    for state in states.states.iter_mut() {
+                        if state.zone == zone {
+                            state.boot = boot_v;
+                            state.awake = awake_v;
+                            state.sleep = sleep_v;
+                            state.shutdown = shutdown_v;
+                            break;
+                        }
                     }
-                }
-            };
+                };
 
             if let Some(cmd) = &power.command {
                 match cmd {
-                    aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(PowerZones::Keyboard, k),
-                    aura_cli::SetAuraZoneEnabled::Logo(l) => set(PowerZones::Logo, l),
-                    aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(PowerZones::Lightbar, l),
-                    aura_cli::SetAuraZoneEnabled::Lid(l) => set(PowerZones::Lid, l),
-                    aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(PowerZones::RearGlow, r),
-                    aura_cli::SetAuraZoneEnabled::Ally(r) => set(PowerZones::Ally, r),
+                    aura_cli::SetAuraZoneEnabled::Keyboard(k) => {
+                        set(PowerZones::Keyboard, k.boot, k.awake, k.sleep, k.shutdown)
+                    }
+                    aura_cli::SetAuraZoneEnabled::Logo(l) => {
+                        set(PowerZones::Logo, l.boot, l.awake, l.sleep, l.shutdown)
+                    }
+                    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)
+                    }
                 }
             }
 
@@ -979,36 +833,37 @@ fn handle_throttle_profile(
         return Err(ProfileError::NotSupported.into());
     }
 
-    if !cmd.next && !cmd.list && cmd.profile_set.is_none() && !cmd.profile_get {
-        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()?;
 
-    if cmd.next {
-        proxy.set_platform_profile(PlatformProfile::next(current, &choices))?;
-    } else if let Some(profile) = cmd.profile_set {
-        proxy.set_platform_profile(profile)?;
-    }
-
-    if cmd.list {
-        for p in &choices {
-            println!("{:?}", p);
+    match &cmd.command {
+        crate::cli_opts::ProfileSubCommand::Next(_) => {
+            proxy.set_platform_profile(PlatformProfile::next(current, &choices))?;
+        }
+        crate::cli_opts::ProfileSubCommand::Set(s) => {
+            if !s.ac && !s.battery {
+                proxy.set_platform_profile(s.profile)?;
+            } else {
+                if s.ac {
+                    proxy.set_platform_profile_on_ac(s.profile)?;
+                }
+                if s.battery {
+                    proxy.set_platform_profile_on_battery(s.profile)?;
+                }
+            }
+        }
+        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:?}");
     }
 
     Ok(())
@@ -1025,14 +880,7 @@ fn handle_fan_curve(
     };
 
     if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
-        if !cmd.help {
-            println!("Missing arg or command\n");
-        }
-        println!("{}", FanCurveCommand::usage());
-
-        if let Some(lst) = cmd.self_command_list() {
-            println!("\n{}", lst);
-        }
+        println!("Missing arg or command; run 'asusctl fan-curve --help' for usage");
         return Ok(());
     }
 
@@ -1169,34 +1017,35 @@ fn print_firmware_attr(attr: &AsusArmouryProxyBlocking) -> Result<(), Box<dyn st
     Ok(())
 }
 
+#[allow(clippy::manual_is_multiple_of, clippy::nonminimal_bool)]
 fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error::Error>> {
-    {
-        if cmd.free.is_empty() || cmd.free.len() % 2 != 0 || cmd.help {
-            const USAGE: &str = "Usage: asusctl platform panel_overdrive 1 nv_dynamic_boost 5";
-            if cmd.free.len() % 2 != 0 {
-                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() {
+    // If nested subcommand provided, handle set/get/list.
+    match &cmd.command {
+        ArmourySubCommand::List(_) => {
+            if let Ok(attrs) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
+                for attr in attrs.iter() {
                     print_firmware_attr(attr)?;
                 }
             }
-            return Ok(());
+            Ok(())
         }
-
-        if let Ok(attr) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
-            for cmd in cmd.free.chunks(2) {
-                for attr in attr.iter() {
+        ArmourySubCommand::Get(g) => {
+            if let Ok(attrs) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
+                for attr in attrs.iter() {
                     let name = attr.name()?;
-                    if <&str>::from(name) == cmd[0] {
-                        let mut value: i32 = cmd[1].parse()?;
+                    if <&str>::from(name) == g.property {
+                        print_firmware_attr(attr)?;
+                    }
+                }
+            }
+            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()?;
@@ -1206,7 +1055,7 @@ fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error
                     }
                 }
             }
+            Ok(())
         }
     }
-    Ok(())
 }

asusctl/src/scsi_cli.rs

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

asusctl/src/slash_cli.rs

@@ -1,37 +1,34 @@
-use gumdrop::Options;
+use argh::FromArgs;
 use rog_slash::SlashMode;
 
-#[derive(Options)]
+#[derive(FromArgs, Debug)]
+#[argh(subcommand, name = "slash", description = "slash ledbar commands")]
 pub struct SlashCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(help = "Enable the Slash Ledbar")]
+    #[argh(switch, description = "enable the Slash Ledbar")]
     pub enable: bool,
-    #[options(help = "Disable the Slash Ledbar")]
+    #[argh(switch, description = "disable the Slash Ledbar")]
     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>,
-    #[options(meta = "", help = "Set interval value <0-5>")]
+    #[argh(option, description = "set interval value <0-5>")]
     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>,
-    #[options(help = "list available animations")]
+    #[argh(switch, description = "list available animations")]
     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>,
-    #[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>,
-    #[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>,
-    #[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>,
-    // #[options(short = "L", meta = "", help = "Show the animation on lid closed")]
-    // pub show_on_lid_closed: Option<bool>,
-    #[options(
-        short = "w",
-        meta = "",
-        help = "Show the low-battery warning animation"
+    #[argh(
+        option,
+        short = 'w',
+        description = "show the low-battery warning animation"
     )]
     pub show_battery_warning: Option<bool>,
 }

asusd-user/Cargo.toml

@@ -32,3 +32,16 @@ config-traits = { path = "../config-traits" }
 
 zbus.workspace = true
 env_logger.workspace = true
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+An user utility for Linux to control fancy things on various ASUS laptops
+like keyboard effects or anime matrix animation cycles."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusd-user", "usr/bin/", "755"],
+  ["../asusd_user-fakeinstall/usr/lib/systemd/user/*", "usr/lib/systemd/user/", "644"],
+]

asusd/Cargo.toml

@@ -45,3 +45,18 @@ concat-idents.workspace = true
 
 [dev-dependencies]
 cargo-husky.workspace = true
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+The dbus server for asusctl and rog-control-center applications."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/asusd", "usr/bin/", "755"],
+  ["../asusd-fakeinstall/usr/lib/systemd/system/*", "usr/lib/systemd/system/", "644"],
+  ["../asusd-fakeinstall/usr/lib/udev/rules.d/*", "usr/lib/udev/rules.d/", "644"],
+  ["../asusd-fakeinstall/usr/share/asusd/*", "usr/share/share/asusd/", "644"],
+  ["../asusd-fakeinstall/usr/share/dbus-1/system.d/*", "usr/share/dbus-1/system.d/", "644"],
+]

asusd/src/asus_armoury.rs

@@ -1,12 +1,14 @@
 use std::sync::Arc;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
-use log::{debug, error, info};
-use rog_platform::asus_armoury::{AttrValue, Attribute, FirmwareAttribute, FirmwareAttributes};
+use log::{debug, error, info, warn};
+use rog_platform::asus_armoury::{
+    AttrValue, Attribute, FirmwareAttribute, FirmwareAttributeType, FirmwareAttributes,
+};
 use rog_platform::platform::{PlatformProfile, RogPlatform};
 use rog_platform::power::AsusPower;
 use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
 use zbus::object_server::SignalEmitter;
 use zbus::zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Type, Value};
 use zbus::{fdo, interface, Connection};
@@ -51,6 +53,29 @@ impl AsusArmouryAttribute {
         }
     }
 
+    pub fn attribute_name(&self) -> String {
+        String::from(self.attr.name())
+    }
+
+    fn resolve_i32_value(refreshed: Option<i32>, cached: &AttrValue) -> i32 {
+        refreshed
+            .or(match cached {
+                AttrValue::Integer(i) => Some(*i),
+                _ => None,
+            })
+            .unwrap_or(-1)
+    }
+
+    pub async fn emit_limits(&self, connection: &Connection) -> Result<(), RogError> {
+        let path = dbus_path_for_attr(self.attr.name());
+        let signal = SignalEmitter::new(connection, path)?;
+        self.min_value_changed(&signal).await?;
+        self.max_value_changed(&signal).await?;
+        self.scalar_increment_changed(&signal).await?;
+        self.current_value_changed(&signal).await?;
+        Ok(())
+    }
+
     pub async fn move_to_zbus(self, connection: &Connection) -> Result<(), RogError> {
         let path = dbus_path_for_attr(self.attr.name());
         connection
@@ -78,14 +103,20 @@ impl AsusArmouryAttribute {
                         let sig = signal_ctxt.clone();
                         tokio::spawn(async move {
                             let mut buffer = [0; 32];
-                            watch
-                                .into_event_stream(&mut buffer)
-                                .unwrap()
-                                .for_each(|_| async {
-                                    debug!("{} changed", name);
-                                    ctrl.$fn_prop_changed(&sig).await.ok();
-                                })
-                                .await;
+                            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
+                                stream
+                                    .for_each(|_| async {
+                                        debug!("{} changed", name);
+                                        ctrl.$fn_prop_changed(&sig).await.ok();
+                                    })
+                                    .await;
+                            } else {
+                                info!(
+                                    "inotify event stream failed for {} ({}). You can ignore this \
+                                     if unsupported",
+                                    name, $attr_str
+                                );
+                            }
                         });
                     }
                     Err(e) => info!(
@@ -107,43 +138,96 @@ impl AsusArmouryAttribute {
     }
 }
 
+#[derive(Clone, Default)]
+pub struct ArmouryAttributeRegistry {
+    attrs: Vec<AsusArmouryAttribute>,
+}
+
+impl ArmouryAttributeRegistry {
+    pub fn push(&mut self, attr: AsusArmouryAttribute) {
+        self.attrs.push(attr);
+    }
+
+    pub async fn emit_limits(&self, connection: &Connection) -> Result<(), RogError> {
+        let mut last_err: Option<RogError> = None;
+        for attr in &self.attrs {
+            if let Err(e) = attr.emit_limits(connection).await {
+                error!(
+                    "Failed to emit updated limits for attribute '{}': {e:?}",
+                    attr.attribute_name()
+                );
+                last_err = Some(e);
+            }
+        }
+        if let Some(err) = last_err {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+}
+
 impl crate::Reloadable for AsusArmouryAttribute {
     async fn reload(&mut self) -> Result<(), RogError> {
         info!("Reloading {}", self.attr.name());
-        let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
-        let power_plugged = self
-            .power
-            .get_online()
-            .map_err(|e| {
-                error!("Could not get power status: {e:?}");
-                e
-            })
-            .unwrap_or_default();
-        let config = if power_plugged == 1 {
-            &self.config.lock().await.ac_profile_tunings
-        } else {
-            &self.config.lock().await.dc_profile_tunings
-        };
-        if let Some(tuning) = config.get(&profile) {
-            if tuning.enabled {
-                if let Some(tune) = tuning.group.get(&self.name()) {
-                    self.attr
-                        .set_current_value(&AttrValue::Integer(*tune))
-                        .map_err(|e| {
-                            error!("Could not set {} value: {e:?}", self.attr.name());
-                            self.attr.base_path_exists();
-                            e
-                        })?;
-                    info!("Set {} to {:?}", self.attr.name(), tune);
+        let attribute: FirmwareAttribute = self.attr.name().into();
+        let name = self.attr.name();
+
+        let config = self.config.lock().await;
+        let apply_value = match attribute.property_type() {
+            FirmwareAttributeType::Ppt => {
+                let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+                let power_plugged = self
+                    .power
+                    .get_online()
+                    .map_err(|e| {
+                        error!("Could not get power status: {e:?}");
+                        e
+                    })
+                    .unwrap_or_default()
+                    == 1;
+
+                let apply_value = {
+                    config.select_tunings_ref(power_plugged, profile).and_then(
+                        |tuning| match tuning.enabled {
+                            true => tuning.group.get(&self.name()).copied(),
+                            false => None,
+                        },
+                    )
+                };
+
+                apply_value.map_or(AttrValue::None, AttrValue::Integer)
+            }
+            FirmwareAttributeType::Gpu => {
+                info!("Reload called on GPU attribute {name}: doing nothing");
+                AttrValue::None
+            }
+            _ => {
+                info!("Reload called on firmware attribute {name}");
+                match config.armoury_settings.get(&attribute) {
+                    Some(saved_value) => AttrValue::Integer(*saved_value),
+                    None => AttrValue::None,
                 }
             }
-        }
+        };
+
+        self.attr.set_current_value(&apply_value).map_err(|e| {
+            error!("Could not set {} value: {e:?}", self.attr.name());
+            self.attr.base_path_exists();
+            e
+        })?;
+
+        info!(
+            "Restored asus-armoury setting {} to {:?}",
+            self.attr.name(),
+            apply_value
+        );
 
         Ok(())
     }
 }
 
-/// If return is `-1` on a property then there is avilable value for that
+/// If return is `-1` on a property then there is available value for that
 /// property
 #[interface(name = "xyz.ljones.AsusArmoury")]
 impl AsusArmouryAttribute {
@@ -193,7 +277,7 @@ impl AsusArmouryAttribute {
 
     async fn restore_default(&self) -> fdo::Result<()> {
         self.attr.restore_default()?;
-        if self.name().is_ppt() {
+        if self.name().property_type() == FirmwareAttributeType::Ppt {
             let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
             let power_plugged = self
                 .power
@@ -226,26 +310,20 @@ impl AsusArmouryAttribute {
 
     #[zbus(property)]
     async fn min_value(&self) -> i32 {
-        match self.attr.min_value() {
-            AttrValue::Integer(i) => *i,
-            _ => -1,
-        }
+        Self::resolve_i32_value(self.attr.refresh_min_value(), self.attr.min_value())
     }
 
     #[zbus(property)]
     async fn max_value(&self) -> i32 {
-        match self.attr.max_value() {
-            AttrValue::Integer(i) => *i,
-            _ => -1,
-        }
+        Self::resolve_i32_value(self.attr.refresh_max_value(), self.attr.max_value())
     }
 
     #[zbus(property)]
     async fn scalar_increment(&self) -> i32 {
-        match self.attr.scalar_increment() {
-            AttrValue::Integer(i) => *i,
-            _ => -1,
-        }
+        Self::resolve_i32_value(
+            self.attr.refresh_scalar_increment(),
+            self.attr.scalar_increment(),
+        )
     }
 
     #[zbus(property)]
@@ -258,7 +336,7 @@ impl AsusArmouryAttribute {
 
     #[zbus(property)]
     async fn current_value(&self) -> fdo::Result<i32> {
-        if self.name().is_ppt() {
+        if self.name().property_type() == FirmwareAttributeType::Ppt {
             let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
             let power_plugged = self
                 .power
@@ -267,12 +345,15 @@ impl AsusArmouryAttribute {
                     error!("Could not get power status: {e:?}");
                     e
                 })
-                .unwrap_or_default();
-            let mut config = self.config.lock().await;
-            let tuning = config.select_tunings(power_plugged == 1, profile);
-            if let Some(tune) = tuning.group.get(&self.name()) {
-                return Ok(*tune);
-            } else if let AttrValue::Integer(i) = self.attr.default_value() {
+                .unwrap_or_default()
+                == 1;
+            let config = self.config.lock().await;
+            if let Some(tuning) = config.select_tunings_ref(power_plugged, profile) {
+                if let Some(tune) = tuning.group.get(&self.name()) {
+                    return Ok(*tune);
+                }
+            }
+            if let AttrValue::Integer(i) = self.attr.default_value() {
                 return Ok(*i);
             }
             return Err(fdo::Error::Failed(
@@ -290,68 +371,64 @@ impl AsusArmouryAttribute {
 
     #[zbus(property)]
     async fn set_current_value(&mut self, value: i32) -> fdo::Result<()> {
-        if self.name().is_ppt() {
-            let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
-            let power_plugged = self
-                .power
-                .get_online()
-                .map_err(|e| {
-                    error!("Could not get power status: {e:?}");
-                    e
-                })
-                .unwrap_or_default();
-
-            let mut config = self.config.lock().await;
-            let tuning = config.select_tunings(power_plugged == 1, profile);
-
-            if let Some(tune) = tuning.group.get_mut(&self.name()) {
-                *tune = value;
-            } else {
-                tuning.group.insert(self.name(), value);
-                debug!("Store tuning config for {} = {:?}", self.attr.name(), value);
-            }
-            if tuning.enabled {
-                self.attr
-                    .set_current_value(&AttrValue::Integer(value))
+        let name = self.attr.name();
+        let apply_value = match self.name().property_type() {
+            FirmwareAttributeType::Ppt => {
+                let profile: PlatformProfile = self.platform.get_platform_profile()?.into();
+                let power_plugged = self
+                    .power
+                    .get_online()
                     .map_err(|e| {
-                        error!("Could not set value: {e:?}");
+                        error!("Could not get power status: {e:?}");
                         e
-                    })?;
-            }
-        } else {
-            self.attr
-                .set_current_value(&AttrValue::Integer(value))
-                .map_err(|e| {
-                    error!("Could not set value: {e:?}");
-                    e
-                })?;
+                    })
+                    .unwrap_or_default();
 
-            let has_attr = self
-                .config
-                .lock()
-                .await
-                .armoury_settings
-                .contains_key(&self.name());
-            if has_attr {
-                if let Some(setting) = self
-                    .config
-                    .lock()
-                    .await
-                    .armoury_settings
-                    .get_mut(&self.name())
-                {
-                    *setting = value
+                let mut config = self.config.lock().await;
+                let tuning = config.select_tunings(power_plugged == 1, profile);
+
+                if let Some(tune) = tuning.group.get_mut(&self.name()) {
+                    *tune = value;
+                } else {
+                    tuning.group.insert(self.name(), value);
+                    debug!("Store tuning config for {name} = {:?}", value);
+                }
+
+                match tuning.enabled {
+                    true => {
+                        debug!("Tuning is enabled: setting value to PPT property {name} = {value}");
+                        AttrValue::Integer(value)
+                    }
+                    false => {
+                        warn!("Tuning is disabled: skipping setting value to PPT property {name}");
+                        AttrValue::None
+                    }
                 }
-            } 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);
             }
-        }
+            _ => {
+                let mut settings = self.config.lock().await;
+                settings
+                    .armoury_settings
+                    .entry(self.name())
+                    .and_modify(|setting| {
+                        debug!("Set config for {name} = {value}");
+                        *setting = value;
+                    })
+                    .or_insert_with(|| {
+                        debug!("Adding config for {name} = {value}");
+                        value
+                    });
+
+                AttrValue::Integer(value)
+            }
+        };
+
+        self.attr.set_current_value(&apply_value).map_err(|e| {
+            error!("Could not set value {value} to attribute {name}: {e:?}");
+            e
+        })?;
+
+        // write config after setting value
         self.config.lock().await.write();
         Ok(())
     }
@@ -363,7 +440,8 @@ pub async fn start_attributes_zbus(
     power: AsusPower,
     attributes: FirmwareAttributes,
     config: Arc<Mutex<Config>>,
-) -> Result<(), RogError> {
+) -> Result<ArmouryAttributeRegistry, RogError> {
+    let mut registry = ArmouryAttributeRegistry::default();
     for attr in attributes.attributes() {
         let mut attr = AsusArmouryAttribute::new(
             attr.clone(),
@@ -371,15 +449,42 @@ pub async fn start_attributes_zbus(
             power.clone(),
             config.clone(),
         );
-        attr.reload().await?;
 
-        let path = dbus_path_for_attr(attr.attr.name());
-        let sig = zbus::object_server::SignalEmitter::new(conn, path)?;
-        attr.watch_and_notify(sig).await?;
+        let registry_attr = attr.clone();
 
-        attr.move_to_zbus(conn).await?;
+        if let Err(e) = attr.reload().await {
+            error!(
+                "Skipping attribute '{}' due to reload error: {e:?}",
+                attr.attr.name()
+            );
+            break;
+        }
+
+        let attr_name = attr.attribute_name();
+
+        let path = dbus_path_for_attr(attr_name.as_str());
+        match zbus::object_server::SignalEmitter::new(conn, path) {
+            Ok(sig) => {
+                if let Err(e) = attr.watch_and_notify(sig).await {
+                    error!("Failed to start watcher for '{}': {e:?}", attr.attr.name());
+                }
+            }
+            Err(e) => {
+                error!(
+                    "Failed to create SignalEmitter for '{}': {e:?}",
+                    attr.attr.name()
+                );
+            }
+        }
+
+        if let Err(e) = attr.move_to_zbus(conn).await {
+            error!("Failed to register attribute '{attr_name}' on zbus: {e:?}");
+            continue;
+        }
+
+        registry.push(registry_attr);
     }
-    Ok(())
+    Ok(registry)
 }
 
 pub async fn set_config_or_default(
@@ -390,7 +495,7 @@ pub async fn set_config_or_default(
 ) {
     for attr in attrs.attributes().iter() {
         let name: FirmwareAttribute = attr.name().into();
-        if name.is_ppt() {
+        if name.property_type() == FirmwareAttributeType::Ppt {
             let tuning = config.select_tunings(power_plugged, profile);
             if !tuning.enabled {
                 debug!("Tuning group is not enabled, skipping");
@@ -420,6 +525,20 @@ pub async fn set_config_or_default(
                     // config.write();
                 }
             }
+        } else {
+            // Handle non-PPT attributes (boolean and other settings)
+            if let Some(saved_value) = config.armoury_settings.get(&name) {
+                attr.set_current_value(&AttrValue::Integer(*saved_value))
+                    .map_err(|e| {
+                        error!("Failed to set {}: {e}", <&str>::from(name));
+                    })
+                    .ok();
+                info!(
+                    "Restored armoury setting for {} = {:?}",
+                    <&str>::from(name),
+                    saved_value
+                );
+            }
         }
     }
 }

asusd/src/aura_anime/mod.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 use std::thread::sleep;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use rog_anime::usb::{
     pkt_flush, pkt_set_brightness, pkt_set_enable_display, pkt_set_enable_powersave_anim,
@@ -17,6 +16,7 @@ use rog_anime::usb::{
 use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::usb_raw::USBRaw;
+use tokio::sync::Mutex;
 
 use self::config::{AniMeConfig, AniMeConfigCached};
 use crate::error::RogError;
@@ -51,7 +51,7 @@ impl AniMe {
 
     /// Will fail if something is already holding the config lock
     async fn do_init_cache(&mut self) {
-        if let Some(mut config) = self.config.try_lock() {
+        if let Ok(mut config) = self.config.try_lock() {
             if let Err(e) = self.cache.init_from_config(&config, config.anime_type) {
                 error!(
                     "Trying to cache the Anime Config failed, will reset to default config: {e:?}"

asusd/src/aura_anime/trait_impls.rs

@@ -85,7 +85,7 @@ impl AniMeZbus {
     /// Set base brightness level
     #[zbus(property)]
     async fn brightness(&self) -> Brightness {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.display_brightness;
         }
         Brightness::Off
@@ -117,7 +117,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn builtins_enabled(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.builtin_anims_enabled;
         }
         false
@@ -162,7 +162,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn builtin_animations(&self) -> Animations {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.builtin_anims;
         }
         Animations::default()
@@ -195,7 +195,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn enable_display(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.display_enabled;
         }
         false
@@ -218,7 +218,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_unplugged(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_unplugged;
         }
         false
@@ -245,7 +245,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_suspended(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_suspended;
         }
         false
@@ -261,7 +261,7 @@ impl AniMeZbus {
 
     #[zbus(property)]
     async fn off_when_lid_closed(&self) -> bool {
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             return config.off_when_lid_closed;
         }
         false

asusd/src/aura_laptop/config.rs

@@ -82,8 +82,9 @@ impl AuraConfig {
             config
                 .builtins
                 .insert(*n, AuraEffect::default_with_mode(*n));
-
-            if !config.support_data.basic_zones.is_empty() {
+        }
+        if !config.support_data.basic_zones.is_empty() {
+            for n in &config.support_data.basic_modes {
                 let mut default = vec![];
                 for (i, tmp) in config.support_data.basic_zones.iter().enumerate() {
                     default.push(AuraEffect {
@@ -118,14 +119,14 @@ impl AuraConfig {
             self.multizone_on = false;
         } else {
             if let Some(multi) = self.multizone.as_mut() {
-                if let Some(fx) = multi.get_mut(effect.mode()) {
-                    for fx in fx.iter_mut() {
+                if let Some(fx_vec) = multi.get_mut(effect.mode()) {
+                    for fx in fx_vec.iter_mut() {
                         if fx.zone == effect.zone {
                             *fx = effect;
                             return;
                         }
                     }
-                    fx.push(effect);
+                    fx_vec.push(effect);
                 } else {
                     multi.insert(*effect.mode(), vec![effect]);
                 }
@@ -230,6 +231,8 @@ impl AuraConfig {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::{Mutex, MutexGuard, OnceLock};
+
     use rog_aura::keyboard::AuraPowerState;
     use rog_aura::{
         AuraEffect, AuraModeNum, AuraZone, Colour, Direction, LedBrightness, PowerZones, Speed,
@@ -237,8 +240,20 @@ mod tests {
 
     use super::AuraConfig;
 
+    // Global mutex to serialize tests that rely on process-wide environment
+    // variables
+    static TEST_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+
+    fn test_lock() -> MutexGuard<'static, ()> {
+        TEST_MUTEX
+            .get_or_init(|| Mutex::new(()))
+            .lock()
+            .expect("TEST_MUTEX poisoned")
+    }
+
     #[test]
     fn set_multizone_4key_config() {
+        let _guard = test_lock();
         std::env::set_var("BOARD_NAME", "");
         let mut config = AuraConfig::new("19b6");
 
@@ -294,30 +309,43 @@ mod tests {
         let res = config.multizone.unwrap();
         let sta = res.get(&AuraModeNum::Static).unwrap();
         assert_eq!(sta.len(), 4);
-        assert_eq!(sta[0].colour1, Colour {
-            r: 0xff,
-            g: 0x00,
-            b: 0xff
-        });
-        assert_eq!(sta[1].colour1, Colour {
-            r: 0x00,
-            g: 0xff,
-            b: 0xff
-        });
-        assert_eq!(sta[2].colour1, Colour {
-            r: 0xff,
-            g: 0xff,
-            b: 0x00
-        });
-        assert_eq!(sta[3].colour1, Colour {
-            r: 0x00,
-            g: 0xff,
-            b: 0x00
-        });
+        assert_eq!(
+            sta[0].colour1,
+            Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[1].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[2].colour1,
+            Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+        assert_eq!(
+            sta[3].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00
+            }
+        );
     }
 
     #[test]
     fn set_multizone_multimode_config() {
+        let _guard = test_lock();
         std::env::set_var("BOARD_NAME", "");
         let mut config = AuraConfig::new("19b6");
 
@@ -366,51 +394,65 @@ mod tests {
 
     #[test]
     fn verify_0x1866_g531i() {
+        let _guard = test_lock();
         std::env::set_var("BOARD_NAME", "G513I");
         let mut config = AuraConfig::new("1866");
 
         assert_eq!(config.brightness, LedBrightness::Med);
         assert_eq!(config.builtins.len(), 5);
-        assert_eq!(config.builtins.first_entry().unwrap().get(), &AuraEffect {
-            mode: AuraModeNum::Static,
-            zone: AuraZone::None,
-            colour1: Colour { r: 166, g: 0, b: 0 },
-            colour2: Colour { r: 0, g: 0, b: 0 },
-            speed: Speed::Med,
-            direction: Direction::Right
-        });
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
         assert_eq!(config.enabled.states.len(), 1);
-        assert_eq!(config.enabled.states[0], AuraPowerState {
-            zone: PowerZones::KeyboardAndLightbar,
-            boot: true,
-            awake: true,
-            sleep: true,
-            shutdown: true
-        });
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::KeyboardAndLightbar,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
     }
 
     #[test]
     fn verify_0x19b6_g634j() {
+        let _guard = test_lock();
         std::env::set_var("BOARD_NAME", "G634J");
         let mut config = AuraConfig::new("19b6");
 
         assert_eq!(config.brightness, LedBrightness::Med);
         assert_eq!(config.builtins.len(), 12);
-        assert_eq!(config.builtins.first_entry().unwrap().get(), &AuraEffect {
-            mode: AuraModeNum::Static,
-            zone: AuraZone::None,
-            colour1: Colour { r: 166, g: 0, b: 0 },
-            colour2: Colour { r: 0, g: 0, b: 0 },
-            speed: Speed::Med,
-            direction: Direction::Right
-        });
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
         assert_eq!(config.enabled.states.len(), 4);
-        assert_eq!(config.enabled.states[0], AuraPowerState {
-            zone: PowerZones::Keyboard,
-            boot: true,
-            awake: true,
-            sleep: true,
-            shutdown: true
-        });
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::Keyboard,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
     }
 }

asusd/src/aura_laptop/mod.rs

@@ -2,13 +2,13 @@ use std::sync::Arc;
 
 use config::AuraConfig;
 use config_traits::StdConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use log::info;
 use rog_aura::keyboard::{AuraLaptopUsbPackets, LedUsbPackets};
 use rog_aura::usb::{AURA_LAPTOP_LED_APPLY, AURA_LAPTOP_LED_SET};
 use rog_aura::{AuraDeviceType, AuraEffect, LedBrightness, PowerZones, AURA_LAPTOP_LED_MSG_LEN};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::keyboard_led::KeyboardBacklight;
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 
@@ -28,7 +28,7 @@ impl Aura {
         Ok(())
     }
 
-    pub async fn lock_config(&self) -> MutexGuard<AuraConfig> {
+    pub async fn lock_config(&self) -> MutexGuard<'_, AuraConfig> {
         self.config.lock().await
     }
 

asusd/src/aura_laptop/trait_impls.rs

@@ -71,7 +71,13 @@ impl AuraZbus {
     #[zbus(property)]
     async fn set_brightness(&mut self, brightness: LedBrightness) -> Result<(), ZbErr> {
         if let Some(bl) = self.0.backlight.as_ref() {
-            return Ok(bl.lock().await.set_brightness(brightness.into())?);
+            let res = bl.lock().await.set_brightness(brightness.into());
+            if res.is_ok() {
+                let mut config = self.0.config.lock().await;
+                config.brightness = brightness;
+                config.write();
+            }
+            return Ok(res?);
         }
         Err(ZbErr::Failed("No sysfs brightness control".to_string()))
     }
@@ -112,7 +118,7 @@ impl AuraZbus {
         // entirely possible to deadlock here, so use try instead of lock()
         // let ctrl = self.0.lock().await;
         // Ok(config.current_mode)
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             Ok(config.current_mode)
         } else {
             Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
@@ -140,7 +146,7 @@ impl AuraZbus {
     #[zbus(property)]
     async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
         // entirely possible to deadlock here, so use try instead of lock()
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             let mode = config.current_mode;
             match config.builtins.get(&mode) {
                 Some(effect) => Ok(effect.clone()),

asusd/src/aura_manager.rs

@@ -4,15 +4,16 @@
 // - Add it to Zbus server
 // - If udev sees device removed then remove the zbus path
 
+use std::collections::HashMap;
 use std::sync::Arc;
 
 use dmi_id::DMIID;
 use futures_lite::future::block_on;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use mio::{Events, Interest, Poll, Token};
 use rog_platform::error::PlatformError;
 use rog_platform::hid_raw::HidRaw;
+use tokio::sync::Mutex;
 use udev::{Device, MonitorBuilder};
 use zbus::zvariant::{ObjectPath, OwnedObjectPath};
 use zbus::Connection;
@@ -92,23 +93,46 @@ fn dev_prop_matches(dev: &Device, prop: &str, value: &str) -> bool {
 pub struct AsusDevice {
     device: DeviceHandle,
     dbus_path: OwnedObjectPath,
+    hid_key: Option<String>,
 }
 
 pub struct DeviceManager {
     _dbus_connection: Connection,
+    _hid_handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
 }
 
 impl DeviceManager {
+    #[allow(clippy::type_complexity)]
+    async fn get_or_create_hid_handle(
+        handles: &Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+        endpoint: &Device,
+    ) -> Result<(Arc<Mutex<HidRaw>>, String), RogError> {
+        let dev_node = endpoint
+            .devnode()
+            .ok_or_else(|| RogError::MissingFunction("hidraw devnode missing".to_string()))?;
+        let key = dev_node.to_string_lossy().to_string();
+
+        if let Some(existing) = handles.lock().await.get(&key).cloned() {
+            return Ok((existing, key));
+        }
+
+        let hidraw = HidRaw::from_device(endpoint.clone())?;
+        let handle = Arc::new(Mutex::new(hidraw));
+        handles.lock().await.insert(key.clone(), handle.clone());
+        Ok((handle, key))
+    }
+
     async fn init_hid_devices(
         connection: &Connection,
         device: Device,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
     ) -> Result<Vec<AsusDevice>, RogError> {
         let mut devices = Vec::new();
         if let Some(usb_device) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
             if let Some(usb_id) = usb_device.attribute_value("idProduct") {
                 if let Some(vendor_id) = usb_device.attribute_value("idVendor") {
                     if vendor_id != "0b05" {
-                        debug!("Not ASUS vendor ID");
+                        debug!("Not ASUS vendor ID: {}", vendor_id.to_string_lossy());
                         return Ok(devices);
                     }
                     // Almost all devices are identified by the productId.
@@ -116,9 +140,10 @@ impl DeviceManager {
                     // 1. Generate an interface path
                     // 2. Create the device
                     // Use the top-level endpoint, not the parent
-                    if let Ok(hidraw) = HidRaw::from_device(device) {
+                    if let Ok((dev, hid_key)) =
+                        Self::get_or_create_hid_handle(&handles, &device).await
+                    {
                         debug!("Testing device {usb_id:?}");
-                        let dev = Arc::new(Mutex::new(hidraw));
                         // SLASH DEVICE
                         if let Ok(dev_type) = DeviceHandle::new_slash_hid(
                             dev.clone(),
@@ -134,6 +159,7 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
                                 });
                             }
                         }
@@ -152,6 +178,7 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key.clone()),
                                 });
                             }
                         }
@@ -170,9 +197,12 @@ impl DeviceManager {
                                 devices.push(AsusDevice {
                                     device: dev_type,
                                     dbus_path: path,
+                                    hid_key: Some(hid_key),
                                 });
                             }
                         }
+                    } else {
+                        warn!("Failed to initialise shared hid handle for {usb_id:?}");
                     }
                 }
             }
@@ -181,7 +211,10 @@ impl DeviceManager {
     }
 
     /// To be called on daemon startup
-    async fn init_all_hid(connection: &Connection) -> Result<Vec<AsusDevice>, RogError> {
+    async fn init_all_hid(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Result<Vec<AsusDevice>, RogError> {
         // track and ensure we use only one hidraw per prod_id
         // let mut interfaces = HashSet::new();
         let mut devices: Vec<AsusDevice> = Vec::new();
@@ -200,7 +233,7 @@ impl DeviceManager {
             .scan_devices()
             .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
         {
-            devices.append(&mut Self::init_hid_devices(connection, device).await?);
+            devices.append(&mut Self::init_hid_devices(connection, device, handles.clone()).await?);
         }
 
         Ok(devices)
@@ -228,6 +261,7 @@ impl DeviceManager {
                         return Some(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -275,10 +309,13 @@ impl DeviceManager {
         Ok(devices)
     }
 
-    pub async fn find_all_devices(connection: &Connection) -> Vec<AsusDevice> {
+    pub async fn find_all_devices(
+        connection: &Connection,
+        handles: Arc<Mutex<HashMap<String, Arc<Mutex<HidRaw>>>>>,
+    ) -> Vec<AsusDevice> {
         let mut devices: Vec<AsusDevice> = Vec::new();
         // HID first, always
-        if let Ok(devs) = &mut Self::init_all_hid(connection).await {
+        if let Ok(devs) = &mut Self::init_all_hid(connection, handles.clone()).await {
             devices.append(devs);
         }
         // USB after, need to check if HID picked something up and if so, skip it
@@ -306,6 +343,7 @@ impl DeviceManager {
                     devices.push(AsusDevice {
                         device: dev_type,
                         dbus_path: path,
+                        hid_key: None,
                     });
                 }
             } else {
@@ -328,6 +366,7 @@ impl DeviceManager {
                         devices.push(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -355,6 +394,7 @@ impl DeviceManager {
                         devices.push(AsusDevice {
                             device: dev_type,
                             dbus_path: path,
+                            hid_key: None,
                         });
                     }
                 }
@@ -370,16 +410,19 @@ impl DeviceManager {
 
     pub async fn new(connection: Connection) -> Result<Self, RogError> {
         let conn_copy = connection.clone();
-        let devices = Self::find_all_devices(&conn_copy).await;
+        let hid_handles = Arc::new(Mutex::new(HashMap::new()));
+        let devices = Self::find_all_devices(&conn_copy, hid_handles.clone()).await;
         info!("Found {} valid devices on startup", devices.len());
         let devices = Arc::new(Mutex::new(devices));
         let manager = Self {
             _dbus_connection: connection,
+            _hid_handles: hid_handles.clone(),
         };
 
         // TODO: The /sysfs/ LEDs don't cause events, so they need to be manually
         // checked for and added
 
+        let hid_handles_thread = hid_handles.clone();
         std::thread::spawn(move || {
             let mut monitor = MonitorBuilder::new()?.listen()?;
             let mut poll = Poll::new()?;
@@ -408,6 +451,7 @@ impl DeviceManager {
 
                     let devices = devices.clone();
                     let conn_copy = conn_copy.clone();
+                    let hid_handles = hid_handles_thread.clone();
                     block_on(async move {
                         // SCSCI devs
                         if subsys == "block" {
@@ -483,6 +527,7 @@ impl DeviceManager {
                                         // Iter in reverse so as to not screw up indexing
                                         for index in removals.iter().rev() {
                                             let dev = devices.lock().await.remove(*index);
+                                            let hid_key = dev.hid_key.clone();
                                             let path = path.clone();
                                             let res = match dev.device {
                                                 DeviceHandle::Aura(_) => {
@@ -512,14 +557,20 @@ impl DeviceManager {
                                                 _ => todo!(),
                                             };
                                             info!("AuraManager removed: {path:?}, {res}");
+                                            if let Some(key) = hid_key {
+                                                hid_handles.lock().await.remove(&key);
+                                            }
                                         }
                                     }
                                 } else if action == "add" {
                                     let evdev = event.device();
-                                    if let Ok(mut new_devs) =
-                                        Self::init_hid_devices(&conn_copy, evdev)
-                                            .await
-                                            .map_err(|e| error!("Couldn't add new device: {e:?}"))
+                                    if let Ok(mut new_devs) = Self::init_hid_devices(
+                                        &conn_copy,
+                                        evdev,
+                                        hid_handles.clone(),
+                                    )
+                                    .await
+                                    .map_err(|e| error!("Couldn't add new device: {e:?}"))
                                     {
                                         devices.lock().await.append(&mut new_devs);
                                     }

asusd/src/aura_scsi/mod.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use config::ScsiConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use rog_scsi::{AuraEffect, Device, Task};
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 
@@ -20,7 +20,7 @@ impl ScsiAura {
         Self { device, config }
     }
 
-    pub async fn lock_config(&self) -> MutexGuard<ScsiConfig> {
+    pub async fn lock_config(&self) -> MutexGuard<'_, ScsiConfig> {
         self.config.lock().await
     }
 

asusd/src/aura_scsi/trait_impls.rs

@@ -83,7 +83,7 @@ impl ScsiZbus {
     #[zbus(property)]
     async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
         // entirely possible to deadlock here, so use try instead of lock()
-        if let Some(config) = self.0.config.try_lock() {
+        if let Ok(config) = self.0.config.try_lock() {
             let mode = config.current_mode;
             match config.modes.get(&mode) {
                 Some(effect) => Ok(effect.clone()),

asusd/src/aura_slash/mod.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use config::SlashConfig;
-use futures_util::lock::{Mutex, MutexGuard};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::usb_raw::USBRaw;
 use rog_slash::usb::{slash_pkt_enable, slash_pkt_init, slash_pkt_options, slash_pkt_set_mode};
+use tokio::sync::{Mutex, MutexGuard};
 
 use crate::error::RogError;
 
@@ -27,7 +27,7 @@ impl Slash {
         Self { hid, usb, config }
     }
 
-    pub async fn lock_config(&self) -> MutexGuard<SlashConfig> {
+    pub async fn lock_config(&self) -> MutexGuard<'_, SlashConfig> {
         self.config.lock().await
     }
 

asusd/src/aura_types.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use config_traits::{StdConfig, StdConfigLoad};
-use futures_util::lock::Mutex;
 use log::{debug, error, info};
 use rog_anime::error::AnimeError;
 use rog_anime::usb::get_anime_type;
@@ -13,6 +12,7 @@ use rog_platform::usb_raw::USBRaw;
 use rog_scsi::{open_device, ScsiType};
 use rog_slash::error::SlashError;
 use rog_slash::SlashType;
+use tokio::sync::Mutex;
 
 use crate::aura_anime::config::AniMeConfig;
 use crate::aura_anime::AniMe;

asusd/src/config.rs

@@ -8,6 +8,12 @@ use serde::{Deserialize, Serialize};
 
 const CONFIG_FILE: &str = "asusd.ron";
 
+/// Default value for base_charge_control_end_threshold when not present in config.
+/// Returns 0 so restore_charge_limit() skips restoration for upgraded configs.
+fn default_base_charge_limit() -> u8 {
+    0
+}
+
 #[derive(Default, Clone, Deserialize, Serialize, PartialEq)]
 pub struct Tuning {
     pub enabled: bool,
@@ -19,8 +25,8 @@ type Tunings = HashMap<PlatformProfile, Tuning>;
 pub struct Config {
     // The current charge limit applied
     pub charge_control_end_threshold: u8,
-    /// Save charge limit for restoring
-    #[serde(skip)]
+    /// Save charge limit for restoring after one-shot full charge
+    #[serde(default = "default_base_charge_limit")]
     pub base_charge_control_end_threshold: u8,
     pub disable_nvidia_powerd_on_battery: bool,
     /// An optional command/script to run when power is changed to AC
@@ -67,12 +73,28 @@ impl Config {
         };
         config.entry(profile).or_insert_with(Tuning::default)
     }
+
+    pub fn select_tunings_ref(
+        &self,
+        power_plugged: bool,
+        profile: PlatformProfile,
+    ) -> Option<&Tuning> {
+        let config = if power_plugged {
+            &self.ac_profile_tunings
+        } else {
+            &self.dc_profile_tunings
+        };
+        config.get(&profile)
+    }
 }
 
 impl Default for Config {
     fn default() -> Self {
         Self {
             charge_control_end_threshold: 100,
+            // NOTE: This is intentionally 100 (not 0 like the serde default).
+            // New installs get 100 (no limit). Upgraded configs missing this
+            // field get 0 via serde, which skips restore_charge_limit().
             base_charge_control_end_threshold: 100,
             disable_nvidia_powerd_on_battery: true,
             ac_command: Default::default(),
@@ -146,7 +168,7 @@ pub struct Config611 {
 
 impl From<Config611> for Config {
     fn from(c: Config611) -> Self {
-        Self {
+        let mut config = Self {
             // Restore the base charge limit
             charge_control_end_threshold: c.charge_control_end_threshold,
             base_charge_control_end_threshold: c.charge_control_end_threshold,
@@ -168,7 +190,12 @@ impl From<Config611> for Config {
             armoury_settings: HashMap::default(),
             screenpad_gamma: None,
             screenpad_sync_primary: Default::default(),
-        }
+        };
+
+        config.ac_profile_tunings = c.ac_profile_tunings;
+        config.dc_profile_tunings = c.dc_profile_tunings;
+        config.armoury_settings = c.armoury_settings;
+        config
     }
 }
 

asusd/src/ctrl_backlight.rs

@@ -2,9 +2,9 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{info, warn};
 use rog_platform::backlight::{Backlight, BacklightType};
+use tokio::sync::Mutex;
 use zbus::fdo::Error as FdoErr;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};
@@ -13,7 +13,7 @@ use crate::config::Config;
 use crate::error::RogError;
 use crate::ASUS_ZBUS_PATH;
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct CtrlBacklight {
     backlights: Vec<Backlight>,
     config: Arc<Mutex<Config>>,

asusd/src/ctrl_fancurves.rs

@@ -3,13 +3,13 @@ use std::sync::Arc;
 
 use config_traits::{StdConfig, StdConfigLoad};
 use futures_lite::StreamExt;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
 use rog_platform::platform::{PlatformProfile, RogPlatform};
 use rog_profiles::error::ProfileError;
 use rog_profiles::fan_curve_set::CurveData;
 use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
 use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};
 

asusd/src/ctrl_platform.rs

@@ -3,17 +3,19 @@ use std::process::Command;
 use std::sync::Arc;
 
 use config_traits::StdConfig;
-use futures_util::lock::Mutex;
 use log::{debug, error, info, warn};
-use rog_platform::asus_armoury::{AttrValue, FirmwareAttribute, FirmwareAttributes};
+use rog_platform::asus_armoury::{
+    AttrValue, FirmwareAttribute, FirmwareAttributeType, FirmwareAttributes,
+};
 use rog_platform::cpu::{CPUControl, CPUGovernor, CPUEPP};
 use rog_platform::platform::{PlatformProfile, Properties, RogPlatform};
 use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
 use zbus::fdo::Error as FdoErr;
 use zbus::object_server::SignalEmitter;
 use zbus::{interface, Connection};
 
-use crate::asus_armoury::set_config_or_default;
+use crate::asus_armoury::{set_config_or_default, ArmouryAttributeRegistry};
 use crate::config::Config;
 use crate::error::RogError;
 use crate::{task_watch_item, CtrlTask, ReloadAndNotify};
@@ -46,9 +48,12 @@ pub struct CtrlPlatform {
     attributes: FirmwareAttributes,
     cpu_control: Option<CPUControl>,
     config: Arc<Mutex<Config>>,
+    connection: Connection,
+    armoury_registry: ArmouryAttributeRegistry,
 }
 
 impl CtrlPlatform {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         platform: RogPlatform,
         power: AsusPower,
@@ -56,6 +61,8 @@ impl CtrlPlatform {
         config: Arc<Mutex<Config>>,
         config_path: &Path,
         signal_context: SignalEmitter<'static>,
+        connection: Connection,
+        armoury_registry: ArmouryAttributeRegistry,
     ) -> Result<Self, RogError> {
         let config1 = config.clone();
         let config_path = config_path.to_owned();
@@ -68,6 +75,8 @@ impl CtrlPlatform {
             cpu_control: CPUControl::new()
                 .map_err(|e| error!("Couldn't get CPU control sysfs: {e}"))
                 .ok(),
+            connection,
+            armoury_registry,
         };
         let mut inotify_self = ret_self.clone();
 
@@ -161,7 +170,7 @@ impl CtrlPlatform {
                 .map(|s| s.to_string())
                 .collect()
         };
-        if prog.len() > 1 {
+        if (!prog.is_empty()) && (!prog[0].is_empty()) {
             let mut cmd = Command::new(&prog[0]);
             for arg in prog.iter().skip(1) {
                 cmd.arg(arg);
@@ -288,16 +297,39 @@ impl CtrlPlatform {
 
     #[zbus(property)]
     fn charge_control_end_threshold(&self) -> Result<u8, FdoErr> {
-        let limit = self.power.get_charge_control_end_threshold()?;
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
+        let limit = self.power.get_charge_control_end_threshold().map_err(|e| {
+            FdoErr::Failed(format!(
+                "Could not read charge_control_end_threshold: {e:?}"
+            ))
+        })?;
+
         Ok(limit)
     }
 
     #[zbus(property)]
     async fn set_charge_control_end_threshold(&mut self, limit: u8) -> Result<(), FdoErr> {
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
         if !(20..=100).contains(&limit) {
             return Err(RogError::ChargeLimit(limit))?;
         }
-        self.power.set_charge_control_end_threshold(limit)?;
+
+        self.power
+            .set_charge_control_end_threshold(limit)
+            .map_err(|e| {
+                FdoErr::Failed(format!("Could not set charge_control_end_threshold: {e:?}"))
+            })?;
+
         self.config.lock().await.charge_control_end_threshold = limit;
         self.config.lock().await.base_charge_control_end_threshold = limit;
         self.config.lock().await.write();
@@ -305,12 +337,22 @@ impl CtrlPlatform {
     }
 
     async fn one_shot_full_charge(&self) -> Result<(), FdoErr> {
+        if !self.power.has_charge_control_end_threshold() {
+            return Err(FdoErr::NotSupported(
+                "RogPlatform: charge_control_end_threshold not supported".to_owned(),
+            ));
+        }
+
         let base_limit = std::mem::replace(
             &mut self.config.lock().await.charge_control_end_threshold,
             100,
         );
         if base_limit != 100 {
-            self.power.set_charge_control_end_threshold(100)?;
+            self.power
+                .set_charge_control_end_threshold(100)
+                .map_err(|e| {
+                    FdoErr::Failed(format!("Could not set one_shot_full_charge: {e:?}"))
+                })?;
             self.config.lock().await.base_charge_control_end_threshold = base_limit;
             self.config.lock().await.write();
         }
@@ -419,8 +461,18 @@ impl CtrlPlatform {
         #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
         policy: PlatformProfile,
     ) -> Result<(), FdoErr> {
-        self.config.lock().await.platform_profile_on_battery = policy;
-        self.set_platform_profile(ctxt, policy).await?;
+        // If the requested profile isn't available on this platform, and it's
+        // `Quiet`, fall back to `LowPower` so we don't write an unavailable
+        // 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(())
     }
@@ -448,8 +500,16 @@ impl CtrlPlatform {
         #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
         policy: PlatformProfile,
     ) -> Result<(), FdoErr> {
-        self.config.lock().await.platform_profile_on_ac = policy;
-        self.set_platform_profile(ctxt, policy).await?;
+        // Mirror the same fallback behavior for AC profile changes.
+        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_ac = chosen;
+        self.set_platform_profile(ctxt, chosen).await?;
         self.config.lock().await.write();
         Ok(())
     }
@@ -559,7 +619,7 @@ impl CtrlPlatform {
 
             for attr in self.attributes.attributes() {
                 let name: FirmwareAttribute = attr.name().into();
-                if name.is_ppt() {
+                if name.property_type() == FirmwareAttributeType::Ppt {
                     // reset stored value
                     if let Some(tune) = self
                         .config
@@ -729,6 +789,31 @@ impl CtrlTask for CtrlPlatform {
                             }
                             if !sleeping {
                                 platform1.run_ac_or_bat_cmd(power_plugged > 0).await;
+                                if let Ok(profile) =
+                                    platform1.platform.get_platform_profile().map(|p| p.into())
+                                {
+                                    let attrs = FirmwareAttributes::new();
+                                    {
+                                        let mut cfg = platform1.config.lock().await;
+                                        set_config_or_default(
+                                            &attrs,
+                                            &mut cfg,
+                                            power_plugged > 0,
+                                            profile,
+                                        )
+                                        .await;
+                                    }
+                                    if let Err(e) = platform1
+                                        .armoury_registry
+                                        .emit_limits(&platform1.connection)
+                                        .await
+                                    {
+                                        error!(
+                                            "Failed to emit armoury updates after power change: \
+                                             {e:?}"
+                                        );
+                                    }
+                                }
                             }
                             platform1.config.lock().await.last_power_plugged = power_plugged;
                         }
@@ -789,13 +874,17 @@ impl CtrlTask for CtrlPlatform {
                     {
                         // TODO: manage this better, shouldn't need to create every time
                         let attrs = FirmwareAttributes::new();
-                        set_config_or_default(
-                            &attrs,
-                            &mut *platform3.config.lock().await,
-                            power_plugged,
-                            profile,
-                        )
-                        .await;
+                        {
+                            let mut cfg = platform3.config.lock().await;
+                            set_config_or_default(&attrs, &mut cfg, power_plugged, profile).await;
+                        }
+                        if let Err(e) = platform3
+                            .armoury_registry
+                            .emit_limits(&platform3.connection)
+                            .await
+                        {
+                            error!("Failed to emit armoury updates after AC/DC toggle: {e:?}");
+                        }
                         platform3
                             .enable_ppt_group_changed(&signal_ctxt_copy)
                             .await
@@ -852,6 +941,9 @@ impl CtrlTask for CtrlPlatform {
                             profile,
                         )
                         .await;
+                        if let Err(e) = ctrl.armoury_registry.emit_limits(&ctrl.connection).await {
+                            error!("Failed to emit armoury updates after profile change: {e:?}");
+                        }
                     }
                 }
             }

asusd/src/daemon.rs

@@ -3,7 +3,7 @@ use std::error::Error;
 use std::sync::Arc;
 
 use ::zbus::Connection;
-use asusd::asus_armoury::start_attributes_zbus;
+use asusd::asus_armoury::{start_attributes_zbus, ArmouryAttributeRegistry};
 use asusd::aura_manager::DeviceManager;
 use asusd::config::Config;
 use asusd::ctrl_backlight::CtrlBacklight;
@@ -11,15 +11,17 @@ use asusd::ctrl_fancurves::CtrlFanCurveZbus;
 use asusd::ctrl_platform::CtrlPlatform;
 use asusd::{print_board_info, start_tasks, CtrlTask, ZbusRun, DBUS_NAME};
 use config_traits::{StdConfig, StdConfigLoad2};
-use futures_util::lock::Mutex;
 use log::{error, info};
 use rog_platform::asus_armoury::FirmwareAttributes;
 use rog_platform::platform::RogPlatform;
 use rog_platform::power::AsusPower;
+use tokio::sync::Mutex;
 use zbus::fdo::ObjectManager;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Starting asusd daemon...");
+
     // console_subscriber::init();
     let mut logger = env_logger::Builder::new();
     logger
@@ -62,7 +64,9 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
 
     // Start zbus server
     let mut server = Connection::system().await?;
-    server.object_server().at("/", ObjectManager).await.unwrap();
+    if let Err(e) = server.object_server().at("/", ObjectManager).await {
+        error!("Failed to register ObjectManager at root '/': {e:?}");
+    }
 
     let config = Config::new().load();
     let cfg_path = config.file_path();
@@ -72,19 +76,31 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     let platform = RogPlatform::new()?; // TODO: maybe needs async mutex?
     let power = AsusPower::new()?; // TODO: maybe needs async mutex?
     let attributes = FirmwareAttributes::new();
-    start_attributes_zbus(
+    let armoury_registry = match start_attributes_zbus(
         &server,
         platform.clone(),
         power.clone(),
         attributes.clone(),
         config.clone(),
     )
-    .await?;
+    .await
+    {
+        Ok(registry) => {
+            info!("attribute on zbus initialized");
+            registry
+        }
+        Err(e) => {
+            error!("Failed to initialize firmware attributes over zbus: {e:?}");
+            ArmouryAttributeRegistry::default()
+        }
+    };
 
     match CtrlFanCurveZbus::new() {
         Ok(ctrl) => {
+            info!("FanCurves: found supported fancurves");
             let sig_ctx = CtrlFanCurveZbus::signal_context(&server)?;
             start_tasks(ctrl, &mut server, sig_ctx).await?;
+            info!("FanCurves: initialized");
         }
         Err(err) => {
             error!("FanCurves: {}", err);
@@ -93,8 +109,10 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
 
     match CtrlBacklight::new(config.clone()) {
         Ok(backlight) => {
+            info!("Backlight: found supported backlight");
             backlight.start_watch_primary().await?;
             backlight.add_to_server(&mut server).await;
+            info!("Backlight: initialized");
         }
         Err(err) => {
             error!("Backlight: {}", err);
@@ -108,10 +126,14 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
         config.clone(),
         &cfg_path,
         CtrlPlatform::signal_context(&server)?,
+        server.clone(),
+        armoury_registry,
     ) {
         Ok(ctrl) => {
+            info!("CtrlPlatform: initialized");
             let sig_ctx = CtrlPlatform::signal_context(&server)?;
             start_tasks(ctrl, &mut server, sig_ctx).await?;
+            info!("CtrlPlatform: tasks started");
         }
         Err(err) => {
             error!("CtrlPlatform: {}", err);
@@ -120,10 +142,12 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
 
     let _ = DeviceManager::new(server.clone()).await?;
 
+    info!("DeviceManager initialized");
+
     // Request dbus name after finishing initalizing all functions
     server.request_name(DBUS_NAME).await?;
 
-    info!("Startup success, begining dbus server loop");
+    info!("Startup success on dbus name {DBUS_NAME}: begining dbus server loop");
     loop {
         // This is just a blocker to idle and ensure the reator reacts
         server.executor().tick().await;

data/asusd.rules

@@ -9,11 +9,14 @@ ENV{DMI_FAMILY}=="*Strix*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Vivo*ook*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Zenbook*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*ProArt*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*TX Air*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*TX Gaming*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*EXPERTBOOK*", GOTO="asusd_start"
 # No match so
 GOTO="asusd_end"
 
 LABEL="asusd_start"
-ACTION=="add|change", DRIVER=="asus-nb-wmi", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
-ACTION=="add|remove", DRIVER=="asus-nb-wmi", TAG+="systemd", RUN+="systemctl restart asusd.service"
+ACTION=="add|change", DRIVER=="asus-nb-wmi", TAG+="systemd", ENV{SYSTEMD_WANTS}+="asusd.service"
+ACTION=="add|remove", DRIVER=="asus-nb-wmi", TAG+="systemd", ENV{SYSTEMD_WANTS}+="asusd.service"
 
 LABEL="asusd_end"

data/asusd.service

@@ -6,7 +6,10 @@ After=nvidia-powerd.service systemd-udevd.service
 
 [Service]
 Environment=IS_SERVICE=1
-Environment=RUST_LOG="debug"
+# 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"
 # required to prevent init issues with hid_asus and MCU
 ExecStartPre=/bin/sleep 1
 ExecStart=/usr/bin/asusd

distro-packaging/asusctl.spec

@@ -20,9 +20,9 @@
 %global debug_package %{nil}
 %endif
 
-%define version 6.1.12
+%define version 6.3.1
 %define specrelease %{?dist}
-%define pkg_release 9%{specrelease}
+%define pkg_release 1%{specrelease}
 
 # Use hardening ldflags.
 %global rustflags -Clink-arg=-Wl,-z,relro,-z,now
@@ -55,6 +55,7 @@ BuildRequires:  pkgconfig(libseat)
 BuildRequires:  pkgconfig(libudev)
 BuildRequires:  pkgconfig(xkbcommon)
 BuildRequires:  pkgconfig(libzstd)
+BuildRequires:  pkgconfig(fontconfig)
 BuildRequires:  desktop-file-utils
 
 %description
@@ -67,6 +68,7 @@ asus-nb-ctrl enables third-party apps to use the above with dbus methods.
 
 %package rog-gui
 Summary: An experimental GUI for %{name}
+Requires: %{name} = %{version}-%{release}
 
 %description rog-gui
 A one-stop-shop GUI tool for asusd/asusctl. It aims to provide most controls,
@@ -74,11 +76,6 @@ a notification service, and ability to run in the background.
 
 %prep
 %autosetup
-%if %{defined fedora}
-%cargo_prep
-sed -i 's|offline = true|offline = false|' .cargo/config.toml
-sed -i 's|source.crates-io|source.ignore_this|' .cargo/config.toml
-%else
 mkdir -p .cargo
 cat > .cargo/config.toml << 'EOF'
 [term]
@@ -86,26 +83,78 @@ verbose = true
 [net]
 offline = false
 EOF
-%endif
 
 %build
 export RUSTFLAGS="%{rustflags}"
 %if %{defined fedora}
-%cargo_build
+/usr/bin/cargo build --release --locked
 %else
-/usr/bin/cargo auditable build --release
+/usr/bin/cargo auditable build --release --locked
 %endif
 
 %install
 export RUSTFLAGS="%{rustflags}"
-mkdir -p "%{buildroot}/%{_bindir}" "%{buildroot}%{_docdir}"
-%make_install
 
-install -D -m 0644 README.md %{buildroot}/%{_docdir}/%{name}/README.md
-install -D -m 0644 rog-anime/README.md %{buildroot}/%{_docdir}/%{name}/README-anime.md
-install -D -m 0644 rog-anime/data/diagonal-template.png %{buildroot}/%{_docdir}/%{name}/diagonal-template.png
+%define _target_dir target/release
 
-desktop-file-validate %{buildroot}/%{_datadir}/applications/rog-control-center.desktop
+# Install binaries
+install -D -m 0755 %{_target_dir}/asusd %{buildroot}%{_bindir}/asusd
+install -D -m 0755 %{_target_dir}/asusd-user %{buildroot}%{_bindir}/asusd-user
+install -D -m 0755 %{_target_dir}/asusctl %{buildroot}%{_bindir}/asusctl
+install -D -m 0755 %{_target_dir}/rog-control-center %{buildroot}%{_bindir}/rog-control-center
+
+# Install systemd units
+install -D -m 0644 data/asusd.service %{buildroot}%{_unitdir}/asusd.service
+install -D -m 0644 data/asusd-user.service %{buildroot}%{_userunitdir}/asusd-user.service
+
+# Install udev rules
+install -D -m 0644 data/asusd.rules %{buildroot}%{_udevrulesdir}/99-asusd.rules
+
+# Install dbus config
+install -D -m 0644 data/asusd.conf %{buildroot}%{_datadir}/dbus-1/system.d/asusd.conf
+
+# Install asusd data
+install -D -m 0644 rog-aura/data/aura_support.ron %{buildroot}%{_datadir}/asusd/aura_support.ron
+cp -r rog-anime/data/anime %{buildroot}%{_datadir}/asusd/
+
+# Install rog-gui data
+install -D -m 0644 rog-control-center/data/rog-control-center.desktop %{buildroot}%{_datadir}/applications/rog-control-center.desktop
+install -D -m 0644 rog-control-center/data/rog-control-center.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/rog-control-center.png
+mkdir -p %{buildroot}%{_datadir}/rog-gui/layouts
+cp -r rog-aura/data/layouts/*.ron %{buildroot}%{_datadir}/rog-gui/layouts/
+
+# Install icons
+install -D -m 0644 data/icons/asus_notif_yellow.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_yellow.png
+install -D -m 0644 data/icons/asus_notif_green.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_green.png
+install -D -m 0644 data/icons/asus_notif_blue.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_blue.png
+install -D -m 0644 data/icons/asus_notif_red.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_red.png
+install -D -m 0644 data/icons/asus_notif_orange.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_orange.png
+install -D -m 0644 data/icons/asus_notif_white.png %{buildroot}%{_datadir}/icons/hicolor/512x512/apps/asus_notif_white.png
+install -D -m 0644 data/icons/scalable/gpu-compute.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/gpu-compute.svg
+install -D -m 0644 data/icons/scalable/gpu-hybrid.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/gpu-hybrid.svg
+install -D -m 0644 data/icons/scalable/gpu-integrated.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/gpu-integrated.svg
+install -D -m 0644 data/icons/scalable/gpu-nvidia.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/gpu-nvidia.svg
+install -D -m 0644 data/icons/scalable/gpu-vfio.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/gpu-vfio.svg
+install -D -m 0644 data/icons/scalable/notification-reboot.svg %{buildroot}%{_datadir}/icons/hicolor/scalable/status/notification-reboot.svg
+
+# Install docs
+install -D -m 0644 README.md %{buildroot}%{_docdir}/%{name}/README.md
+install -D -m 0644 rog-anime/README.md %{buildroot}%{_docdir}/%{name}/README-anime.md
+install -D -m 0644 rog-anime/data/diagonal-template.png %{buildroot}%{_docdir}/%{name}/diagonal-template.png
+
+# Install LICENSE to asusctl datadir
+install -D -m 0644 LICENSE %{buildroot}%{_datadir}/asusctl/LICENSE
+
+desktop-file-validate %{buildroot}%{_datadir}/applications/rog-control-center.desktop
+
+%post
+%systemd_post asusd.service
+
+%preun
+%systemd_preun asusd.service
+
+%postun
+%systemd_postun_with_restart asusd.service
 
 %files
 %license LICENSE
@@ -115,8 +164,6 @@ desktop-file-validate %{buildroot}/%{_datadir}/applications/rog-control-center.d
 %{_unitdir}/asusd.service
 %{_userunitdir}/asusd-user.service
 %{_udevrulesdir}/99-asusd.rules
-#%dir %{_sysconfdir}/asusd/
-%{_datadir}/asusd/aura_support.ron
 %{_datadir}/dbus-1/system.d/asusd.conf
 %{_datadir}/icons/hicolor/512x512/apps/asus_notif_yellow.png
 %{_datadir}/icons/hicolor/512x512/apps/asus_notif_green.png
@@ -131,6 +178,7 @@ desktop-file-validate %{buildroot}/%{_datadir}/applications/rog-control-center.d
 %{_datadir}/icons/hicolor/scalable/status/gpu-vfio.svg
 %{_datadir}/icons/hicolor/scalable/status/notification-reboot.svg
 %{_docdir}/%{name}/
+%{_datadir}/asusctl/
 %{_datadir}/asusd/
 
 %files rog-gui

extra/index.html

@@ -0,0 +1,23 @@
+<!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-anime/src/data.rs

@@ -63,6 +63,8 @@ pub enum AnimeType {
     GA401,
     GA402,
     GU604,
+    G635L,
+    G835L,
     #[default]
     Unsupported,
 }
@@ -71,12 +73,21 @@ impl FromStr for AnimeType {
     type Err = AnimeError;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        Ok(match s {
-            "ga401" | "GA401" => Self::GA401,
-            "ga402" | "GA402" => Self::GA402,
-            "gu604" | "GU604" => Self::GU604,
-            _ => Self::Unsupported,
-        })
+        let dmi = s.to_uppercase();
+
+        if dmi.contains("GA401") {
+            return Ok(Self::GA401);
+        } else if dmi.contains("GA402") {
+            return Ok(Self::GA402);
+        } else if dmi.contains("GU604") {
+            return Ok(Self::GU604);
+        } else if dmi.contains("G635L") {
+            return Ok(Self::G635L);
+        } else if dmi.contains("G835L") {
+            return Ok(Self::G835L);
+        }
+
+        Ok(Self::Unsupported)
     }
 }
 
@@ -89,6 +100,10 @@ impl AnimeType {
             AnimeType::GA402
         } else if board_name.contains("GU604V") {
             AnimeType::GU604
+        } else if board_name.contains("G635L") {
+            AnimeType::G635L
+        } else if board_name.contains("G835L") {
+            AnimeType::G835L
         } else {
             AnimeType::Unsupported
         }
@@ -98,6 +113,9 @@ impl AnimeType {
     pub fn width(&self) -> usize {
         match self {
             AnimeType::GU604 => 70,
+            // TODO: Find G635L W*H
+            AnimeType::G635L => 68,
+            AnimeType::G835L => 68,
             _ => 74,
         }
     }
@@ -107,6 +125,8 @@ impl AnimeType {
         match self {
             AnimeType::GA401 => 36,
             AnimeType::GU604 => 43,
+            AnimeType::G635L => 34,
+            AnimeType::G835L => 34,
             _ => 39,
         }
     }
@@ -116,6 +136,7 @@ impl AnimeType {
         match self {
             AnimeType::GA401 => PANE_LEN * 2,
             AnimeType::GU604 => PANE_LEN * 3,
+            AnimeType::G835L => PANE_LEN * 3,
             _ => PANE_LEN * 3,
         }
     }
@@ -180,7 +201,13 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
 
         let mut buffers = match anime.anime {
             AnimeType::GA401 => vec![[0; 640]; 2],
-            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unsupported => vec![[0; 640]; 3],
+            AnimeType::GA402
+            | AnimeType::GU604
+            | AnimeType::G635L
+            | AnimeType::G835L
+            | AnimeType::Unsupported => {
+                vec![[0; 640]; 3]
+            }
         };
 
         for (idx, chunk) in anime.data.as_slice().chunks(PANE_LEN).enumerate() {
@@ -191,7 +218,11 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
 
         if matches!(
             anime.anime,
-            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unsupported
+            AnimeType::GA402
+                | AnimeType::GU604
+                | AnimeType::G635L
+                | AnimeType::G835L
+                | AnimeType::Unsupported
         ) {
             buffers[2][..7].copy_from_slice(&USB_PREFIX3);
         }

rog-anime/src/diagonal.rs

@@ -381,4 +381,48 @@ impl AnimeDiagonal {
 
         AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
     }
+
+    // TODO: Implement `to_g635l_packets` and `to_g835l_packets` functions
+    // fn to_g835l_packets(buf: &[u8]) -> Result<AnimeDataBuffer> {
+    //     let mut buf = vec![0u8; AnimeType::GU604.data_length()];
+
+    //     let mut start_index: usize = 0;
+
+    //     fn copy_slice(
+    //         buf: &mut [u8],
+    //         anime: &AnimeDiagonal,
+    //         x: usize,
+    //         y: usize,
+    //         start_index: &mut usize,
+    //         len: usize,
+    //     ) {
+    //         buf[*start_index..*start_index + len].copy_from_slice(&anime.get_row(x, y, len));
+    //         *start_index += len;
+    //     }
+
+    //     let b = &mut buf;
+    //     let a = &self;
+
+    //     copy_slice(b, a, 40, 0, &mut start_index, 21);
+    //     copy_slice(b, a, 41, 0, &mut start_index, 21);
+    //     copy_slice(b, a, 42, 0, &mut start_index, 20);
+    //     copy_slice(b, a, 43, 0, &mut start_index, 20);
+    //     copy_slice(b, a, 44, 0, &mut start_index, 19);
+    //     copy_slice(b, a, 45, 0, &mut start_index, 19);
+    //     copy_slice(b, a, 46, 0, &mut start_index, 18);
+    //     copy_slice(b, a, 47, 0, &mut start_index, 18);
+    //     copy_slice(b, a, 48, 0, &mut start_index, 17);
+    //     copy_slice(b, a, 49, 0, &mut start_index, 17);
+    //     copy_slice(b, a, 50, 0, &mut start_index, 16);
+    //     copy_slice(b, a, 51, 0, &mut start_index, 16);
+    //     copy_slice(b, a, 52, 0, &mut start_index, 15);
+    //     copy_slice(b, a, 53, 0, &mut start_index, 15);
+    //     copy_slice(b, a, 54, 0, &mut start_index, 14);
+    //     copy_slice(b, a, 55, 0, &mut start_index, 14);
+    //     copy_slice(b, a, 56, 0, &mut start_index, 13);
+    //     copy_slice(b, a, 57, 0, &mut start_index, 13);
+    //     copy_slice(b, a, 58, 0, &mut start_index, 12);
+
+    //     AnimeDataBuffer::from_vec(crate::AnimeType::G835L, buf)
+    // }
 }

rog-anime/src/image.rs

@@ -138,6 +138,10 @@ impl AnimeImage {
         match anime_type {
             AnimeType::GA401 => 0.3,
             AnimeType::GU604 => 0.28,
+            // TODO: Calculate correct values for G635L and G835L.
+            // Known values for G835L W*H is 34*68
+            AnimeType::G635L => 0.28,
+            AnimeType::G835L => 0.28,
             _ => 0.283,
         }
     }
@@ -162,6 +166,20 @@ impl AnimeImage {
     ///    ^   ------+
     ///  first_x
     /// ```
+    ///
+    /// TODO: add the cases for G635L and G835L
+    /// This is how it looks like, but calculation may be a bit more complex
+    /// ```text
+    /// |\
+    /// | \
+    /// |  \
+    /// |   \
+    /// \    \
+    ///  \    \
+    ///   \    \
+    ///    \    \
+    ///     \____\
+    /// ```
     fn first_x(anime_type: AnimeType, y: u32) -> u32 {
         match anime_type {
             AnimeType::GA401 => {
@@ -169,7 +187,7 @@ impl AnimeImage {
                     // first 5 rows for GA401 are always at X = 0
                     return 0;
                 }
-                (y + 1) / 2 - 3
+                y.div_ceil(2) - 3
             }
             AnimeType::GU604 => {
                 // first 9 rows start at zero
@@ -185,7 +203,7 @@ impl AnimeImage {
                     return 0;
                 }
                 // and then their offset grows by one every two rows
-                (y + 1) / 2 - 5
+                y.div_ceil(2) - 5
             }
         }
     }
@@ -213,7 +231,7 @@ impl AnimeImage {
                     // First 5 rows for GA401 are always 33 physical LEDs long
                     return 33;
                 }
-                36 - (y + 1) / 2
+                36 - y.div_ceil(2)
             }
             AnimeType::GU604 => {
                 if y <= 9 {
@@ -221,6 +239,19 @@ impl AnimeImage {
                 }
                 38 - Self::first_x(anime_type, y) + y % 2
             }
+            // TODO: Implement this
+            // AnimeType::G635L => {
+            //     if y <= 11 {
+            //         return 34;
+            //     }
+            //     39 - y / 2
+            // }
+            // AnimeType::G635E => {
+            //     if y <= 11 {
+            //         return 34;
+            //     }
+            //     39 - y / 2
+            // }
             _ => {
                 if y <= 11 {
                     return 34;
@@ -235,8 +266,10 @@ impl AnimeImage {
         match anime_type {
             // 33.0 = Longest row LED count (physical) plus half-pixel offset
             AnimeType::GA401 => (33.0 + 0.5) * Self::scale_x(anime_type),
-
             AnimeType::GU604 => (38.0 + 0.5) * Self::scale_x(anime_type),
+            // TODO: Implement this
+            // AnimeType::G635L => (34.0 + 0.5) * Self::scale_x(anime_type),
+            // AnimeType::G835L => (34.0 + 0.5) * Self::scale_x(anime_type),
             _ => (35.0 + 0.5) * Self::scale_x(anime_type),
         }
     }
@@ -246,6 +279,9 @@ impl AnimeImage {
         match anime_type {
             AnimeType::GA401 => 55,
             AnimeType::GU604 => 62,
+            // TODO: Implement this
+            // AnimeType::G635L => 68,
+            // AnimeType::G835L => 68,
             _ => 61,
         }
     }
@@ -256,6 +292,11 @@ impl AnimeImage {
             // 54.0 = End column LED count (physical) plus one dead pixel
             AnimeType::GA401 => (54.0 + 1.0) * Self::scale_y(anime_type),
             AnimeType::GU604 => 62.0 * Self::scale_y(anime_type),
+
+            // TODO: Implement this
+            // AnimeType::G635L => (34.0 + 0.5) * Self::scale_y(anime_type),
+            // AnimeType::G835L => (34.0 + 0.5) * Self::scale_y(anime_type),
+
             // GA402 may not have dead pixels and require only the physical LED count
             _ => 61.0 * Self::scale_y(anime_type),
         }
@@ -269,7 +310,18 @@ impl AnimeImage {
                 1 | 3 => 35, // Some rows are padded
                 _ => 36 - y / 2,
             },
+
+            // TODO: Implement this
+            // AnimeType::G635L => match y {
+
+            // },
+            // AnimeType::G835L => match y {
+
+            // },
+
+            // This seems redundant
             AnimeType::GU604 => AnimeImage::width(anime_type, y),
+
             // GA402 does not have padding, equivalent to width
             _ => AnimeImage::width(anime_type, y),
         }

rog-anime/src/usb.rs

@@ -243,7 +243,7 @@ impl From<AnimShutdown> for i32 {
 #[inline]
 pub fn get_anime_type() -> AnimeType {
     let dmi = DMIID::new().unwrap_or_default();
-    let board_name = dmi.board_name;
+    let board_name = dmi.board_name.to_uppercase();
 
     if board_name.contains("GA401I") || board_name.contains("GA401Q") {
         AnimeType::GA401
@@ -251,6 +251,10 @@ pub fn get_anime_type() -> AnimeType {
         AnimeType::GA402
     } else if board_name.contains("GU604V") {
         AnimeType::GU604
+    } else if board_name.contains("G635L") {
+        AnimeType::G635L
+    } else if board_name.contains("G835L") {
+        AnimeType::G835L
     } else {
         AnimeType::Unsupported
     }

rog-anime/tests/g635l.rs

@@ -0,0 +1,240 @@
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use rog_anime::*;
+
+    #[test]
+    fn g635l_image_edge_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut matrix = AnimeImage::new(
+            Vec2::new(1.0, 1.0),
+            0.0,
+            Vec2::default(),
+            0.0,
+            vec![Pixel::default(); 1000],
+            100,
+            AnimeType::G635L,
+        )
+        .unwrap();
+        matrix.edge_outline();
+        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        // print!("left: '[");
+        // for b in pkt[1] {
+        //     print!("{b:#02x},");
+        // }
+        // print!("]'");
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+
+    #[test]
+    fn g635l_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x1, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        // TODO: create a png file for G635L
+        path.push("tests/data/ga401-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::G635L).unwrap();
+        let data = matrix.into_data_buffer(AnimeType::G635L).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+}

rog-anime/tests/g835l.rs

@@ -0,0 +1,240 @@
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use rog_anime::*;
+
+    #[test]
+    fn g835l_image_edge_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut matrix = AnimeImage::new(
+            Vec2::new(1.0, 1.0),
+            0.0,
+            Vec2::default(),
+            0.0,
+            vec![Pixel::default(); 1000],
+            100,
+            AnimeType::G835L,
+        )
+        .unwrap();
+        matrix.edge_outline();
+        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        // print!("left: '[");
+        // for b in pkt[1] {
+        //     print!("{b:#02x},");
+        // }
+        // print!("]'");
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+
+    #[test]
+    fn g835l_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x02, 0x1, 0x00, 0x73, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+            0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        // TODO: create a png file for G835L
+        path.push("tests/data/ga401-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::G835L).unwrap();
+        let data = matrix.into_data_buffer(AnimeType::G835L).unwrap();
+        let pkt = AnimePacketType::try_from(data).unwrap();
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+}

rog-aura/data/aura_support.ron

@@ -5,7 +5,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -14,7 +14,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, RainbowCycle],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -23,7 +23,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -32,16 +32,43 @@
         layout_name: "fa507",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
         device_name: "FA617NS",
         product_id: "",
-        layout_name: "fx505d",
+        layout_name: "fa507",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    (
+        device_name: "FA617NT",
+        product_id: "",
+        layout_name: "fa507",
+        basic_modes: [Static, Breathe, Pulse],
+        basic_zones: [],
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    (
+        device_name: "FA617XS",
+        product_id: "",
+        layout_name: "fa507",
+        basic_modes: [Static, Breathe, Pulse],
+        basic_zones: [],
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    (
+        device_name: "FA617XT",
+        product_id: "",
+        layout_name: "fa507",
+        basic_modes: [Static, Breathe, Pulse],
+        basic_zones: [],
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -50,7 +77,7 @@
         layout_name: "fx505d",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -59,7 +86,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -68,7 +95,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -77,7 +104,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -86,7 +113,25 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    (
+        device_name: "FX607J",
+        product_id: "",
+        layout_name: "fa506i",
+        basic_modes: [Static, Breathe, Pulse],
+        basic_zones: [],
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    ( 
+        device_name: "FX607V",
+        product_id: "",
+        layout_name: "fa506i",
+        basic_modes: [Static, Breathe, RainbowCycle, Pulse],
+        basic_zones: [],
+        advanced_type: Zoned([SingleZone]),
         power_zones: [Keyboard],
     ),
     (
@@ -95,7 +140,7 @@
         layout_name: "fa506i",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -104,7 +149,16 @@
         layout_name: "fx505d",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
+        power_zones: [Keyboard],
+    ),
+    (
+        device_name: "FX706H",
+        product_id: "",
+        layout_name: "fx505d",
+        basic_modes: [Static, Breathe, RainbowCycle],
+        basic_zones: [],
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -113,7 +167,7 @@
         layout_name: "g512",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -131,7 +185,7 @@
         layout_name: "g513i",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -176,7 +230,7 @@
         layout_name: "gx502",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -185,7 +239,7 @@
         layout_name: "gx502",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -224,13 +278,31 @@
         advanced_type: PerKey,
         power_zones: [Keyboard],
     ),
+    (
+        device_name: "G614FR",
+        product_id: "",
+        layout_name: "g634j-per-key",
+        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
+        basic_zones: [],
+        advanced_type: PerKey,
+        power_zones: [Keyboard, Lightbar, Logo],
+    ),
     (
         device_name: "G614J",
         product_id: "",
         layout_name: "g634j-per-key",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
+        power_zones: [Keyboard, Lightbar],
+    ),
+    (
+        device_name: "G614JIR",
+        product_id: "",
+        layout_name: "g513i-per-key",
+        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
+        basic_zones: [],
+        advanced_type: PerKey,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -239,16 +311,34 @@
         layout_name: "g634j-per-key",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
+    (
+        device_name: "G614JU",
+        product_id: "",
+        layout_name: "g634j-per-key",
+        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
+        basic_zones: [],
+        advanced_type: PerKey,
+        power_zones: [Keyboard, Lightbar, Logo],
+    ),
     (
         device_name: "G614JZ",
         product_id: "",
         layout_name: "g634j-per-key",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        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],
     ),
     (
@@ -260,13 +350,22 @@
         advanced_type: PerKey,
         power_zones: [Keyboard, Lightbar, Logo, RearGlow],
     ),
+    (
+            device_name: "G635L",
+            product_id: "",
+            layout_name: "g635l-per-key",
+            basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
+            basic_zones: [],
+            advanced_type: PerKey,
+            power_zones: [Keyboard, Lightbar, Logo],
+    ),
     (
         device_name: "G712LI",
         product_id: "",
         layout_name: "gl503",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -275,7 +374,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -284,7 +383,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -293,7 +392,7 @@
         layout_name: "gx502",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -302,7 +401,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -311,7 +410,7 @@
         layout_name: "gx502",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -320,7 +419,7 @@
         layout_name: "gx502",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -356,7 +455,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -374,7 +473,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4, BarLeft, BarRight],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
     (
@@ -392,7 +491,7 @@
         layout_name: "g533q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -401,7 +500,7 @@
         layout_name: "g533q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -410,7 +509,7 @@
         layout_name: "g533q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -458,6 +557,15 @@
         advanced_type: PerKey,
         power_zones: [Keyboard, Lightbar],
     ),
+    (
+        device_name: "G815L",
+        product_id: "",
+        layout_name: "g814ji-per-key",
+        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
+        basic_zones: [],
+        advanced_type: PerKey,
+        power_zones: [Keyboard, Lightbar],
+    ),
     (
         device_name: "G834J",
         product_id: "",
@@ -467,13 +575,22 @@
         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: "",
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -482,7 +599,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -491,7 +608,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -500,7 +617,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -509,7 +626,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -518,7 +635,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -527,7 +644,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -536,7 +653,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -545,7 +662,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -554,7 +671,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -563,7 +680,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -581,7 +698,7 @@
         layout_name: "gl503",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -590,7 +707,7 @@
         layout_name: "gl503",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -599,7 +716,7 @@
         layout_name: "gl503",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4, Logo, BarLeft, BarRight],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -617,7 +734,7 @@
         layout_name: "g533q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -626,7 +743,7 @@
         layout_name: "gl503",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -635,7 +752,7 @@
         layout_name: "fa507",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -683,6 +800,15 @@
         advanced_type: Zoned([SingleZone]),
         power_zones: [Keyboard],
     ),
+    (
+        device_name: "GU605C",
+        product_id: "",
+        layout_name: "ga401q",
+        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
+        basic_zones: [],
+        advanced_type: Zoned([SingleZone]),
+        power_zones: [Keyboard],
+    ),
     (
         device_name: "GU605M",
         product_id: "",
@@ -698,7 +824,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -707,7 +833,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -716,7 +842,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -725,7 +851,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -743,7 +869,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -761,7 +887,7 @@
         layout_name: "gx531-per-key",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -815,7 +941,7 @@
         layout_name: "gx531-per-key",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -824,7 +950,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -833,7 +959,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -842,8 +968,8 @@
         layout_name: "",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
-        power_zones: [None],
+        advanced_type: r#None,
+        power_zones: [r#None],
     ),
     (
         device_name: "GZ301Z",
@@ -851,7 +977,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Keyboard],
     ),
     (
@@ -860,7 +986,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Ally],
     ),
     (
@@ -869,7 +995,7 @@
         layout_name: "ga401q",
         basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Pulse],
         basic_zones: [],
-        advanced_type: None,
+        advanced_type: r#None,
         power_zones: [Ally],
     ),
 ])

rog-aura/data/layouts/g635l-per-key_US.ron

@@ -0,0 +1,375 @@
+(
+    locale: "US",
+    key_shapes: {
+        "regular": Led(
+            width: 1.0,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "regular_spacing": Blank(
+            width: 1.2,
+            height: 0.0,
+        ),
+        "rog_row": Led(
+            width: 1.0,
+            height: 0.7,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.6,
+        ),
+        "rog_row_blocking": Blank(
+            width: 1.2,
+            height: 0.0,
+        ),
+        "func_space": Blank(
+            width: 0.6,
+            height: 0.0,
+        ),
+        "backspace": Led(
+            width: 2.2,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "tab": Led(
+            width: 1.6,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "backslash": Led(
+            width: 1.6,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "capsplonk": Led(
+            width: 2.0,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "return": Led(
+            width: 2.4,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "lshift": Led(
+            width: 2.6,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "rshift": Led(
+            width: 3.0,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "lctrl": Led(
+            width: 1.4,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "spacebar": Led(
+            width: 5.8,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "rctrl": Led(
+            width: 1.2,
+            height: 1.0,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "up_arrow": Led(
+            width: 0.8,
+            height: 0.8,
+            pad_left: 1.1,
+            pad_right: 1.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+        ),
+        "arrows_spacer": Blank(
+            width: 15.0,
+            height: 0.0,
+        ),
+        "arrows": Led(
+            width: 0.8,
+            height: 0.8,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: -0.1,
+            pad_bottom: 0.1,
+        ),
+        "row_end_spacing": Blank(
+            width: 0.4,
+            height: 0.0,
+        ),
+        "lid_logo": Led(
+            width: 2.6,
+            height: 1.2,
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.8,
+            pad_bottom: 0.0,
+        ),
+        "lightbar_left": Led(
+            width: 0.6,
+            height: 3.6,
+            pad_left: -1.2,
+            pad_right: 0.2,
+            pad_top: -3.0,
+            pad_bottom: 0.3,
+        ),
+        "lightbar_corner_left": Led(
+            width: 0.8,
+            height: 0.6,
+            pad_left: -0.6,
+            pad_right: 0.2,
+            pad_top: 0.8,
+            pad_bottom: 0.0,
+        ),
+        "lightbar_bottom": Led(
+            width: 12.6,
+            height: 0.5,
+            pad_left: -0.1,
+            pad_right: -0.1,
+            pad_top: 0.8,
+            pad_bottom: 0.0,
+        ),
+        "lightbar_corner_right": Led(
+            width: 0.8,
+            height: 0.6,
+            pad_left: 0.0,
+            pad_right: 0.2,
+            pad_top: 0.8,
+            pad_bottom: 0.0,
+        ),
+        "lightbar_right": Led(
+            width: 0.6,
+            height: 3.6,
+            pad_left: -0.8,
+            pad_right: 0.2,
+            pad_top: -3.0,
+            pad_bottom: 0.3,
+        ),
+    },
+    key_rows: [
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Blocking, "rog_row_blocking"),
+                (Blocking, "rog_row_blocking"),
+                (VolDown, "rog_row"),
+                (VolUp, "rog_row"),
+                (MicMute, "rog_row"),
+                (RogFan, "rog_row"),
+                (RogApp, "rog_row"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Esc, "regular"),
+                (Spacing, "regular_spacing"),
+                (F1, "regular"),
+                (F2, "regular"),
+                (F3, "regular"),
+                (F4, "regular"),
+                (Spacing, "func_space"),
+                (F5, "regular"),
+                (F6, "regular"),
+                (F7, "regular"),
+                (F8, "regular"),
+                (Spacing, "func_space"),
+                (F9, "regular"),
+                (F10, "regular"),
+                (F11, "regular"),
+                (F12, "regular"),
+                (Spacing, "row_end_spacing"),
+                (Del, "regular"), // Should be super/insert
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Tilde, "regular"),
+                (N1, "regular"),
+                (N2, "regular"),
+                (N3, "regular"),
+                (N4, "regular"),
+                (N5, "regular"),
+                (N6, "regular"),
+                (N7, "regular"),
+                (N8, "regular"),
+                (N9, "regular"),
+                (N0, "regular"),
+                (Hyphen, "regular"),
+                (Equals, "regular"),
+                (Backspace, "backspace"),
+                (Spacing, "row_end_spacing"),
+                (MediaPlay, "regular"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Tab, "tab"),
+                (Q, "regular"),
+                (W, "regular"),
+                (E, "regular"),
+                (R, "regular"),
+                (T, "regular"),
+                (Y, "regular"),
+                (U, "regular"),
+                (I, "regular"),
+                (O, "regular"),
+                (P, "regular"),
+                (LBracket, "regular"),
+                (RBracket, "regular"),
+                (BackSlash, "backslash"),
+                (Spacing, "row_end_spacing"),
+                (MediaStop, "regular"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Caps, "capsplonk"),
+                (A, "regular"),
+                (S, "regular"),
+                (D, "regular"),
+                (F, "regular"),
+                (G, "regular"),
+                (H, "regular"),
+                (J, "regular"),
+                (K, "regular"),
+                (L, "regular"),
+                (SemiColon, "regular"),
+                (Quote, "regular"),
+                (Return, "return"),
+                (Spacing, "row_end_spacing"),
+                (MediaNext, "regular"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (LShift, "lshift"),
+                (Z, "regular"),
+                (X, "regular"),
+                (C, "regular"),
+                (V, "regular"),
+                (B, "regular"),
+                (N, "regular"),
+                (M, "regular"),
+                (Comma, "regular"),
+                (Period, "regular"),
+                (FwdSlash, "regular"),
+                (Rshift, "rshift"),
+                (Spacing, "row_end_spacing"),
+                (MediaPrev, "regular"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (LCtrl, "lctrl"),
+                (LFn, "regular"),
+                (Meta, "regular"),
+                (LAlt, "regular"),
+                (Spacebar, "spacebar"),
+                (RAlt, "regular"),
+                (PrtSc, "regular"),
+                (RCtrl, "rctrl"),
+                (Up, "up_arrow"),
+                (Spacing, "row_end_spacing"),
+                (PrtSc, "regular"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (Spacing, "arrows_spacer"),
+                (Left, "arrows"),
+                (Down, "arrows"),
+                (Right, "arrows"),
+            ],
+        ),
+        (
+            pad_left: 6.5,
+            pad_right: 6.5,
+            pad_top: 0.2,
+            pad_bottom: 0.1,
+            row: [
+                (LidLogo, "lid_logo"),
+            ],
+        ),
+        (
+            pad_left: 0.1,
+            pad_right: 0.1,
+            pad_top: 0.1,
+            pad_bottom: 0.1,
+            row: [
+                (LightbarLeft, "lightbar_left"),
+                (LightbarLeftCorner, "lightbar_corner_left"),
+                (LightbarLeftBottom, "lightbar_bottom"),
+                (LightbarRightBottom, "lightbar_bottom"),
+                (LightbarRightCorner, "lightbar_corner_right"),
+                (LightbarRight, "lightbar_right"),
+            ],
+        ),
+    ],
+)

rog-aura/src/aura_detection.rs

@@ -164,6 +164,25 @@ impl LedSupportFile {
             return Some(data);
         }
 
+        // If the system-wide files were not found (typical in CI or
+        // development environments), attempt to load the bundled
+        // `data/aura_support.ron` from the crate so tests and local runs
+        // behave the same as when the package is installed.
+        // Attempt to load a bundled `aura_support.ron` included at compile time.
+        // Using `include_str!` ensures the data is available regardless of
+        // runtime `CARGO_MANIFEST_DIR` or CI environment differences.
+        let bundled_buf = include_str!("../data/aura_support.ron");
+        if !bundled_buf.is_empty() {
+            if let Ok(tmp) = ron::from_str::<LedSupportFile>(bundled_buf) {
+                data.0.append(&mut tmp.0.clone());
+                data.0.sort_by(|a, b| a.device_name.cmp(&b.device_name));
+                info!("Loaded bundled LED support data (embedded)");
+                return Some(data);
+            } else {
+                warn!("Could not parse embedded bundled data file");
+            }
+        }
+
         warn!("Does {} exist?", ASUS_LED_MODE_USER_CONF);
         None
     }

rog-aura/src/builtin_modes.rs

@@ -359,6 +359,12 @@ 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-aura/src/effects/mod.rs

@@ -207,12 +207,14 @@ mod tests {
     fn single_key_next_state_then_create() {
         let layout = KeyLayout::default_layout();
         let mut seq = AdvancedEffects::new(false);
-        seq.effects
-            .push(Effect::Static(Static::new(LedCode::F, Colour {
+        seq.effects.push(Effect::Static(Static::new(
+            LedCode::F,
+            Colour {
                 r: 255,
                 g: 127,
                 b: 0,
-            })));
+            },
+        )));
 
         seq.next_state(&layout);
         let packets = seq.create_packets();

rog-aura/src/keyboard/layouts.rs

@@ -335,93 +335,117 @@ impl KeyLayout {
                 KeyShape::new_led(1.0, 1.0, 0.1, 0.1, 0.1, 0.1),
             )]),
             key_rows: vec![
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::Esc, "regular".to_owned()),
-                    (LedCode::F1, "regular".to_owned()),
-                    (LedCode::F2, "regular".to_owned()),
-                    (LedCode::F3, "regular".to_owned()),
-                    (LedCode::F4, "regular".to_owned()),
-                    // not sure which key to put here
-                    (LedCode::F5, "regular".to_owned()),
-                    (LedCode::F6, "regular".to_owned()),
-                    (LedCode::F7, "regular".to_owned()),
-                    (LedCode::F8, "regular".to_owned()),
-                    (LedCode::F9, "regular".to_owned()),
-                    (LedCode::F10, "regular".to_owned()),
-                    (LedCode::F11, "regular".to_owned()),
-                    (LedCode::F12, "regular".to_owned()),
-                ]),
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::Tilde, "regular".to_owned()),
-                    (LedCode::N1, "regular".to_owned()),
-                    (LedCode::N2, "regular".to_owned()),
-                    (LedCode::N3, "regular".to_owned()),
-                    (LedCode::N4, "regular".to_owned()),
-                    (LedCode::N5, "regular".to_owned()),
-                    (LedCode::N6, "regular".to_owned()),
-                    (LedCode::N7, "regular".to_owned()),
-                    (LedCode::N8, "regular".to_owned()),
-                    (LedCode::N9, "regular".to_owned()),
-                    (LedCode::N0, "regular".to_owned()),
-                    (LedCode::Hyphen, "regular".to_owned()),
-                    (LedCode::Equals, "regular".to_owned()),
-                    (LedCode::Backspace, "regular".to_owned()),
-                ]),
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::Tab, "regular".to_owned()),
-                    (LedCode::Q, "regular".to_owned()),
-                    (LedCode::W, "regular".to_owned()),
-                    (LedCode::E, "regular".to_owned()),
-                    (LedCode::R, "regular".to_owned()),
-                    (LedCode::T, "regular".to_owned()),
-                    (LedCode::Y, "regular".to_owned()),
-                    (LedCode::U, "regular".to_owned()),
-                    (LedCode::I, "regular".to_owned()),
-                    (LedCode::O, "regular".to_owned()),
-                    (LedCode::P, "regular".to_owned()),
-                    (LedCode::LBracket, "regular".to_owned()),
-                    (LedCode::RBracket, "regular".to_owned()),
-                    (LedCode::BackSlash, "regular".to_owned()),
-                ]),
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::Caps, "regular".to_owned()),
-                    (LedCode::A, "regular".to_owned()),
-                    (LedCode::S, "regular".to_owned()),
-                    (LedCode::D, "regular".to_owned()),
-                    (LedCode::F, "regular".to_owned()),
-                    (LedCode::G, "regular".to_owned()),
-                    (LedCode::H, "regular".to_owned()),
-                    (LedCode::J, "regular".to_owned()),
-                    (LedCode::K, "regular".to_owned()),
-                    (LedCode::L, "regular".to_owned()),
-                    (LedCode::SemiColon, "regular".to_owned()),
-                    (LedCode::Quote, "regular".to_owned()),
-                    (LedCode::Return, "regular".to_owned()),
-                ]),
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::LShift, "regular".to_owned()),
-                    (LedCode::Z, "regular".to_owned()),
-                    (LedCode::X, "regular".to_owned()),
-                    (LedCode::C, "regular".to_owned()),
-                    (LedCode::V, "regular".to_owned()),
-                    (LedCode::B, "regular".to_owned()),
-                    (LedCode::N, "regular".to_owned()),
-                    (LedCode::M, "regular".to_owned()),
-                    (LedCode::Comma, "regular".to_owned()),
-                    (LedCode::Period, "regular".to_owned()),
-                    (LedCode::FwdSlash, "regular".to_owned()),
-                    (LedCode::Rshift, "regular".to_owned()),
-                ]),
-                KeyRow::new(0.1, 0.1, vec![
-                    (LedCode::LCtrl, "regular".to_owned()),
-                    (LedCode::LFn, "regular".to_owned()),
-                    (LedCode::Meta, "regular".to_owned()),
-                    (LedCode::LAlt, "regular".to_owned()),
-                    (LedCode::Spacebar, "regular".to_owned()),
-                    (LedCode::RAlt, "regular".to_owned()),
-                    (LedCode::PrtSc, "regular".to_owned()),
-                    (LedCode::RCtrl, "regular".to_owned()),
-                ]),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::Esc, "regular".to_owned()),
+                        (LedCode::F1, "regular".to_owned()),
+                        (LedCode::F2, "regular".to_owned()),
+                        (LedCode::F3, "regular".to_owned()),
+                        (LedCode::F4, "regular".to_owned()),
+                        // not sure which key to put here
+                        (LedCode::F5, "regular".to_owned()),
+                        (LedCode::F6, "regular".to_owned()),
+                        (LedCode::F7, "regular".to_owned()),
+                        (LedCode::F8, "regular".to_owned()),
+                        (LedCode::F9, "regular".to_owned()),
+                        (LedCode::F10, "regular".to_owned()),
+                        (LedCode::F11, "regular".to_owned()),
+                        (LedCode::F12, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::Tilde, "regular".to_owned()),
+                        (LedCode::N1, "regular".to_owned()),
+                        (LedCode::N2, "regular".to_owned()),
+                        (LedCode::N3, "regular".to_owned()),
+                        (LedCode::N4, "regular".to_owned()),
+                        (LedCode::N5, "regular".to_owned()),
+                        (LedCode::N6, "regular".to_owned()),
+                        (LedCode::N7, "regular".to_owned()),
+                        (LedCode::N8, "regular".to_owned()),
+                        (LedCode::N9, "regular".to_owned()),
+                        (LedCode::N0, "regular".to_owned()),
+                        (LedCode::Hyphen, "regular".to_owned()),
+                        (LedCode::Equals, "regular".to_owned()),
+                        (LedCode::Backspace, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::Tab, "regular".to_owned()),
+                        (LedCode::Q, "regular".to_owned()),
+                        (LedCode::W, "regular".to_owned()),
+                        (LedCode::E, "regular".to_owned()),
+                        (LedCode::R, "regular".to_owned()),
+                        (LedCode::T, "regular".to_owned()),
+                        (LedCode::Y, "regular".to_owned()),
+                        (LedCode::U, "regular".to_owned()),
+                        (LedCode::I, "regular".to_owned()),
+                        (LedCode::O, "regular".to_owned()),
+                        (LedCode::P, "regular".to_owned()),
+                        (LedCode::LBracket, "regular".to_owned()),
+                        (LedCode::RBracket, "regular".to_owned()),
+                        (LedCode::BackSlash, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::Caps, "regular".to_owned()),
+                        (LedCode::A, "regular".to_owned()),
+                        (LedCode::S, "regular".to_owned()),
+                        (LedCode::D, "regular".to_owned()),
+                        (LedCode::F, "regular".to_owned()),
+                        (LedCode::G, "regular".to_owned()),
+                        (LedCode::H, "regular".to_owned()),
+                        (LedCode::J, "regular".to_owned()),
+                        (LedCode::K, "regular".to_owned()),
+                        (LedCode::L, "regular".to_owned()),
+                        (LedCode::SemiColon, "regular".to_owned()),
+                        (LedCode::Quote, "regular".to_owned()),
+                        (LedCode::Return, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::LShift, "regular".to_owned()),
+                        (LedCode::Z, "regular".to_owned()),
+                        (LedCode::X, "regular".to_owned()),
+                        (LedCode::C, "regular".to_owned()),
+                        (LedCode::V, "regular".to_owned()),
+                        (LedCode::B, "regular".to_owned()),
+                        (LedCode::N, "regular".to_owned()),
+                        (LedCode::M, "regular".to_owned()),
+                        (LedCode::Comma, "regular".to_owned()),
+                        (LedCode::Period, "regular".to_owned()),
+                        (LedCode::FwdSlash, "regular".to_owned()),
+                        (LedCode::Rshift, "regular".to_owned()),
+                    ],
+                ),
+                KeyRow::new(
+                    0.1,
+                    0.1,
+                    vec![
+                        (LedCode::LCtrl, "regular".to_owned()),
+                        (LedCode::LFn, "regular".to_owned()),
+                        (LedCode::Meta, "regular".to_owned()),
+                        (LedCode::LAlt, "regular".to_owned()),
+                        (LedCode::Spacebar, "regular".to_owned()),
+                        (LedCode::RAlt, "regular".to_owned()),
+                        (LedCode::PrtSc, "regular".to_owned()),
+                        (LedCode::RCtrl, "regular".to_owned()),
+                    ],
+                ),
             ],
         }
     }

rog-control-center/Cargo.toml

@@ -12,8 +12,9 @@ edition.workspace = true
 default = []
 mocking = []
 x11 = ["slint/backend-winit-x11"]
-# Requires RUSTFLAGS="--cfg tokio_unstable"
+# 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 }
@@ -58,3 +59,17 @@ features = [
 
 [build-dependencies.slint-build]
 git = "https://github.com/slint-ui/slint.git"
+
+[package.metadata.deb]
+license-file = ["../LICENSE", "4"]
+extended-description = """\
+The dbus server for asusctl and rog-control-center applications."""
+depends = "$auto"
+section = "utility"
+priority = "optional"
+assets = [
+  ["target/release/rog-control-center", "usr/bin/", "755"],
+  ["../rog_gui-fakeinstall/usr/share/applications/*", "usr/share/share/applications/", "644"],
+  ["../rog_gui-fakeinstall/usr/share/icons/hicolor/512x512/apps/*", "usr/share/icons/hicolor/512x512/apps", "644"],
+  ["../rog_gui-fakeinstall/usr/share/icons/hicolor/scalable/status/*", "usr/share/icons/hicolor/scalable/status", "644"],
+]

rog-control-center/src/main.rs

@@ -24,11 +24,16 @@ use tokio::runtime::Runtime;
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    // Ensure tracing spans are quiet by default unless user overrides
+    if std::env::var_os("RUST_LOG").is_none() {
+        std::env::set_var("RUST_LOG", "warn,tracing=error,zbus=error");
+    }
     let mut logger = env_logger::Builder::new();
     logger
-        .filter_level(LevelFilter::Warn)
         .parse_default_env()
-        .target(env_logger::Target::Stdout)
+        .filter_level(LevelFilter::Info)
+        .parse_default_env()
+        .target(env_logger::Target::Stderr)
         .format_timestamp(None)
         .init();
 
@@ -102,7 +107,6 @@ 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();
 
@@ -133,6 +137,18 @@ 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;
@@ -140,6 +156,7 @@ async fn main() -> Result<()> {
         config.startup_in_background = false;
         config.start_fullscreen = true;
     }
+
     config.write();
 
     let enable_tray_icon = config.enable_tray_icon;
@@ -198,76 +215,77 @@ async fn main() -> Result<()> {
                         }
                     })
                     .ok();
-            } else {
-                // 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;
+
+                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;
+            }
+
+            // 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;
                 }
 
-                // 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();
+                let app_state_copy = app_state.clone();
+                slint::invoke_from_event_loop(move || {
+                    UI.with(|ui| {
+                        let app_state_copy = app_state_copy.clone();
+                        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 config_copy = config.clone();
-                    let app_state_copy = app_state.clone();
-                    slint::invoke_from_event_loop(move || {
-                        UI.with(|ui| {
-                            let app_state_copy = app_state_copy.clone();
-                            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;
+                            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();
                                     }
-                                    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();
-                                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);
+                                })
+                                .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);
                     }
                 }
             }

rog-control-center/src/notify.rs

@@ -9,15 +9,11 @@ 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, Urgency};
-use rog_platform::platform::GpuMode;
+use notify_rust::{Hint, Notification, Timeout};
 use rog_platform::power::AsusPower;
 use serde::{Deserialize, Serialize};
-use supergfxctl::actions::UserActionRequired as GfxUserAction;
-use supergfxctl::pci_device::{GfxMode, GfxPower};
-use supergfxctl::zbus_proxy::DaemonProxy as SuperProxy;
+use supergfxctl::pci_device::GfxPower;
 use tokio::runtime::Runtime;
 use tokio::task::JoinHandle;
 
@@ -116,26 +112,26 @@ pub fn start_notifications(
 
                 if p == 0 && p != last_state {
                     let prog: Vec<&str> = bat.split_whitespace().collect();
-                    if prog.len() > 1 {
+                    if (!prog.is_empty()) && (!prog[0].is_empty()) {
                         let mut cmd = Command::new(prog[0]);
 
                         for arg in prog.iter().skip(1) {
                             cmd.arg(*arg);
                         }
                         cmd.spawn()
-                            .map_err(|e| error!("AC command error: {e:?}"))
+                            .map_err(|e| error!("Battery power command error: {e:?}"))
                             .ok();
                     }
                 } else if p != last_state {
                     let prog: Vec<&str> = ac.split_whitespace().collect();
-                    if prog.len() > 1 {
+                    if (!prog.is_empty()) && (!prog[0].is_empty()) {
                         let mut cmd = Command::new(prog[0]);
 
                         for arg in prog.iter().skip(1) {
                             cmd.arg(*arg);
                         }
                         cmd.spawn()
-                            .map_err(|e| error!("AC command error: {e:?}"))
+                            .map_err(|e| error!("AC power command error: {e:?}"))
                             .ok();
                     }
                 }
@@ -145,12 +141,8 @@ pub fn start_notifications(
         }
     });
 
-    let enabled_notifications_copy = 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());
-    };
+    info!("Attempting to start plain dgpu status monitor");
+    start_dpu_status_mon(config.clone());
 
     // GPU MUX Mode notif
     // TODO: need to get armoury attrs and iter to find
@@ -189,87 +181,9 @@ 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 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() {
-                    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,
@@ -295,95 +209,3 @@ 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)
-        .timeout(Timeout::Never)
-        .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.spawn_without_dbus_name().await {
+        match tray_init.disable_dbus_name(true).spawn().await {
             Ok(t) => tray = t,
             Err(e) => {
                 log::error!(

rog-control-center/src/ui/mod.rs

@@ -102,8 +102,9 @@ pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
             available.contains(&"xyz.ljones.Aura".to_string()),
             available.contains(&"xyz.ljones.Anime".to_string()),
             available.contains(&"xyz.ljones.FanCurves".to_string()),
-            true,
-            true,
+            true, // GPU Configuration
+            true, // App Settings
+            true, // About
         ]
         .into(),
     );

rog-control-center/src/ui/setup_fans.rs

@@ -168,15 +168,24 @@ pub fn setup_fan_curve_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
 
         update_fan_data(handle, balanced, perf, quiet);
 
+        let choices_for_ui = platform_profile_choices.clone();
         let handle_next1 = handle_copy.clone();
         if let Err(e) = handle_copy.upgrade_in_event_loop(move |handle| {
             let global = handle.global::<FanPageData>();
             let fans1 = fans.clone();
+            let choices = choices_for_ui.clone();
             global.on_set_profile_default(move |profile| {
                 let fans = fans1.clone();
                 let handle_next = handle_next1.clone();
+                let choices = choices.clone();
                 tokio::spawn(async move {
-                    if fans.set_curves_to_defaults(profile.into()).await.is_err() {
+                    let mut target: PlatformProfile = profile.into();
+                    if target == PlatformProfile::Quiet
+                        && !choices.contains(&PlatformProfile::Quiet)
+                    {
+                        target = PlatformProfile::LowPower;
+                    }
+                    if fans.set_curves_to_defaults(target).await.is_err() {
                         return;
                     }
                     let Ok(balanced) = fans

rog-control-center/src/ui/setup_system.rs

@@ -12,7 +12,7 @@ use slint::{ComponentHandle, Model, ModelRc, SharedString, VecModel};
 use super::show_toast;
 use crate::config::Config;
 use crate::zbus_proxies::find_iface_async;
-use crate::{set_ui_callbacks, set_ui_props_async, AttrMinMax, MainWindow, SystemPageData};
+use crate::{set_ui_callbacks, AttrMinMax, MainWindow, SystemPageData};
 
 const MINMAX: AttrMinMax = AttrMinMax {
     min: 0,
@@ -40,6 +40,12 @@ pub fn setup_system_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
     ui.global::<SystemPageData>().set_platform_profile(-1);
     ui.global::<SystemPageData>().set_panel_overdrive(-1);
     ui.global::<SystemPageData>().set_boot_sound(-1);
+    ui.global::<SystemPageData>().set_kbd_leds_awake(-1);
+    ui.global::<SystemPageData>().set_kbd_leds_sleep(-1);
+    ui.global::<SystemPageData>().set_kbd_leds_boot(-1);
+    ui.global::<SystemPageData>().set_kbd_leds_shutdown(-1);
+    ui.global::<SystemPageData>().set_screen_auto_brightness(-1);
+    ui.global::<SystemPageData>().set_mcu_powersave(-1);
     ui.global::<SystemPageData>().set_mini_led_mode(-1);
     ui.global::<SystemPageData>().set_screenpad_brightness(-1);
     ui.global::<SystemPageData>().set_ppt_pl1_spl(MINMAX);
@@ -308,6 +314,7 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
 
         let platform_copy = platform.clone();
         if let Ok(mut value) = platform.platform_profile_choices().await {
+            debug!("Available platform profile choices: {:?}", value);
             handle
                 .upgrade_in_event_loop(move |handle| {
                     value.sort();
@@ -519,7 +526,7 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
                 set_ui_callbacks!(handle,
                     SystemPageData(as i32),
                     platform_copy.platform_profile_on_battery(.into()),
-                    "Throttle policy on abttery set to {}",
+                    "Throttle policy on battery set to {}",
                     "Setting Throttle policy on battery failed"
                 );
                 set_ui_callbacks!(handle,
@@ -572,120 +579,152 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
 
         for attr in armoury_attrs {
             if let Ok(value) = attr.current_value().await {
-                let name = attr.name().await.unwrap();
-                debug!("Setting up {} = {value}", <&str>::from(name));
-                let platform = platform.clone();
-                handle
-                    .upgrade_in_event_loop(move |handle| match name {
-                        FirmwareAttribute::ApuMem => {}
-                        FirmwareAttribute::CoresPerformance => {}
-                        FirmwareAttribute::CoresEfficiency => {}
-                        FirmwareAttribute::PptEnabled => {
-                            init_property!(ppt_enabled, handle, value, bool);
-                            setup_callback!(ppt_enabled, handle, attr, bool);
-                            let handle_copy = handle.as_weak();
-                            let proxy_copy = attr.clone();
-                            tokio::spawn(async move {
-                                let mut x = proxy_copy.receive_current_value_changed().await;
-                                use futures_util::StreamExt;
-                                while let Some(e) = x.next().await {
-                                    if let Ok(out) = e.get().await {
-                                        handle_copy
-                                            .upgrade_in_event_loop(move |handle| {
-                                                handle
-                                                    .global::<SystemPageData>()
-                                                    .set_enable_ppt_group(out == 1);
-                                                handle
-                                                    .global::<SystemPageData>()
-                                                    .set_ppt_enabled(out == 1);
-                                            })
-                                            .ok();
+                if let Ok(name) = attr.name().await {
+                    debug!("Setting up {} = {value}", <&str>::from(name));
+                    let platform = platform.clone();
+                    handle
+                        .upgrade_in_event_loop(move |handle| match name {
+                            FirmwareAttribute::ApuMem => {}
+                            FirmwareAttribute::CoresPerformance => {}
+                            FirmwareAttribute::CoresEfficiency => {}
+                            FirmwareAttribute::PptEnabled => {
+                                init_property!(ppt_enabled, handle, value, bool);
+                                setup_callback!(ppt_enabled, handle, attr, bool);
+                                let handle_copy = handle.as_weak();
+                                let proxy_copy = attr.clone();
+                                tokio::spawn(async move {
+                                    let mut x = proxy_copy.receive_current_value_changed().await;
+                                    use futures_util::StreamExt;
+                                    while let Some(e) = x.next().await {
+                                        if let Ok(out) = e.get().await {
+                                            handle_copy
+                                                .upgrade_in_event_loop(move |handle| {
+                                                    handle
+                                                        .global::<SystemPageData>()
+                                                        .set_enable_ppt_group(out == 1);
+                                                    handle
+                                                        .global::<SystemPageData>()
+                                                        .set_ppt_enabled(out == 1);
+                                                })
+                                                .ok();
+                                        }
                                     }
-                                }
-                            });
-                            handle
-                                .global::<SystemPageData>()
-                                .set_ppt_enabled_available(true);
-                            handle
-                                .global::<SystemPageData>()
-                                .set_enable_ppt_group(value == 1);
-                        }
-                        FirmwareAttribute::PptPl1Spl => {
-                            init_minmax_property!(ppt_pl1_spl, handle, attr);
-                            setup_callback!(ppt_pl1_spl, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_pl1_spl, handle, attr);
-                            setup_minmax_external!(ppt_pl1_spl, handle, attr, platform);
-                        }
-                        FirmwareAttribute::PptPl2Sppt => {
-                            init_minmax_property!(ppt_pl2_sppt, handle, attr);
-                            setup_callback!(ppt_pl2_sppt, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_pl2_sppt, handle, attr);
-                            setup_minmax_external!(ppt_pl2_sppt, handle, attr, platform);
-                        }
-                        FirmwareAttribute::PptPl3Fppt => {
-                            init_minmax_property!(ppt_pl3_fppt, handle, attr);
-                            setup_callback!(ppt_pl3_fppt, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_pl3_fppt, handle, attr);
-                            setup_minmax_external!(ppt_pl3_fppt, handle, attr, platform);
-                        }
-                        FirmwareAttribute::PptFppt => {
-                            init_minmax_property!(ppt_fppt, handle, attr);
-                            setup_callback!(ppt_fppt, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_fppt, handle, attr);
-                            setup_minmax_external!(ppt_fppt, handle, attr, platform);
-                        }
-                        FirmwareAttribute::PptApuSppt => {
-                            init_minmax_property!(ppt_apu_sppt, handle, attr);
-                            setup_callback!(ppt_apu_sppt, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_apu_sppt, handle, attr);
-                            setup_minmax_external!(ppt_apu_sppt, handle, attr, platform);
-                        }
-                        FirmwareAttribute::PptPlatformSppt => {
-                            init_minmax_property!(ppt_platform_sppt, handle, attr);
-                            setup_callback!(ppt_platform_sppt, handle, attr, i32);
-                            setup_callback_restore_default!(ppt_platform_sppt, handle, attr);
-                            setup_minmax_external!(ppt_platform_sppt, handle, attr, platform);
-                        }
-                        FirmwareAttribute::NvDynamicBoost => {
-                            init_minmax_property!(nv_dynamic_boost, handle, attr);
-                            setup_callback!(nv_dynamic_boost, handle, attr, i32);
-                            setup_callback_restore_default!(nv_dynamic_boost, handle, attr);
-                            setup_minmax_external!(nv_dynamic_boost, handle, attr, platform);
-                        }
-                        FirmwareAttribute::NvTempTarget => {
-                            init_minmax_property!(nv_temp_target, handle, attr);
-                            setup_callback!(nv_temp_target, handle, attr, i32);
-                            setup_callback_restore_default!(nv_temp_target, handle, attr);
-                            setup_minmax_external!(nv_temp_target, handle, attr, platform);
-                        }
-                        FirmwareAttribute::DgpuBaseTgp => {}
-                        FirmwareAttribute::DgpuTgp => {}
-                        FirmwareAttribute::ChargeMode => {}
-                        FirmwareAttribute::BootSound => {
-                            init_property!(boot_sound, handle, value, i32);
-                            setup_callback!(boot_sound, handle, attr, i32);
-                            setup_external!(boot_sound, i32, handle, attr, value)
-                        }
-                        FirmwareAttribute::McuPowersave => {}
-                        FirmwareAttribute::PanelOverdrive => {
-                            init_property!(panel_overdrive, handle, value, i32);
-                            setup_callback!(panel_overdrive, handle, attr, i32);
-                            setup_external!(panel_overdrive, i32, handle, attr, value)
-                        }
-                        FirmwareAttribute::PanelHdMode => {}
-                        FirmwareAttribute::EgpuConnected => {}
-                        FirmwareAttribute::EgpuEnable => {}
-                        FirmwareAttribute::DgpuDisable => {}
-                        FirmwareAttribute::GpuMuxMode => {}
-                        FirmwareAttribute::MiniLedMode => {
-                            init_property!(mini_led_mode, handle, value, i32);
-                            setup_callback!(mini_led_mode, handle, attr, i32);
-                            setup_external!(mini_led_mode, i32, handle, attr, value);
-                        }
-                        FirmwareAttribute::PendingReboot => {}
-                        FirmwareAttribute::None => {}
-                    })
-                    .ok();
+                                });
+                                handle
+                                    .global::<SystemPageData>()
+                                    .set_ppt_enabled_available(true);
+                                handle
+                                    .global::<SystemPageData>()
+                                    .set_enable_ppt_group(value == 1);
+                            }
+                            FirmwareAttribute::PptPl1Spl => {
+                                init_minmax_property!(ppt_pl1_spl, handle, attr);
+                                setup_callback!(ppt_pl1_spl, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_pl1_spl, handle, attr);
+                                setup_minmax_external!(ppt_pl1_spl, handle, attr, platform);
+                            }
+                            FirmwareAttribute::PptPl2Sppt => {
+                                init_minmax_property!(ppt_pl2_sppt, handle, attr);
+                                setup_callback!(ppt_pl2_sppt, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_pl2_sppt, handle, attr);
+                                setup_minmax_external!(ppt_pl2_sppt, handle, attr, platform);
+                            }
+                            FirmwareAttribute::PptPl3Fppt => {
+                                init_minmax_property!(ppt_pl3_fppt, handle, attr);
+                                setup_callback!(ppt_pl3_fppt, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_pl3_fppt, handle, attr);
+                                setup_minmax_external!(ppt_pl3_fppt, handle, attr, platform);
+                            }
+                            FirmwareAttribute::PptFppt => {
+                                init_minmax_property!(ppt_fppt, handle, attr);
+                                setup_callback!(ppt_fppt, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_fppt, handle, attr);
+                                setup_minmax_external!(ppt_fppt, handle, attr, platform);
+                            }
+                            FirmwareAttribute::PptApuSppt => {
+                                init_minmax_property!(ppt_apu_sppt, handle, attr);
+                                setup_callback!(ppt_apu_sppt, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_apu_sppt, handle, attr);
+                                setup_minmax_external!(ppt_apu_sppt, handle, attr, platform);
+                            }
+                            FirmwareAttribute::PptPlatformSppt => {
+                                init_minmax_property!(ppt_platform_sppt, handle, attr);
+                                setup_callback!(ppt_platform_sppt, handle, attr, i32);
+                                setup_callback_restore_default!(ppt_platform_sppt, handle, attr);
+                                setup_minmax_external!(ppt_platform_sppt, handle, attr, platform);
+                            }
+                            FirmwareAttribute::NvDynamicBoost => {
+                                init_minmax_property!(nv_dynamic_boost, handle, attr);
+                                setup_callback!(nv_dynamic_boost, handle, attr, i32);
+                                setup_callback_restore_default!(nv_dynamic_boost, handle, attr);
+                                setup_minmax_external!(nv_dynamic_boost, handle, attr, platform);
+                            }
+                            FirmwareAttribute::NvTempTarget => {
+                                init_minmax_property!(nv_temp_target, handle, attr);
+                                setup_callback!(nv_temp_target, handle, attr, i32);
+                                setup_callback_restore_default!(nv_temp_target, handle, attr);
+                                setup_minmax_external!(nv_temp_target, handle, attr, platform);
+                            }
+                            FirmwareAttribute::DgpuBaseTgp => {}
+                            FirmwareAttribute::DgpuTgp => {}
+                            FirmwareAttribute::ChargeMode => {}
+                            FirmwareAttribute::BootSound => {
+                                init_property!(boot_sound, handle, value, i32);
+                                setup_callback!(boot_sound, handle, attr, i32);
+                                setup_external!(boot_sound, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::KbdLedsAwake => {
+                                init_property!(kbd_leds_awake, handle, value, i32);
+                                setup_callback!(kbd_leds_awake, handle, attr, i32);
+                                setup_external!(kbd_leds_awake, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::KbdLedsSleep => {
+                                init_property!(kbd_leds_sleep, handle, value, i32);
+                                setup_callback!(kbd_leds_sleep, handle, attr, i32);
+                                setup_external!(kbd_leds_sleep, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::KbdLedsBoot => {
+                                init_property!(kbd_leds_boot, handle, value, i32);
+                                setup_callback!(kbd_leds_boot, handle, attr, i32);
+                                setup_external!(kbd_leds_boot, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::KbdLedsShutdown => {
+                                init_property!(kbd_leds_shutdown, handle, value, i32);
+                                setup_callback!(kbd_leds_shutdown, handle, attr, i32);
+                                setup_external!(kbd_leds_shutdown, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::ScreenAutoBrightness => {
+                                init_property!(screen_auto_brightness, handle, value, i32);
+                                setup_callback!(screen_auto_brightness, handle, attr, i32);
+                                setup_external!(screen_auto_brightness, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::McuPowersave => {
+                                init_property!(mcu_powersave, handle, value, i32);
+                                setup_callback!(mcu_powersave, handle, attr, i32);
+                                setup_external!(mcu_powersave, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::PanelOverdrive => {
+                                init_property!(panel_overdrive, handle, value, i32);
+                                setup_callback!(panel_overdrive, handle, attr, i32);
+                                setup_external!(panel_overdrive, i32, handle, attr, value)
+                            }
+                            FirmwareAttribute::PanelHdMode => {}
+                            FirmwareAttribute::EgpuConnected => {}
+                            FirmwareAttribute::EgpuEnable => {}
+                            FirmwareAttribute::DgpuDisable => {}
+                            FirmwareAttribute::GpuMuxMode => {}
+                            FirmwareAttribute::MiniLedMode => {
+                                init_property!(mini_led_mode, handle, value, i32);
+                                setup_callback!(mini_led_mode, handle, attr, i32);
+                                setup_external!(mini_led_mode, i32, handle, attr, value);
+                            }
+                            FirmwareAttribute::PendingReboot => {}
+                            FirmwareAttribute::None => {}
+                        })
+                        .ok();
+                } else {
+                    error!("Attribute with no name, skipping");
+                }
             }
         }
         handle

rog-control-center/src/zbus_proxies.rs

@@ -89,7 +89,7 @@ where
         }
     }
     if paths.len() > 1 {
-        println!("Multiple asusd interfaces devices found");
+        log::warn!("Multiple asusd interfaces devices found");
     }
     if !paths.is_empty() {
         let mut ctrl = Vec::new();
@@ -129,7 +129,7 @@ where
         }
     }
     if paths.len() > 1 {
-        println!("Multiple asusd interfaces devices found");
+        log::warn!("Multiple asusd interfaces devices found");
     }
     if !paths.is_empty() {
         let mut ctrl = Vec::new();

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

@@ -0,0 +1,684 @@
+
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2024-06-09 00:20+0000\n"
+"PO-Revision-Date: 2024-07-19 11:32+0400\n"
+"Last-Translator: Rəşad Qasımlı <rashadgasimli2005@gmail.com>\n"
+"Language-Team: Azerbaijan <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: az\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+
+#: rog-control-center/ui/pages/anime.slint:6
+msgctxt "Anime Brightness"
+msgid "Off"
+msgstr "Sönülü"
+
+#: rog-control-center/ui/pages/anime.slint:7
+msgctxt "Anime Brightness"
+msgid "Low"
+msgstr "Aşağı"
+
+#: rog-control-center/ui/pages/anime.slint:8
+msgctxt "Anime Brightness"
+msgid "Med"
+msgstr "Orta"
+
+#: rog-control-center/ui/pages/anime.slint:9
+msgctxt "Anime Brightness"
+msgid "High"
+msgstr "Yüksək"
+
+#: rog-control-center/ui/pages/anime.slint:23
+msgctxt "AnimePageData"
+msgid "Glitch Construction"
+msgstr "Nasazlıq İnşaatı"
+
+#: rog-control-center/ui/pages/anime.slint:23
+msgctxt "AnimePageData"
+msgid "Static Emergence"
+msgstr "Statik Ortaya Çıxma"
+
+#: rog-control-center/ui/pages/anime.slint:25
+msgctxt "AnimePageData"
+msgid "Binary Banner Scroll"
+msgstr "İkili Afiş Sürüşdürmə"
+
+#: rog-control-center/ui/pages/anime.slint:25
+msgctxt "AnimePageData"
+msgid "Rog Logo Glitch"
+msgstr "Rog Logo Nasazlığı"
+
+#: rog-control-center/ui/pages/anime.slint:27
+msgctxt "AnimePageData"
+msgid "Banner Swipe"
+msgstr "Afiş Sürüşdürmə"
+
+#: rog-control-center/ui/pages/anime.slint:27
+msgctxt "AnimePageData"
+msgid "Starfield"
+msgstr "Ulduz Sahəsi"
+
+#: rog-control-center/ui/pages/anime.slint:29
+msgctxt "AnimePageData"
+msgid "Glitch Out"
+msgstr "Nasazlıq"
+
+#: rog-control-center/ui/pages/anime.slint:29
+msgctxt "AnimePageData"
+msgid "See Ya"
+msgstr "Görüşərik"
+
+#: rog-control-center/ui/pages/anime.slint:50
+msgctxt "Anime Brightness"
+msgid "Brightness"
+msgstr "Parlaqlıq"
+
+#: rog-control-center/ui/pages/anime.slint:66
+msgctxt "PageAnime"
+msgid "Enable display"
+msgstr "Ekranı aktivləşdir"
+
+#: rog-control-center/ui/pages/anime.slint:74 rog-control-center/ui/pages/anime.slint:97
+msgctxt "PageAnime"
+msgid "Advanced"
+msgstr "Qabaqcıl"
+
+#: rog-control-center/ui/pages/anime.slint:89
+msgctxt "PageAnime"
+msgid "Use built-in animations"
+msgstr "Yerləşik animasiyalardan istifadə edin"
+
+#: rog-control-center/ui/pages/anime.slint:146
+msgctxt "PageAnime"
+msgid "Set which builtin animations are played"
+msgstr "Hansı yerləşik animasiyaların oynadılacağını ayarlayın"
+
+#: rog-control-center/ui/pages/anime.slint:150
+msgctxt "Anime built-in selection"
+msgid "Boot Animation"
+msgstr "Açılış Animasiyası"
+
+#: rog-control-center/ui/pages/anime.slint:160
+msgctxt "Anime built-in selection"
+msgid "Running Animation"
+msgstr "İşləyən Animasiya"
+
+#: rog-control-center/ui/pages/anime.slint:170
+msgctxt "Anime built-in selection"
+msgid "Sleep Animation"
+msgstr "Yuxu Animasiyası"
+
+#: rog-control-center/ui/pages/anime.slint:180
+msgctxt "Anime built-in selection"
+msgid "Shutdown Animation"
+msgstr "Söndürmə Animasiyası"
+
+#: rog-control-center/ui/pages/anime.slint:220
+msgctxt "PageAnime"
+msgid "Advanced Display Settings"
+msgstr "Qabaqcıl Ekran Parametrləri"
+
+#: rog-control-center/ui/pages/anime.slint:225
+msgctxt "PageAnime"
+msgid "Off when lid closed"
+msgstr "Qapaq bağlandıqda söndür"
+
+#: rog-control-center/ui/pages/anime.slint:234
+msgctxt "PageAnime"
+msgid "Off when suspended"
+msgstr "Gözlədiləndə söndür"
+
+#: rog-control-center/ui/pages/anime.slint:243
+msgctxt "PageAnime"
+msgid "Off when on battery"
+msgstr "Batareyadaykən söndür"
+
+#: rog-control-center/ui/pages/app_settings.slint:26
+msgctxt "PageAppSettings"
+msgid "Run in background after closing"
+msgstr "Bağlandıqdan sonra arxafonda işlət"
+
+#: rog-control-center/ui/pages/app_settings.slint:34
+msgctxt "PageAppSettings"
+msgid "Start app in background (UI closed)"
+msgstr "Tətbiqi arxafonda başlat (İİ sönülü vəziyyətdə)"
+
+#: rog-control-center/ui/pages/app_settings.slint:42
+msgctxt "PageAppSettings"
+msgid "Enable system tray icon"
+msgstr "Sistem nimçə ikonunu aktivləşdir"
+
+#: rog-control-center/ui/pages/app_settings.slint:50
+msgctxt "PageAppSettings"
+msgid "Enable dGPU notifications"
+msgstr "Xarici ekran kartı bildirimlərini aktivləşdir"
+
+#: rog-control-center/ui/pages/aura.slint:28
+msgctxt "PageAura"
+msgid "Brightness"
+msgstr "Parlaqlıq"
+
+#: rog-control-center/ui/pages/aura.slint:39
+msgctxt "PageAura"
+msgid "Aura mode"
+msgstr "Aura rejimi"
+
+#: rog-control-center/ui/pages/aura.slint:59
+msgctxt "PageAura"
+msgid "Colour 1"
+msgstr "Rəng 1"
+
+#: rog-control-center/ui/pages/aura.slint:85
+msgctxt "PageAura"
+msgid "Colour 2"
+msgstr "Rəng 2"
+
+#: rog-control-center/ui/pages/aura.slint:119
+msgctxt "PageAura"
+msgid "Zone"
+msgstr "Qurşaq"
+
+#: rog-control-center/ui/pages/aura.slint:142
+msgctxt "PageAura"
+msgid "Direction"
+msgstr "İstiqamət"
+
+#: rog-control-center/ui/pages/aura.slint:164
+msgctxt "PageAura"
+msgid "Speed"
+msgstr "Sürət"
+
+#: rog-control-center/ui/pages/aura.slint:185
+msgctxt "PageAura"
+msgid "Power Settings"
+msgstr "Enerji Parametrləri"
+
+#: rog-control-center/ui/pages/aura.slint:270
+msgctxt "PageAura"
+msgid "Power Zones"
+msgstr "Enerji qurşaqları"
+
+#: rog-control-center/ui/pages/fans.slint:26
+msgctxt "FanTab"
+msgid "This fan is not avilable on this machine"
+msgstr "Bu ventilyator bu cihazda mövcud deyil"
+
+#: rog-control-center/ui/pages/fans.slint:34
+msgctxt "FanTab"
+msgid "Enabled"
+msgstr "Aktiv"
+
+#: rog-control-center/ui/pages/fans.slint:43
+msgctxt "FanTab"
+msgid "Apply"
+msgstr "Tətbiq et"
+
+#: rog-control-center/ui/pages/fans.slint:51
+msgctxt "FanTab"
+msgid "Cancel"
+msgstr "Ləğv et"
+
+#: rog-control-center/ui/pages/fans.slint:59
+msgctxt "FanTab"
+msgid "Factory Default (all fans)"
+msgstr "Zavod standartı (bütün ventilyatorlar)"
+
+#: rog-control-center/ui/pages/fans.slint:72
+msgctxt "PageFans"
+msgid "Balanced"
+msgstr "Balanslaşdırılmış"
+
+#: 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 "Prosessor"
+
+#: 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 "Orta"
+
+#: 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 "Ekran kartı"
+
+#: rog-control-center/ui/pages/fans.slint:131
+msgctxt "PageFans"
+msgid "Performance"
+msgstr "Performans"
+
+#: rog-control-center/ui/pages/fans.slint:190
+msgctxt "PageFans"
+msgid "Quiet"
+msgstr "Sakit"
+
+#: rog-control-center/ui/pages/system.slint:26
+msgctxt "SystemPageData"
+msgid "Balanced"
+msgstr "Balanslaşdırılmış"
+
+#: rog-control-center/ui/pages/system.slint:26 rog-control-center/ui/pages/system.slint:30
+msgctxt "SystemPageData"
+msgid "Performance"
+msgstr "Performans"
+
+#: rog-control-center/ui/pages/system.slint:26
+msgctxt "SystemPageData"
+msgid "Quiet"
+msgstr "Sakit"
+
+#: rog-control-center/ui/pages/system.slint:29
+msgctxt "SystemPageData"
+msgid "Default"
+msgstr "Standart"
+
+#: rog-control-center/ui/pages/system.slint:31
+msgctxt "SystemPageData"
+msgid "BalancePerformance"
+msgstr "Taraz-Performans"
+
+#: rog-control-center/ui/pages/system.slint:32
+msgctxt "SystemPageData"
+msgid "BalancePower"
+msgstr "Taraz-Enerji"
+
+#: rog-control-center/ui/pages/system.slint:33
+msgctxt "SystemPageData"
+msgid "Power"
+msgstr "Enerji"
+
+#: rog-control-center/ui/pages/system.slint:110
+msgctxt "PageSystem"
+msgid "Base system settings"
+msgstr "Əsas sistem parametrləri"
+
+#: rog-control-center/ui/pages/system.slint:115
+msgctxt "PageSystem"
+msgid "Charge limit"
+msgstr "Şarj limiti"
+
+#: rog-control-center/ui/pages/system.slint:127
+msgctxt "PageSystem"
+msgid "Throttle Policy"
+msgstr "Enerji Siyasəti"
+
+#: rog-control-center/ui/pages/system.slint:137
+msgctxt "PageSystem"
+msgid "Advanced"
+msgstr "Qabaqcıl"
+
+#: rog-control-center/ui/pages/system.slint:149
+msgctxt "PageSystem"
+msgid "Panel Overdrive"
+msgstr "Panel aşırma"
+
+#: rog-control-center/ui/pages/system.slint:157
+msgctxt "PageSystem"
+msgid "MiniLED Mode"
+msgstr "MiniLED Rejimi"
+
+#: rog-control-center/ui/pages/system.slint:165
+msgctxt "PageSystem"
+msgid "POST boot sound"
+msgstr "POST açılış səsi"
+
+#: rog-control-center/ui/pages/system.slint:183
+msgctxt "PageSystem"
+msgid "System performance settings"
+msgstr "Sistem performans parametrləri"
+
+#: rog-control-center/ui/pages/system.slint:188
+msgctxt "ppt_pl1_spl"
+msgid "PL1, sustained power limit"
+msgstr "ES1, davamlı enerji limiti"
+
+#: rog-control-center/ui/pages/system.slint:198
+msgctxt "ppt_pl2_sppt"
+msgid "PL2, turbo power limit"
+msgstr "ES2, turbo enerji limiti"
+
+#: rog-control-center/ui/pages/system.slint:208
+msgctxt "ppt_fppt"
+msgid "FPPT, Fast Power Limit"
+msgstr "SPEİ, sürətli enerji limiti"
+
+#: rog-control-center/ui/pages/system.slint:218
+msgctxt "ppt_apu_sppt"
+msgid "SPPT, APU slow power limit"
+msgstr "YPEİ, APU yavaş enerji limiti"
+
+#: rog-control-center/ui/pages/system.slint:228
+msgctxt "ppt_platform_sppt"
+msgid "Slow package power tracking limit"
+msgstr "Yavaş paket enerji izləmə limiti"
+
+#: rog-control-center/ui/pages/system.slint:238
+msgctxt "nv_dynamic_boost"
+msgid "dGPU boost overclock"
+msgstr "Xarici ekran kartının sürət aşırtma sürətini artırma"
+
+#: rog-control-center/ui/pages/system.slint:248
+msgctxt "nv_temp_target"
+msgid "dGPU temperature max"
+msgstr "Xarici ekran kartının maksimum temperaturu"
+
+#: rog-control-center/ui/pages/system.slint:294
+msgctxt "PageSystem"
+msgid "Energy Performance Preference linked to Throttle Policy"
+msgstr "Enerji Performans Üstünlüyü Enerji Siyasətinə bağlıdır"
+
+#: rog-control-center/ui/pages/system.slint:298
+msgctxt "PageSystem"
+msgid "Change EPP based on Throttle Policy"
+msgstr "EPÜ-yü Enerji Siyasəti üçün dəyişdirin"
+
+#: rog-control-center/ui/pages/system.slint:306
+msgctxt "PageSystem"
+msgid "EPP for Balanced Policy"
+msgstr "Balanslaşdırılmış Siyasət üçün EPÜ"
+
+#: rog-control-center/ui/pages/system.slint:316
+msgctxt "PageSystem"
+msgid "EPP for Performance Policy"
+msgstr "Perfomans Siyasəti üçün EPÜ"
+
+#: rog-control-center/ui/pages/system.slint:326
+msgctxt "PageSystem"
+msgid "EPP for Quiet Policy"
+msgstr "Sakit Siyasət üçün EPÜ"
+
+#: rog-control-center/ui/pages/system.slint:344
+msgctxt "PageSystem"
+msgid "Throttle Policy for power state"
+msgstr "Enerji vəziyyəti üçün Enerji Siyasəti"
+
+#: rog-control-center/ui/pages/system.slint:350
+msgctxt "PageSystem"
+msgid "Throttle Policy on Battery"
+msgstr "Batareyadaykən Enerji Siyasəti"
+
+#: rog-control-center/ui/pages/system.slint:360 rog-control-center/ui/pages/system.slint:381
+msgctxt "PageSystem"
+msgid "Enabled"
+msgstr "Aktiv"
+
+#: rog-control-center/ui/pages/system.slint:371
+msgctxt "PageSystem"
+msgid "Throttle Policy on AC"
+msgstr "Şarjdaykən Enerji Siyasəti"
+
+#: rog-control-center/ui/types/aura_types.slint:49
+msgctxt "Aura power zone"
+msgid "Logo"
+msgstr "Loqo"
+
+#: rog-control-center/ui/types/aura_types.slint:50 rog-control-center/ui/types/aura_types.slint:59
+msgctxt "Aura power zone"
+msgid "Keyboard"
+msgstr "Klaviatura"
+
+#: rog-control-center/ui/types/aura_types.slint:51 rog-control-center/ui/types/aura_types.slint:60
+msgctxt "Aura power zone"
+msgid "Lightbar"
+msgstr "İşıq Çubuğu"
+
+#: rog-control-center/ui/types/aura_types.slint:52
+msgctxt "Aura power zone"
+msgid "Lid"
+msgstr "Qapaq"
+
+#: rog-control-center/ui/types/aura_types.slint:53
+msgctxt "Aura power zone"
+msgid "Rear Glow"
+msgstr "Arxa Parıltı"
+
+#: rog-control-center/ui/types/aura_types.slint:54 rog-control-center/ui/types/aura_types.slint:61
+msgctxt "Aura power zone"
+msgid "Keyboard and Lightbar"
+msgstr "Klaviatura və İşıq Çubuğu"
+
+#: rog-control-center/ui/types/aura_types.slint:64
+msgctxt "Aura brightness"
+msgid "Off"
+msgstr "Sönülü"
+
+#: rog-control-center/ui/types/aura_types.slint:65
+msgctxt "Aura brightness"
+msgid "Low"
+msgstr "Aşağı"
+
+#: rog-control-center/ui/types/aura_types.slint:66
+msgctxt "Aura brightness"
+msgid "Med"
+msgstr "Orta"
+
+#: rog-control-center/ui/types/aura_types.slint:67
+msgctxt "Aura brightness"
+msgid "High"
+msgstr "Yüksək"
+
+#: rog-control-center/ui/types/aura_types.slint:72 rog-control-center/ui/types/aura_types.slint:87
+msgctxt "Basic aura mode"
+msgid "Static"
+msgstr "Statik"
+
+#: rog-control-center/ui/types/aura_types.slint:73 rog-control-center/ui/types/aura_types.slint:88
+msgctxt "Basic aura mode"
+msgid "Breathe"
+msgstr "Nəfəs Alma"
+
+#: rog-control-center/ui/types/aura_types.slint:74 rog-control-center/ui/types/aura_types.slint:89
+msgctxt "Basic aura mode"
+msgid "Strobe"
+msgstr "Fləş"
+
+#: rog-control-center/ui/types/aura_types.slint:75
+msgctxt "Basic aura mode"
+msgid "Rainbow"
+msgstr "Göyqurşağı"
+
+#: rog-control-center/ui/types/aura_types.slint:76
+msgctxt "Basic aura mode"
+msgid "Star"
+msgstr "Ulduz"
+
+#: rog-control-center/ui/types/aura_types.slint:77
+msgctxt "Basic aura mode"
+msgid "Rain"
+msgstr "Yağış"
+
+#: rog-control-center/ui/types/aura_types.slint:78
+msgctxt "Basic aura mode"
+msgid "Highlight"
+msgstr "Vurğulama"
+
+#: rog-control-center/ui/types/aura_types.slint:79
+msgctxt "Basic aura mode"
+msgid "Laser"
+msgstr "Lazer"
+
+#: rog-control-center/ui/types/aura_types.slint:80
+msgctxt "Basic aura mode"
+msgid "Ripple"
+msgstr "Dalğalanma"
+
+#: rog-control-center/ui/types/aura_types.slint:81
+msgctxt "Basic aura mode"
+msgid "Nothing"
+msgstr "Heç nə"
+
+#: rog-control-center/ui/types/aura_types.slint:82
+msgctxt "Basic aura mode"
+msgid "Pulse"
+msgstr "Nəbz"
+
+#: rog-control-center/ui/types/aura_types.slint:83
+msgctxt "Basic aura mode"
+msgid "Comet"
+msgstr "Quyruqlu Ulduz"
+
+#: rog-control-center/ui/types/aura_types.slint:84
+msgctxt "Basic aura mode"
+msgid "Flash"
+msgstr "Fləş"
+
+#: rog-control-center/ui/types/aura_types.slint:96
+msgctxt "Aura zone"
+msgid "None"
+msgstr "Heç biri"
+
+#: rog-control-center/ui/types/aura_types.slint:97
+msgctxt "Aura zone"
+msgid "Key1"
+msgstr "Açar1"
+
+#: rog-control-center/ui/types/aura_types.slint:98
+msgctxt "Aura zone"
+msgid "Key2"
+msgstr "Açar2"
+
+#: rog-control-center/ui/types/aura_types.slint:99
+msgctxt "Aura zone"
+msgid "Key3"
+msgstr "Açar3"
+
+#: rog-control-center/ui/types/aura_types.slint:100
+msgctxt "Aura zone"
+msgid "Key4"
+msgstr "Açar5"
+
+#: rog-control-center/ui/types/aura_types.slint:101
+msgctxt "Aura zone"
+msgid "Logo"
+msgstr "Loqo"
+
+#: rog-control-center/ui/types/aura_types.slint:102
+msgctxt "Aura zone"
+msgid "Lightbar Left"
+msgstr "İşıq Çubuğu Sol"
+
+#: rog-control-center/ui/types/aura_types.slint:103
+msgctxt "Aura zone"
+msgid "Lightbar Right"
+msgstr "İşıq Çubuğu Sağ"
+
+#: rog-control-center/ui/types/aura_types.slint:107
+msgctxt "Aura direction"
+msgid "Right"
+msgstr "Sağ"
+
+#: rog-control-center/ui/types/aura_types.slint:108
+msgctxt "Aura direction"
+msgid "Left"
+msgstr "Sol"
+
+#: rog-control-center/ui/types/aura_types.slint:109
+msgctxt "Aura direction"
+msgid "Up"
+msgstr "Yuxarı"
+
+#: rog-control-center/ui/types/aura_types.slint:110
+msgctxt "Aura direction"
+msgid "Down"
+msgstr "Aşağı"
+
+#: rog-control-center/ui/types/aura_types.slint:114
+msgctxt "Aura speed"
+msgid "Low"
+msgstr "Aşağı"
+
+#: rog-control-center/ui/types/aura_types.slint:115
+msgctxt "Aura speed"
+msgid "Medium"
+msgstr "Orta"
+
+#: rog-control-center/ui/types/aura_types.slint:116
+msgctxt "Aura speed"
+msgid "High"
+msgstr "Yüksək"
+
+#: rog-control-center/ui/widgets/aura_power.slint:33
+msgctxt "AuraPowerGroup"
+msgid "Boot"
+msgstr "Açılış"
+
+#: rog-control-center/ui/widgets/aura_power.slint:43
+msgctxt "AuraPowerGroup"
+msgid "Awake"
+msgstr "Oyaq"
+
+#: rog-control-center/ui/widgets/aura_power.slint:53
+msgctxt "AuraPowerGroup"
+msgid "Sleep"
+msgstr "Yuxu"
+
+#: rog-control-center/ui/widgets/aura_power.slint:63
+msgctxt "AuraPowerGroup"
+msgid "Shutdown"
+msgstr "Söndür"
+
+#: rog-control-center/ui/widgets/aura_power.slint:102
+msgctxt "AuraPowerGroupOld"
+msgid "Zone Selection"
+msgstr "Bölgə seçimi"
+
+#: rog-control-center/ui/widgets/aura_power.slint:114
+msgctxt "AuraPowerGroupOld"
+msgid "Boot"
+msgstr "Açılış"
+
+#: rog-control-center/ui/widgets/aura_power.slint:124
+msgctxt "AuraPowerGroupOld"
+msgid "Awake"
+msgstr "Oyaq"
+
+#: rog-control-center/ui/widgets/aura_power.slint:134
+msgctxt "AuraPowerGroupOld"
+msgid "Sleep"
+msgstr "Yuxu"
+
+#: rog-control-center/ui/main_window.slint:51
+msgctxt "MainWindow"
+msgid "ROG"
+msgstr ""
+
+#: rog-control-center/ui/main_window.slint:53
+msgctxt "Menu1"
+msgid "System Control"
+msgstr "Sistem Nəzarəti"
+
+#: rog-control-center/ui/main_window.slint:54
+msgctxt "Menu2"
+msgid "Keyboard Aura"
+msgstr "Klaviatura Aura"
+
+#: rog-control-center/ui/main_window.slint:55
+msgctxt "Menu3"
+msgid "AniMe Matrix"
+msgstr "AniMe Matrisi"
+
+#: rog-control-center/ui/main_window.slint:56
+msgctxt "Menu4"
+msgid "Fan Curves"
+msgstr "Fan Əyriləri"
+
+#: rog-control-center/ui/main_window.slint:57
+msgctxt "Menu5"
+msgid "App Settings"
+msgstr "Tətbiq Parametrləri"
+
+#: rog-control-center/ui/main_window.slint:58
+msgctxt "Menu6"
+msgid "About"
+msgstr "Haqqında"
+
+#: rog-control-center/ui/main_window.slint:70
+msgctxt "MainWindow"
+msgid "Quit App"
+msgstr "Tətbiqdən Çıxın"
+

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

@@ -0,0 +1,810 @@
+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/main_window.slint

@@ -7,6 +7,7 @@ import { PageFans } from "pages/fans.slint";
 import { PageAnime, AnimePageData } from "pages/anime.slint";
 import { RogItem } from "widgets/common.slint";
 import { PageAura } from "pages/aura.slint";
+import { PageGPU } from "pages/gpu.slint";
 import { Node } from "widgets/graph.slint";
 export { Node }
 import { FanPageData, FanType, Profile } from "types/fan_types.slint";
@@ -24,7 +25,15 @@ export component MainWindow inherits Window {
     default-font-size: 14px;
     default-font-weight: 400;
     icon: @image-url("../data/rog-control-center.png");
-    in property <[bool]> sidebar_items_avilable: [true, true, true, true, true, true];
+    in property <[bool]> sidebar_items_avilable: [
+        true,
+        true,
+        true,
+        true,
+        true, // GPU Configuration
+        true, // App Settings
+        true, // About
+    ];
     private property <bool> show_notif;
     private property <bool> fade_cover;
     private property <bool> toast: false;
@@ -58,8 +67,9 @@ export component MainWindow inherits Window {
                     @tr("Menu2" => "Keyboard Aura"),
                     @tr("Menu3" => "AniMe Matrix"),
                     @tr("Menu4" => "Fan Curves"),
-                    @tr("Menu5" => "App Settings"),
-                    @tr("Menu6" => "About"),
+                    @tr("Menu5" => "GPU Configuration"),
+                    @tr("Menu6" => "App Settings"),
+                    @tr("Menu7" => "About"),
                 ];
                 available: root.sidebar_items_avilable;
             }
@@ -89,26 +99,61 @@ export component MainWindow inherits Window {
                 height: root.height + 12px;
             }
 
-            aura := PageAura {
+            /*if(side-bar.current-item == 1):*/ aura := PageAura {
                 width: root.width - side-bar.width;
                 visible: side-bar.current-item == 1;
             }
 
             if(side-bar.current-item == 2): PageAnime {
                 width: root.width - side-bar.width;
+                visible: side-bar.current-item == 2;
             }
 
-            fans := PageFans {
+            if(side-bar.current-item == 3): fans := PageFans {
                 width: root.width - side-bar.width;
                 visible: side-bar.current-item == 3;
             }
 
-            if(side-bar.current-item == 4): PageAppSettings {
+            if(side-bar.current-item == 4): PageGPU {
                 width: root.width - side-bar.width;
+                visible: side-bar.current-item == 4;
             }
 
-            if(side-bar.current-item == 5): PageAbout {
+            if(side-bar.current-item == 5): PageAppSettings {
                 width: root.width - side-bar.width;
+                visible: side-bar.current-item == 5;
+            }
+
+            if(side-bar.current-item == 6): PageAbout {
+                width: root.width - side-bar.width;
+                visible: side-bar.current-item == 6;
+            }
+
+            if toast: Rectangle {
+                x: 0px;
+                y: root.height - self.height;
+                width: root.width - side-bar.width;
+                height: 40px;
+                opacity: 1.0;
+                background: Palette.selection-background;
+                clip: true;
+                TouchArea {
+                    height: 100%;
+                    width: 100%;
+                    clicked => {
+                        toast = false;
+                    }
+                }
+
+                Rectangle {
+                    height: 100%;
+                    width: 100%;
+                    background: Palette.control-background;
+                    Text {
+                        color: Palette.control-foreground;
+                        text: root.toast_text;
+                    }
+                }
             }
         }
     }
@@ -133,31 +178,6 @@ export component MainWindow inherits Window {
         }
     }
 
-    if toast: Rectangle {
-        x: 0px;
-        y: 0px;
-        width: root.width;
-        height: 32px;
-        opacity: 1.0;
-        background: Colors.grey;
-        TouchArea {
-            height: 100%;
-            width: 100%;
-            clicked => {
-                toast = false;
-            }
-        }
-
-        Rectangle {
-            height: 100%;
-            width: 100%;
-            background: Palette.control-background;
-            Text {
-                color: Palette.control-foreground;
-                text: root.toast_text;
-            }
-        }
-    }
 
     // // TODO: or use Dialogue
     if show_notif: Rectangle {
@@ -190,7 +210,9 @@ export component MainWindow inherits Window {
         y: 0px;
         width: root.width;
         height: root.height;
-        padding: 10px;
+
+        //padding only has effect on layout elements
+        //padding: 10px;
 
         background: Palette.background;
         border-color: Palette.border;

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

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

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

@@ -37,7 +37,8 @@ export component PageAnime inherits Rectangle {
     property <bool> show_builtin_advanced: false;
     clip: true;
     // TODO: slow with border-radius
-        padding: 8px;
+    //padding only has effect on layout elements
+    //padding: 8px;
     // height: parent.height - infobar.height - mainview.padding - self.padding * 2;
         // TODO: border-radius: 8px;
         VerticalLayout {

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

@@ -16,7 +16,9 @@ export component PageAppSettings inherits VerticalLayout {
     Rectangle {
         clip: true;
         // TODO: slow with border-radius
-        padding: 8px;
+        //padding only has effect on layout elements
+        //padding: 8px;
+
         // height: parent.height - infobar.height - mainview.padding - self.padding * 2;
         // TODO: border-radius: 8px;
         mainview := VerticalLayout {

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

@@ -113,7 +113,8 @@ export component PageAura inherits Rectangle {
                 min-height: 80px;
                 max-height: 90px;
                 RogItem {
-                    padding: 0px;
+                    //padding only has effect on layout elements
+                    //padding: 0px;
                     VerticalBox {
                         Text {
                             text: @tr("Zone");
@@ -136,7 +137,8 @@ export component PageAura inherits Rectangle {
                 }
 
                 RogItem {
-                    padding: 0px;
+                    //padding only has effect on layout elements
+                    //padding: 0px;
                     VerticalBox {
                         Text {
                             text: @tr("Direction");
@@ -158,7 +160,8 @@ export component PageAura inherits Rectangle {
                 }
 
                 RogItem {
-                    padding: 0px;
+                    //padding only has effect on layout elements
+                    //padding: 0px;
                     VerticalBox {
                         Text {
                             text: @tr("Speed");

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

@@ -0,0 +1,102 @@
+import { Palette, TabWidget, Button, CheckBox } from "std-widgets.slint";
+import { Graph, Node } from "../widgets/graph.slint";
+import { SystemToggle } from "../widgets/common.slint";
+import { Profile, FanType, FanPageData } from "../types/fan_types.slint";
+import { Palette, HorizontalBox , VerticalBox, ScrollView, Slider, Button, Switch, ComboBox, GroupBox, StandardButton} from "std-widgets.slint";
+
+export global GPUPageData {
+    // GPU mode and device state
+    in-out property <int> gpu_mux_mode: 1; // 0 = Ultra/Discreet, 1 = Integrated/Optimus
+    in-out property <int> dgpu_disabled: 0; // 1 == dGPU disabled
+    in-out property <int> egpu_enabled: 0; // 1 == eGPU (XGMobile) enabled
+    callback cb_gpu_mux_mode(int);
+    callback cb_dgpu_disabled(int);
+    callback cb_egpu_enabled(int);
+}
+
+export component PageGPU inherits Rectangle {
+
+    clip: true;
+    ScrollView {
+        VerticalLayout {
+            padding: 10px;
+            spacing: 10px;
+            alignment: LayoutAlignment.start;
+            Rectangle {
+                background: Palette.alternate-background;
+                border-color: Palette.accent-background;
+                border-width: 3px;
+                border-radius: 10px;
+                height: 40px;
+                Text {
+                    font-size: 18px;
+                    color: Palette.control-foreground;
+                    horizontal-alignment: TextHorizontalAlignment.center;
+                    text: @tr("GPU Configuration");
+                }
+            }
+        }
+
+        GroupBox {
+            HorizontalLayout {
+                spacing: 10px;
+
+                // Ultra (discreet) mode button - disabled if dGPU is marked disabled
+                Rectangle {
+                    width: 120px;
+                    height: 36px;
+                    border-radius: 6px;
+                    border-color: Palette.border;
+                    border-width: 2px;
+                    background: GPUPageData.gpu_mux_mode == 0 ? Palette.accent-background : Palette.control-background;
+                    opacity: GPUPageData.dgpu_disabled == 1 ? 0.5 : 1.0;
+
+                    Text {
+                        color: Palette.control-foreground;
+                        horizontal-alignment: TextHorizontalAlignment.center;
+                        vertical-alignment: TextVerticalAlignment.center;
+                        text: @tr("Ultra");
+                    }
+
+                    TouchArea {
+                        width: 100%;
+                        height: 100%;
+                        clicked => {
+                            if (GPUPageData.dgpu_disabled != 1 && GPUPageData.gpu_mux_mode != 0) {
+                                GPUPageData.cb_gpu_mux_mode(0);
+                            }
+                        }
+                    }
+                }
+
+                // Integrated (Optimus) mode button
+                Rectangle {
+                    width: 120px;
+                    height: 36px;
+                    border-radius: 6px;
+                    border-color: Palette.border;
+                    border-width: 2px;
+                    background: GPUPageData.gpu_mux_mode == 1 ? Palette.accent-background : Palette.control-background;
+
+                    Text {
+                        color: Palette.control-foreground;
+                        horizontal-alignment: TextHorizontalAlignment.center;
+                        vertical-alignment: TextVerticalAlignment.center;
+                        text: @tr("Integrated");
+                    }
+
+                    TouchArea {
+                        width: 100%;
+                        height: 100%;
+                        clicked => {
+                            if (GPUPageData.gpu_mux_mode != 1) {
+                                GPUPageData.cb_gpu_mux_mode(1);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+}

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

@@ -51,6 +51,18 @@ export global SystemPageData {
     callback cb_panel_overdrive(int);
     in-out property <int> boot_sound;
     callback cb_boot_sound(int);
+    in-out property <int> kbd_leds_awake;
+    callback cb_kbd_leds_awake(int);
+    in-out property <int> kbd_leds_sleep;
+    callback cb_kbd_leds_sleep(int);
+    in-out property <int> kbd_leds_boot;
+    callback cb_kbd_leds_boot(int);
+    in-out property <int> kbd_leds_shutdown;
+    callback cb_kbd_leds_shutdown(int);
+    in-out property <int> screen_auto_brightness;
+    callback cb_screen_auto_brightness(int);
+    in-out property <int> mcu_powersave;
+    callback cb_mcu_powersave(int);
     in-out property <int> mini_led_mode;
     callback cb_mini_led_mode(int);
 
@@ -140,7 +152,8 @@ export component PageSystem inherits Rectangle {
     property <bool> show_fade_cover: false;
     property <bool> show_throttle_advanced: false;
     clip: true;
-    padding: 8px;
+    //padding only has effect on layout elements
+    //padding: 8px;
     ScrollView {
         VerticalLayout {
             padding: 10px;
@@ -240,6 +253,66 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
+            if SystemPageData.kbd_leds_awake != -1 ||
+                    SystemPageData.kbd_leds_sleep != -1 ||
+                    SystemPageData.kbd_leds_boot != -1 ||
+                    SystemPageData.kbd_leds_shutdown != -1: VerticalLayout {
+                padding: 0px;
+                spacing: 0px;
+                alignment: LayoutAlignment.start;
+                Rectangle {
+                    background: Palette.alternate-background;
+                    border-color: Palette.accent-background;
+                    border-width: 3px;
+                    border-radius: 10px;
+                    height: 40px;
+                    Text {
+                        font-size: 18px;
+                        color: Palette.control-foreground;
+                        horizontal-alignment: TextHorizontalAlignment.center;
+                        text: @tr("Keyboard Power Management");
+                    }
+                }
+
+                GroupBox {
+
+                    HorizontalLayout {
+                        spacing: 10px;
+                        if SystemPageData.kbd_leds_awake != -1: SystemToggleInt {
+                            text: @tr("Keyboard Awake Effect");
+                            checked_int <=> SystemPageData.kbd_leds_awake;
+                            toggled => {
+                                SystemPageData.cb_kbd_leds_awake(SystemPageData.kbd_leds_awake)
+                            }
+                        }
+
+                        if SystemPageData.kbd_leds_sleep != -1: SystemToggleInt {
+                            text: @tr("Keyboard Sleep Effect");
+                            checked_int <=> SystemPageData.kbd_leds_sleep;
+                            toggled => {
+                                SystemPageData.cb_kbd_leds_sleep(SystemPageData.kbd_leds_sleep)
+                            }
+                        }
+
+                        if SystemPageData.kbd_leds_boot != -1: SystemToggleInt {
+                            text: @tr("Keyboard Boot Effect");
+                            checked_int <=> SystemPageData.kbd_leds_boot;
+                            toggled => {
+                                SystemPageData.cb_kbd_leds_boot(SystemPageData.kbd_leds_boot)
+                            }
+                        }
+
+                        if SystemPageData.kbd_leds_shutdown != -1: SystemToggleInt {
+                            text: @tr("Keyboard Shutdown Effect");
+                            checked_int <=> SystemPageData.kbd_leds_shutdown;
+                            toggled => {
+                                SystemPageData.cb_kbd_leds_shutdown(SystemPageData.kbd_leds_shutdown)
+                            }
+                        }
+                    }
+                }
+            }
+
             Rectangle {
                 background: Palette.alternate-background;
                 border-color: Palette.accent-background;
@@ -299,9 +372,25 @@ export component PageSystem inherits Rectangle {
                         SystemPageData.cb_boot_sound(SystemPageData.boot_sound)
                     }
                 }
+
+                if SystemPageData.screen_auto_brightness != -1: SystemToggleInt {
+                    text: @tr("Screen Auto Brightness");
+                    checked_int <=> SystemPageData.screen_auto_brightness;
+                    toggled => {
+                        SystemPageData.cb_screen_auto_brightness(SystemPageData.screen_auto_brightness)
+                    }
+                }
+
+                if SystemPageData.mcu_powersave != -1: SystemToggleInt {
+                    text: @tr("MCU Powersave");
+                    checked_int <=> SystemPageData.mcu_powersave;
+                    toggled => {
+                        SystemPageData.cb_mcu_powersave(SystemPageData.mcu_powersave)
+                    }
+                }
             }
 
-            if SystemPageData.ppt_pl1_spl.current != -1 || SystemPageData.ppt_pl2_sppt.current != -1 || SystemPageData.ppt_pl3_fppt.current != -1 || SystemPageData.ppt_fppt.current != -1 || SystemPageData.ppt_apu_sppt.current != -1 || SystemPageData.nv_temp_target.current != -1 || SystemPageData.nv_dynamic_boost.current != -1: HorizontalLayout {
+            if (SystemPageData.ppt_pl1_spl.max > 0 && SystemPageData.ppt_pl1_spl.current != -1) || (SystemPageData.ppt_pl2_sppt.max > 0 && SystemPageData.ppt_pl2_sppt.current != -1) || (SystemPageData.ppt_pl3_fppt.max > 0 && SystemPageData.ppt_pl3_fppt.current != -1) || (SystemPageData.ppt_fppt.max > 0 && SystemPageData.ppt_fppt.current != -1) || (SystemPageData.ppt_apu_sppt.max > 0 && SystemPageData.ppt_apu_sppt.current != -1) || (SystemPageData.nv_temp_target.max > 0 && SystemPageData.nv_temp_target.current != -1) || (SystemPageData.nv_dynamic_boost.max > 0 && SystemPageData.nv_dynamic_boost.current != -1): HorizontalLayout {
                 padding-right: 10px;
                 padding-left: 10px;
                 alignment: LayoutAlignment.space-between;
@@ -330,7 +419,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.ppt_pl1_spl.current != -1: SystemSlider {
+            if SystemPageData.ppt_pl1_spl.max > 0 && SystemPageData.ppt_pl1_spl.current != -1: SystemSlider {
                 text: @tr("ppt_pl1_spl" => "CPU Sustained Power Limit");
                 title: @tr("ppt_pl1_spl" => "CPU Sustained Power Limit");
                 help_text: @tr("ppt_pl1_spl_help" => "Long-term CPU power limit that affects sustained workload performance. Higher values may increase heat and power consumption.");
@@ -348,7 +437,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.ppt_pl2_sppt.current != -1: SystemSlider {
+            if SystemPageData.ppt_pl2_sppt.max > 0 && SystemPageData.ppt_pl2_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_pl2_sppt" => "CPU Turbo Power Limit");
                 title: @tr("ppt_pl2_sppt" => "CPU Turbo Power Limit");
                 help_text: @tr("ppt_pl2_sppt_help" => "Short-term CPU power limit for boost periods. Controls maximum power during brief high-performance bursts.");
@@ -366,7 +455,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.ppt_pl3_fppt.current != -1: SystemSlider {
+            if SystemPageData.ppt_pl3_fppt.max > 0 && SystemPageData.ppt_pl3_fppt.current != -1: SystemSlider {
                 text: @tr("ppt_pl3_fppt" => "CPU Fast Burst Power Limit");
                 title: @tr("ppt_pl3_fppt" => "CPU Fast Burst Power Limit");
                 help_text: @tr("ppt_pl3_fppt_help" => "Ultra-short duration power limit for instantaneous CPU bursts. Affects responsiveness during sudden workload spikes.");
@@ -383,7 +472,7 @@ export component PageSystem inherits Rectangle {
                     SystemPageData.cb_ppt_pl3_fppt(Math.round(value));
                 }
             }
-            if SystemPageData.ppt_fppt.current != -1: SystemSlider {
+            if SystemPageData.ppt_fppt.max > 0 && SystemPageData.ppt_fppt.current != -1: SystemSlider {
                 text: @tr("ppt_fppt" => "Fast Package Power Limit");
                 title: @tr("ppt_fppt" => "Fast Package Power Limit");
                 help_text: @tr("ppt_fppt_help" => "Ultra-short duration power limit for system package. Controls maximum power during millisecond-scale load spikes.");
@@ -401,7 +490,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.ppt_apu_sppt.current != -1: SystemSlider {
+            if SystemPageData.ppt_apu_sppt.max > 0 && SystemPageData.ppt_apu_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_apu_sppt" => "APU Sustained Power Limit");
                 title: @tr("ppt_apu_sppt" => "APU Sustained Power Limit");
                 help_text: @tr("ppt_apu_sppt_help" => "Long-term power limit for integrated graphics and CPU combined. Affects sustained performance of APU-based workloads.");
@@ -419,7 +508,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.ppt_platform_sppt.current != -1: SystemSlider {
+            if SystemPageData.ppt_platform_sppt.max > 0 && SystemPageData.ppt_platform_sppt.current != -1: SystemSlider {
                 text: @tr("ppt_platform_sppt" => "Platform Sustained Power Limit");
                 title: @tr("ppt_platform_sppt" => "Platform Sustained Power Limit");
                 help_text: @tr("ppt_platform_sppt_help" => "Overall system power limit for sustained operations. Controls total platform power consumption over extended periods.");
@@ -437,7 +526,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.nv_dynamic_boost.current != -1: SystemSlider {
+            if SystemPageData.nv_dynamic_boost.max > 0 && SystemPageData.nv_dynamic_boost.current != -1: SystemSlider {
                 text: @tr("nv_dynamic_boost" => "GPU Power Boost");
                 title: @tr("nv_dynamic_boost" => "GPU Power Boost");
                 help_text: @tr("nv_dynamic_boost_help" => "Additional power allocation for GPU dynamic boost. Higher values increase GPU performance but generate more heat.");
@@ -455,7 +544,7 @@ export component PageSystem inherits Rectangle {
                 }
             }
 
-            if SystemPageData.nv_temp_target.current != -1: SystemSlider {
+            if SystemPageData.nv_temp_target.max > 0 && SystemPageData.nv_temp_target.current != -1: SystemSlider {
                 text: @tr("nv_temp_target" => "GPU Temperature Limit");
                 title: @tr("nv_temp_target" => "GPU Temperature Limit");
                 help_text: @tr("nv_temp_target_help" => "Maximum GPU temperature threshold in Celsius. GPU will throttle to maintain temperature below this limit.");

rog-control-center/ui/widgets/sidebar.slint

@@ -4,7 +4,8 @@
 import { Palette, HorizontalBox, VerticalBox } from "std-widgets.slint";
 
 component SideBarItem inherits Rectangle {
-    padding: 10px;
+    // padding only has effect on layout elements
+    // padding: 10px;
     in property <bool> selected;
     in property <bool> has-focus;
     in-out property <string> text <=> label.text;

rog-dbus/src/zbus_anime.rs

@@ -5,7 +5,7 @@ use zbus::proxy;
 #[proxy(
     interface = "xyz.ljones.Anime",
     default_service = "xyz.ljones.Asusd",
-    default_path = "/xyz/ljones"
+    default_path = "/xyz/ljones/aura/anime"
 )]
 pub trait Anime {
     /// DeviceState method

rog-platform/src/asus_armoury.rs

@@ -124,6 +124,22 @@ impl Attribute {
         &self.scalar_increment
     }
 
+    fn read_attr_i32(&self, name: &str) -> Option<i32> {
+        read_i32(&self.base_path.join(name)).ok()
+    }
+
+    pub fn refresh_min_value(&self) -> Option<i32> {
+        self.read_attr_i32("min_value")
+    }
+
+    pub fn refresh_max_value(&self) -> Option<i32> {
+        self.read_attr_i32("max_value")
+    }
+
+    pub fn refresh_scalar_increment(&self) -> Option<i32> {
+        self.read_attr_i32("scalar_increment")
+    }
+
     /// Read all the immutable values to struct data. These should *never*
     /// change, if they do then it is possibly a driver issue - although this is
     /// subject to `firmware_attributes` class changes in kernel.
@@ -237,8 +253,19 @@ impl FirmwareAttributes {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum FirmwareAttributeType {
+    #[default]
+    Immediate,
+    TUFKeyboard,
+    Ppt,
+    Gpu,
+    Bios,
+}
+
 macro_rules! define_attribute_getters {
-    ($($attr:ident),*) => {
+    // Accept a list of attribute idents and an optional `types { .. }` block
+    ( $( $attr:ident ),* $(,)? $( ; types { $( $tattr:ident : $ptype:ident ),* $(,)? } )? ) => {
         impl FirmwareAttributes {
             $(
                 pub fn $attr(&self) -> Option<&Attribute> {
@@ -252,14 +279,80 @@ macro_rules! define_attribute_getters {
                 });
             )*
         }
+
+        impl FirmwareAttribute {
+            pub fn property_type(&self) -> FirmwareAttributeType {
+                match <&str>::from(*self) {
+                    $(
+                        $( stringify!($tattr) => FirmwareAttributeType::$ptype, )*
+                    )?
+                    _ => FirmwareAttributeType::Immediate,
+                }
+            }
+        }
     }
 }
 
 define_attribute_getters!(
-    apu_mem, cores_performance, cores_efficiency, ppt_pl1_spl, ppt_pl2_sppt, ppt_apu_sppt,
-    ppt_platform_sppt, ppt_fppt, nv_dynamic_boost, nv_temp_target, dgpu_base_tgp, dgpu_tgp,
-    charge_mode, boot_sound, mcu_powersave, panel_od, panel_hd_mode, egpu_connected, egpu_enable,
-    dgpu_disable, gpu_mux_mode, mini_led_mode
+    apu_mem,
+    cores_performance,
+    cores_efficiency,
+    ppt_pl1_spl,
+    ppt_pl2_sppt,
+    ppt_apu_sppt,
+    ppt_platform_sppt,
+    ppt_fppt,
+    nv_dynamic_boost,
+    nv_temp_target,
+    dgpu_base_tgp,
+    dgpu_tgp,
+    charge_mode,
+    boot_sound,
+    kbd_leds_awake,
+    kbd_leds_sleep,
+    kbd_leds_boot,
+    kbd_leds_shutdown,
+    mcu_powersave,
+    panel_od,
+    panel_hd_mode,
+    egpu_connected,
+    egpu_enable,
+    dgpu_disable,
+    gpu_mux_mode,
+    mini_led_mode,
+    screen_auto_brightness
+    ; types {
+        ppt_pl1_spl: Ppt,
+        ppt_pl2_sppt: Ppt,
+        ppt_apu_sppt: Ppt,
+        ppt_platform_sppt: Ppt,
+        ppt_fppt: Ppt,
+        nv_dynamic_boost: Ppt,
+        nv_temp_target: Ppt,
+        dgpu_base_tgp: Ppt,
+        dgpu_tgp: Ppt,
+
+        gpu_mux_mode: Gpu,
+        egpu_connected: Gpu,
+        egpu_enable: Gpu,
+        dgpu_disable: Gpu,
+
+        boot_sound: Bios,
+
+        mcu_powersave: Immediate,
+
+        screen_auto_brightness: Immediate,
+        mini_led_mode: Immediate,
+        panel_hd_mode: Immediate,
+        panel_od: Immediate,
+
+        kbd_leds_awake: TUFKeyboard,
+        kbd_leds_sleep: TUFKeyboard,
+        kbd_leds_boot: TUFKeyboard,
+        kbd_leds_shutdown: TUFKeyboard,
+
+        charge_mode: Immediate,
+    }
 );
 
 /// CamelCase names of the properties. Intended for use with DBUS
@@ -306,29 +399,11 @@ pub enum FirmwareAttribute {
     PendingReboot = 23,
     PptEnabled = 24,
     None = 25,
-}
-
-impl FirmwareAttribute {
-    pub fn is_ppt(&self) -> bool {
-        matches!(
-            self,
-            FirmwareAttribute::PptPl1Spl
-                | FirmwareAttribute::PptPl2Sppt
-                | FirmwareAttribute::PptPl3Fppt
-                | FirmwareAttribute::PptFppt
-                | FirmwareAttribute::PptApuSppt
-                | FirmwareAttribute::PptPlatformSppt
-        )
-    }
-
-    pub fn is_dgpu(&self) -> bool {
-        matches!(
-            self,
-            FirmwareAttribute::NvDynamicBoost
-                | FirmwareAttribute::NvTempTarget
-                | FirmwareAttribute::DgpuTgp
-        )
-    }
+    ScreenAutoBrightness = 26,
+    KbdLedsAwake = 27,
+    KbdLedsSleep = 28,
+    KbdLedsBoot = 29,
+    KbdLedsShutdown = 30,
 }
 
 impl From<&str> for FirmwareAttribute {
@@ -347,9 +422,13 @@ impl From<&str> for FirmwareAttribute {
             "nv_dynamic_boost" => Self::NvDynamicBoost,
             "nv_temp_target" => Self::NvTempTarget,
             "nv_base_tgp" => Self::DgpuBaseTgp,
-            "dgpu_tgp" => Self::DgpuTgp,
+            "nv_tgp" => Self::DgpuTgp,
             "charge_mode" => Self::ChargeMode,
             "boot_sound" => Self::BootSound,
+            "kbd_leds_awake" => Self::KbdLedsAwake,
+            "kbd_leds_sleep" => Self::KbdLedsSleep,
+            "kbd_leds_boot" => Self::KbdLedsBoot,
+            "kbd_leds_shutdown" => Self::KbdLedsShutdown,
             "mcu_powersave" => Self::McuPowersave,
             "panel_overdrive" => Self::PanelOverdrive,
             "panel_hd_mode" => Self::PanelHdMode,
@@ -359,6 +438,7 @@ impl From<&str> for FirmwareAttribute {
             "gpu_mux_mode" => Self::GpuMuxMode,
             "mini_led_mode" => Self::MiniLedMode,
             "pending_reboot" => Self::PendingReboot,
+            "screen_auto_brightness" => Self::ScreenAutoBrightness,
             _ => {
                 error!("Invalid firmware attribute: {}", s);
                 Self::None
@@ -383,7 +463,7 @@ impl From<FirmwareAttribute> for &str {
             FirmwareAttribute::NvDynamicBoost => "nv_dynamic_boost",
             FirmwareAttribute::NvTempTarget => "nv_temp_target",
             FirmwareAttribute::DgpuBaseTgp => "dgpu_base_tgp",
-            FirmwareAttribute::DgpuTgp => "dgpu_tgp",
+            FirmwareAttribute::DgpuTgp => "nv_tgp",
             FirmwareAttribute::ChargeMode => "charge_mode",
             FirmwareAttribute::BootSound => "boot_sound",
             FirmwareAttribute::McuPowersave => "mcu_powersave",
@@ -394,7 +474,12 @@ impl From<FirmwareAttribute> for &str {
             FirmwareAttribute::DgpuDisable => "dgpu_disable",
             FirmwareAttribute::GpuMuxMode => "gpu_mux_mode",
             FirmwareAttribute::MiniLedMode => "mini_led_mode",
+            FirmwareAttribute::KbdLedsAwake => "kbd_leds_awake",
+            FirmwareAttribute::KbdLedsSleep => "kbd_leds_sleep",
+            FirmwareAttribute::KbdLedsBoot => "kbd_leds_boot",
+            FirmwareAttribute::KbdLedsShutdown => "kbd_leds_shutdown",
             FirmwareAttribute::PendingReboot => "pending_reboot",
+            FirmwareAttribute::ScreenAutoBrightness => "screen_auto_brightness",
             FirmwareAttribute::None => "none",
         }
     }

rog-platform/src/cpu.rs

@@ -267,18 +267,24 @@ mod tests {
     fn check_cpu() {
         let cpu = CPUControl::new().unwrap();
         assert_eq!(cpu.get_governor().unwrap(), CPUGovernor::Powersave);
-        assert_eq!(cpu.get_available_governors().unwrap(), vec![
-            CPUGovernor::Performance,
-            CPUGovernor::Powersave
-        ]);
+        assert_eq!(
+            cpu.get_available_governors().unwrap(),
+            vec![
+                CPUGovernor::Performance,
+                CPUGovernor::Powersave
+            ]
+        );
 
         assert_eq!(cpu.get_epp().unwrap(), CPUEPP::BalancePower);
-        assert_eq!(cpu.get_available_epp().unwrap(), vec![
-            CPUEPP::Default,
-            CPUEPP::Performance,
-            CPUEPP::BalancePerformance,
-            CPUEPP::BalancePower,
-            CPUEPP::Power,
-        ]);
+        assert_eq!(
+            cpu.get_available_epp().unwrap(),
+            vec![
+                CPUEPP::Default,
+                CPUEPP::Performance,
+                CPUEPP::BalancePerformance,
+                CPUEPP::BalancePower,
+                CPUEPP::Power,
+            ]
+        );
     }
 }

rog-platform/src/platform.rs

@@ -275,11 +275,16 @@ impl std::str::FromStr for PlatformProfile {
     type Err = PlatformError;
 
     fn from_str(profile: &str) -> Result<Self> {
-        match profile.to_ascii_lowercase().trim() {
+        match profile
+            .to_ascii_lowercase()
+            .trim()
+            .replace(|c| !char::is_alphabetic(c), "")
+            .as_str()
+        {
             "balanced" => Ok(PlatformProfile::Balanced),
             "performance" => Ok(PlatformProfile::Performance),
             "quiet" => Ok(PlatformProfile::Quiet),
-            "low-power" => Ok(PlatformProfile::LowPower),
+            "lowpower" => Ok(PlatformProfile::LowPower),
             "custom" => Ok(PlatformProfile::Custom),
             _ => Err(PlatformError::NotSupported),
         }
@@ -288,11 +293,16 @@ impl std::str::FromStr for PlatformProfile {
 
 impl From<&str> for PlatformProfile {
     fn from(profile: &str) -> Self {
-        match profile.to_ascii_lowercase().trim() {
+        match profile
+            .to_ascii_lowercase()
+            .trim()
+            .replace(|c| !char::is_alphabetic(c), "")
+            .as_str()
+        {
             "balanced" => PlatformProfile::Balanced,
             "performance" => PlatformProfile::Performance,
             "quiet" => PlatformProfile::Quiet,
-            "low-power" => PlatformProfile::LowPower,
+            "lowpower" => PlatformProfile::LowPower,
             "custom" => PlatformProfile::Custom,
             _ => {
                 warn!("{profile} is unknown, using ThrottlePolicy::Balanced");

rog-platform/src/power.rs

@@ -101,8 +101,15 @@ impl AsusPower {
             });
         }
 
-        Err(PlatformError::MissingFunction(
-            "Did not find a battery".to_owned(),
-        ))
+        // No battery found. Return an AsusPower with an empty battery path so
+        // callers can still be constructed and query `has_*` methods which
+        // will correctly report absence. This avoids hard-failing on systems
+        // where the asus-nb-wmi driver loads on desktops with no battery.
+        info!("Did not find a battery, continuing without battery support");
+        Ok(Self {
+            mains,
+            battery: PathBuf::new(),
+            usb,
+        })
     }
 }

rog-profiles/src/lib.rs

@@ -37,8 +37,9 @@ pub fn find_fan_curve_node() -> Result<Device, ProfileError> {
     derive(Type, Value, OwnedValue),
     zvariant(signature = "s")
 )]
-#[derive(Deserialize, Serialize, Debug, Hash, PartialEq, Eq, Clone, Copy)]
+#[derive(Default, Deserialize, Serialize, Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum FanCurvePU {
+    #[default]
     CPU = 0,
     GPU = 1,
     MID = 2,
@@ -100,12 +101,6 @@ impl std::str::FromStr for FanCurvePU {
     }
 }
 
-impl Default for FanCurvePU {
-    fn default() -> Self {
-        Self::CPU
-    }
-}
-
 /// Main purpose of `FanCurves` is to enable restoring state on system boot
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Deserialize, Serialize, Debug, Default)]

rog-scsi/src/builtin_modes.rs

@@ -177,6 +177,12 @@ 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,9 +12,13 @@ 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,
-    GA605,
-    GU605,
+    GA403_2024,
+    GA403_2025,
+    GA605_2024,
+    GA605_2025,
+    GU605_2024,
+    GU605_2025,
+    G614_2025,
     #[default]
     Unsupported,
 }
@@ -22,30 +26,51 @@ pub enum SlashType {
 impl SlashType {
     pub const fn prod_id(&self) -> u16 {
         match self {
-            SlashType::GA403 => PROD_ID1,
-            SlashType::GA605 => PROD_ID2,
-            SlashType::GU605 => PROD_ID1,
+            SlashType::GA403_2025 => PROD_ID2,
+            SlashType::GA403_2024 => PROD_ID1,
+            SlashType::GA605_2025 => PROD_ID2,
+            SlashType::GA605_2024 => PROD_ID2,
+            SlashType::GU605_2025 => PROD_ID2,
+            SlashType::GU605_2024 => PROD_ID1,
+            SlashType::G614_2025 => PROD_ID2,
             SlashType::Unsupported => 0,
         }
     }
 
     pub const fn prod_id_str(&self) -> &str {
         match self {
-            SlashType::GA403 => PROD_ID1_STR,
-            SlashType::GA605 => PROD_ID2_STR,
-            SlashType::GU605 => PROD_ID1_STR,
+            SlashType::GA403_2025 => PROD_ID2_STR,
+            SlashType::GA403_2024 => PROD_ID1_STR,
+            SlashType::GA605_2025 => PROD_ID2_STR,
+            SlashType::GA605_2024 => PROD_ID2_STR,
+            SlashType::GU605_2025 => PROD_ID2_STR,
+            SlashType::GU605_2024 => PROD_ID1_STR,
+            SlashType::G614_2025 => PROD_ID2_STR,
             SlashType::Unsupported => "",
         }
     }
 
     pub fn from_dmi() -> Self {
         let board_name = DMIID::new().unwrap_or_default().board_name.to_uppercase();
-        if board_name.contains("GA403") {
-            SlashType::GA403
+        if board_name.contains("G614F") {
+            SlashType::G614_2025
+        } else if [
+            "GA403W", "GA403UH", "GA403UM", "GA403UP",
+        ]
+        .iter()
+        .any(|s| board_name.contains(s))
+        {
+            SlashType::GA403_2025
+        } else if board_name.contains("GA403") {
+            SlashType::GA403_2024
+        } else if board_name.contains("GA605K") {
+            SlashType::GA605_2025
         } else if board_name.contains("GA605") {
-            SlashType::GA605
+            SlashType::GA605_2024
+        } else if board_name.contains("GU605C") {
+            SlashType::GU605_2025
         } else if board_name.contains("GU605") {
-            SlashType::GU605
+            SlashType::GU605_2024
         } else {
             SlashType::Unsupported
         }
@@ -56,10 +81,14 @@ impl FromStr for SlashType {
     type Err = SlashError;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        Ok(match s {
-            "ga403" | "GA403" => Self::GA403,
-            "ga605" | "GA605" => Self::GA605,
-            "gu605" | "GU605" => Self::GU605,
+        Ok(match s.to_uppercase().as_str() {
+            "GA403_2025" => Self::GA403_2025,
+            "GA403_2024" => Self::GA403_2024,
+            "GA605_2025" => Self::GA605_2025,
+            "GA605_2024" => Self::GA605_2024,
+            "GU605_2025" => Self::GU605_2025,
+            "GU605_2024" => Self::GU605_2024,
+            "G614_2025" => Self::G614_2025,
             _ => Self::Unsupported,
         })
     }
@@ -68,6 +97,7 @@ impl FromStr for SlashType {
 #[cfg_attr(feature = "dbus", derive(Type, Value, OwnedValue))]
 #[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
 pub enum SlashMode {
+    Static = 0x06,
     Bounce = 0x10,
     Slash = 0x12,
     Loading = 0x13,
@@ -91,6 +121,7 @@ impl FromStr for SlashMode {
 
     fn from_str(s: &str) -> Result<Self, SlashError> {
         match s {
+            "Static" => Ok(SlashMode::Static),
             "Bounce" => Ok(SlashMode::Bounce),
             "Slash" => Ok(SlashMode::Slash),
             "Loading" => Ok(SlashMode::Loading),
@@ -114,6 +145,7 @@ impl FromStr for SlashMode {
 impl Display for SlashMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let str = match &self {
+            SlashMode::Static => String::from("Static"),
             SlashMode::Bounce => String::from("Bounce"),
             SlashMode::Slash => String::from("Slash"),
             SlashMode::Loading => String::from("Loading"),
@@ -135,8 +167,9 @@ impl Display for SlashMode {
 }
 
 impl SlashMode {
-    pub fn list() -> [String; 15] {
+    pub fn list() -> [String; 16] {
         [
+            SlashMode::Static.to_string(),
             SlashMode::Bounce.to_string(),
             SlashMode::Slash.to_string(),
             SlashMode::Loading.to_string(),

rog-slash/src/usb.rs

@@ -37,14 +37,26 @@ pub fn get_slash_type() -> SlashType {
     let dmi = DMIID::new()
         .map_err(|_| SlashError::NoDevice)
         .unwrap_or_default();
-    let board_name = dmi.board_name;
-
-    if board_name.contains("GA403") {
-        SlashType::GA403
+    let board_name = dmi.board_name.to_uppercase();
+    if board_name.contains("G614F") {
+        SlashType::G614_2025
+    } else if [
+        "GA403W", "GA403UH", "GA403UM", "GA403UP",
+    ]
+    .iter()
+    .any(|s| board_name.contains(s))
+    {
+        SlashType::GA403_2025
+    } else if board_name.contains("GA403") {
+        SlashType::GA403_2024
+    } else if board_name.contains("GA605K") {
+        SlashType::GA605_2025
     } else if board_name.contains("GA605") {
-        SlashType::GA605
+        SlashType::GA605_2024
+    } else if board_name.contains("GU605C") {
+        SlashType::GU605_2025
     } else if board_name.contains("GU605") {
-        SlashType::GU605
+        SlashType::GU605_2024
     } else {
         SlashType::Unsupported
     }
@@ -52,9 +64,13 @@ pub fn get_slash_type() -> SlashType {
 
 pub const fn report_id(slash_type: SlashType) -> u8 {
     match slash_type {
-        SlashType::GA403 => REPORT_ID_193B,
-        SlashType::GA605 => REPORT_ID_19B6,
-        SlashType::GU605 => REPORT_ID_193B,
+        SlashType::GA403_2025 => REPORT_ID_19B6,
+        SlashType::GA403_2024 => REPORT_ID_193B,
+        SlashType::GA605_2025 => REPORT_ID_19B6,
+        SlashType::GA605_2024 => REPORT_ID_19B6,
+        SlashType::GU605_2025 => REPORT_ID_19B6,
+        SlashType::GU605_2024 => REPORT_ID_193B,
+        SlashType::G614_2025 => REPORT_ID_19B6,
         SlashType::Unsupported => REPORT_ID_19B6,
     }
 }

rust-toolchain

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

simulators/src/animatrix/map_g635l.rs

@@ -0,0 +1,70 @@
+use super::Row;
+
+// TODO: This is a placeholder for G635L map
+pub const G635L: [Row; 63] = [
+    Row(0x01, 7, 32, 0),
+    Row(0x01, 7 + 34, 32, 0),
+    Row(0x01, 7 + 68, 32, 0),
+    Row(0x01, 7 + 102, 32, 0), // 34 len
+    Row(0x01, 7 + 136, 32, 0),
+    Row(0x01, 7 + 170, 34, 0),
+    Row(0x01, 7 + 204, 34, 0),
+    Row(0x01, 7 + 238, 34, 0),
+    Row(0x01, 7 + 272, 34, 0),
+    Row(0x01, 7 + 306, 34, 0),
+    Row(0x01, 7 + 340, 34, 0),
+    Row(0x01, 7 + 374, 34, 0),
+    Row(0x01, 7 + 408, 33, 1),
+    Row(0x01, 7 + 441, 33, 1),
+    Row(0x01, 7 + 474, 32, 2),
+    Row(0x01, 7 + 506, 32, 2),
+    Row(0x01, 7 + 538, 31, 3),
+    Row(0x01, 7 + 569, 31, 3),
+    Row(0x01, 7 + 600, 28, 4),
+    //
+    Row(0x74, 7 + 1, 3, 28 + 4), // adds to end of previous
+    Row(0x74, 7 + 3, 30, 4),
+    Row(0x74, 7 + 33, 29, 5),
+    Row(0x74, 7 + 62, 29, 5),
+    Row(0x74, 7 + 91, 28, 6),
+    Row(0x74, 7 + 119, 28, 6),
+    Row(0x74, 7 + 147, 27, 7),
+    Row(0x74, 7 + 174, 27, 7),
+    Row(0x74, 7 + 202, 26, 9),
+    Row(0x74, 7 + 228, 26, 9),
+    Row(0x74, 7 + 254, 25, 10),
+    Row(0x74, 7 + 278, 25, 9), // WEIRD OFFSET
+    Row(0x74, 7 + 303, 24, 10),
+    Row(0x74, 7 + 327, 24, 10),
+    Row(0x74, 7 + 351, 23, 11),
+    Row(0x74, 7 + 374, 23, 11),
+    Row(0x74, 7 + 397, 22, 12),
+    Row(0x74, 7 + 419, 22, 12),
+    Row(0x74, 7 + 441, 21, 13),
+    Row(0x74, 7 + 462, 21, 13),
+    Row(0x74, 7 + 483, 20, 14),
+    Row(0x74, 7 + 503, 20, 14),
+    Row(0x74, 7 + 523, 19, 15),
+    Row(0x74, 7 + 542, 19, 15),
+    Row(0x74, 7 + 561, 18, 16),
+    Row(0x74, 7 + 579, 18, 16),
+    Row(0x74, 7 + 597, 17, 17),
+    Row(0x74, 7 + 614, 13, 17),
+    //
+    Row(0xe7, 7 + 1, 4, 13 + 18), // adds to end of previous
+    Row(0xe7, 7 + 4, 16, 18),
+    Row(0xe7, 7 + 20, 16, 18),
+    Row(0xe7, 7 + 36, 15, 19),
+    Row(0xe7, 7 + 51, 15, 19),
+    Row(0xe7, 7 + 66, 14, 20),
+    Row(0xe7, 7 + 80, 12, 20), // too long? 14
+    Row(0xe7, 7 + 94, 13, 21),
+    Row(0xe7, 7 + 107, 13, 21),
+    Row(0xe7, 7 + 120, 12, 12), // Actual display end
+    Row(0xe7, 7 + 132, 12, 22),
+    Row(0xe7, 7 + 144, 11, 23),
+    Row(0xe7, 7 + 155, 11, 23),
+    Row(0xe7, 7 + 166, 10, 24),
+    Row(0xe7, 7 + 176, 10, 24),
+    Row(0xe7, 7 + 186, 9, 25),
+];

simulators/src/animatrix/map_g835l.rs

@@ -0,0 +1,70 @@
+use super::Row;
+
+// TODO: This is a placeholder for G835L map
+pub const G835L: [Row; 63] = [
+    Row(0x01, 7, 32, 0),
+    Row(0x01, 7 + 34, 32, 0),
+    Row(0x01, 7 + 68, 32, 0),
+    Row(0x01, 7 + 102, 32, 0), // 34 len
+    Row(0x01, 7 + 136, 32, 0),
+    Row(0x01, 7 + 170, 34, 0),
+    Row(0x01, 7 + 204, 34, 0),
+    Row(0x01, 7 + 238, 34, 0),
+    Row(0x01, 7 + 272, 34, 0),
+    Row(0x01, 7 + 306, 34, 0),
+    Row(0x01, 7 + 340, 34, 0),
+    Row(0x01, 7 + 374, 34, 0),
+    Row(0x01, 7 + 408, 33, 1),
+    Row(0x01, 7 + 441, 33, 1),
+    Row(0x01, 7 + 474, 32, 2),
+    Row(0x01, 7 + 506, 32, 2),
+    Row(0x01, 7 + 538, 31, 3),
+    Row(0x01, 7 + 569, 31, 3),
+    Row(0x01, 7 + 600, 28, 4),
+    //
+    Row(0x74, 7 + 1, 3, 28 + 4), // adds to end of previous
+    Row(0x74, 7 + 3, 30, 4),
+    Row(0x74, 7 + 33, 29, 5),
+    Row(0x74, 7 + 62, 29, 5),
+    Row(0x74, 7 + 91, 28, 6),
+    Row(0x74, 7 + 119, 28, 6),
+    Row(0x74, 7 + 147, 27, 7),
+    Row(0x74, 7 + 174, 27, 7),
+    Row(0x74, 7 + 202, 26, 9),
+    Row(0x74, 7 + 228, 26, 9),
+    Row(0x74, 7 + 254, 25, 10),
+    Row(0x74, 7 + 278, 25, 9), // WEIRD OFFSET
+    Row(0x74, 7 + 303, 24, 10),
+    Row(0x74, 7 + 327, 24, 10),
+    Row(0x74, 7 + 351, 23, 11),
+    Row(0x74, 7 + 374, 23, 11),
+    Row(0x74, 7 + 397, 22, 12),
+    Row(0x74, 7 + 419, 22, 12),
+    Row(0x74, 7 + 441, 21, 13),
+    Row(0x74, 7 + 462, 21, 13),
+    Row(0x74, 7 + 483, 20, 14),
+    Row(0x74, 7 + 503, 20, 14),
+    Row(0x74, 7 + 523, 19, 15),
+    Row(0x74, 7 + 542, 19, 15),
+    Row(0x74, 7 + 561, 18, 16),
+    Row(0x74, 7 + 579, 18, 16),
+    Row(0x74, 7 + 597, 17, 17),
+    Row(0x74, 7 + 614, 13, 17),
+    //
+    Row(0xe7, 7 + 1, 4, 13 + 18), // adds to end of previous
+    Row(0xe7, 7 + 4, 16, 18),
+    Row(0xe7, 7 + 20, 16, 18),
+    Row(0xe7, 7 + 36, 15, 19),
+    Row(0xe7, 7 + 51, 15, 19),
+    Row(0xe7, 7 + 66, 14, 20),
+    Row(0xe7, 7 + 80, 12, 20), // too long? 14
+    Row(0xe7, 7 + 94, 13, 21),
+    Row(0xe7, 7 + 107, 13, 21),
+    Row(0xe7, 7 + 120, 12, 12), // Actual display end
+    Row(0xe7, 7 + 132, 12, 22),
+    Row(0xe7, 7 + 144, 11, 23),
+    Row(0xe7, 7 + 155, 11, 23),
+    Row(0xe7, 7 + 166, 10, 24),
+    Row(0xe7, 7 + 176, 10, 24),
+    Row(0xe7, 7 + 186, 9, 25),
+];

simulators/src/animatrix/mod.rs

@@ -1,9 +1,13 @@
 use rog_anime::AnimeType;
 
+use self::map_g635l::G635L;
+use self::map_g835l::G835L;
 use self::map_ga401::GA401;
 use self::map_ga402::GA402;
 use self::map_gu604::GU604;
 
+mod map_g635l;
+mod map_g835l;
 mod map_ga401;
 mod map_ga402;
 mod map_gu604;
@@ -39,14 +43,18 @@ pub struct AniMatrix {
 impl AniMatrix {
     pub fn new(model: AnimeType) -> Self {
         let led_shape = match model {
+            // TODO: Verify how this reacts on G635L and G835L
+            // These are all doing the same thing. Can be simplified
             AnimeType::GA401 => LedShape {
                 vertical: 2,
                 horizontal: 5,
             },
-            AnimeType::GA402 | AnimeType::Unsupported => LedShape {
-                vertical: 2,
-                horizontal: 5,
-            },
+            AnimeType::GA402 | AnimeType::G635L | AnimeType::G835L | AnimeType::Unsupported => {
+                LedShape {
+                    vertical: 2,
+                    horizontal: 5,
+                }
+            }
             AnimeType::GU604 => LedShape {
                 vertical: 2,
                 horizontal: 5,
@@ -58,6 +66,8 @@ impl AniMatrix {
             AnimeType::GA401 => GA401.to_vec(),
             AnimeType::GA402 | AnimeType::Unsupported => GA402.to_vec(),
             AnimeType::GU604 => GU604.to_vec(),
+            AnimeType::G635L => G635L.to_vec(),
+            AnimeType::G835L => G835L.to_vec(),
         };
 
         Self { rows, led_shape }

simulators/src/simulator.rs

@@ -157,6 +157,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 for (x_count, b) in dev.buffer[start..=end].iter().enumerate() {
                     canvas.set_draw_color(Color::RGB(*b, *b, *b));
 
+                    #[allow(clippy::manual_is_multiple_of)]
                     let x: i32 = w + x_count as i32 * w
                         - if (y_count + y_offset as usize) % 2 != 0 {
                             0