Fix Corsair K70 RGB PRO V2 direct lighting

The K70 RGB PRO V2 (1B1C:1BB3) was detected but never lit: it blanked into software render mode and then fell back to its onboard effect. Getting it working turned up five faults, three of which affect every Corsair V2 device rather than just this keyboard. Packet size is now read from the HID report descriptor before the first write instead of being inferred from a reply. These devices come in a 64 byte and a 1024 byte flavour, and sending a short packet to a 1024 byte endpoint stalls it until the device is power cycled, so the size has to be known up front rather than after two short queries have gone out. CORSAIR_V2_PACKET_SIZE was 1024 while pkt_sze reached 1025, so every read using pkt_sze overran its stack buffer by a byte. The command helpers now use pkt_sze against buffers of the corrected size. The lighting resource probe ran before the device was placed in software render mode, where the answer is meaningless, and treated any error as "use resource 1". Devices that answer invalid or unsupported for resource 1 want the alternate lighting resource, which takes RGB triplets; this keyboard is one of them. The probe now runs after the render mode switch and distinguishes a stale open handle from an unsupported resource. Direct lighting writes were sized from the keymap, which covers only the keys that exist. The hardware expects its full slot count and ignores a short write, so corsair_v2_device carries an optional hw_led_count and the buffer map is padded to it. Set to 193 for this keyboard. The keepalive thread wrote LEDs on its first pass, because last_update_time was left at the clock epoch and so always read as older than the update period. That raced detection on the same HID handle with no locking, which both corrupted the transaction and could abort the process. The clock is now started before the thread runs, device transactions are serialised behind a mutex, and the thread is stopped before Shutdown rather than after. Also fixes an uninitialised stack buffer sent to the device during setup, and widens the K70 RGB PRO matrix to 22 columns so the numpad period key has a position in the layout instead of being dropped. Verified on hardware: repeated colour changes apply and the device stays responsive across runs. Co-Authored-By: Claude Opus 5 <[email protected]>
Add Corsair K60 RGB PRO SE support
2026-09-21 21:08:51 -04:00 · 2026-09-21 12:01:20 -05:00 · 2026-09-21 07:20:47 -05:00 · 2026-09-21 07:20:14 +02:00 · 2026-09-20 23:20:08 -05:00 · 2026-09-21 03:26:28 +04:00
1462 changed files with 150431 additions and 62127 deletions
@@ -14,9 +14,9 @@
 #   run only if manually started to save CI minutes if      #
 #   GitLab hosted runners                                   #
 # * For commits to the CalcProgrammer1/OpenRGB repository,  #
-#   automatically run all jobs on the default branch,       #
-#   otherwise run them if the source is part of a merge     #
-#   request                                                 #
+#   automatically run all jobs on the default branch or     #
+#   tag builds, otherwise run them if the source is part    #
+#   of a merge request                                      #
 #-----------------------------------------------------------#
 .downstream_rules:
  rules:
@@ -26,7 +26,7 @@

 .upstream_rules:
  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_PIPELINE_SOURCE == "merge_request_event")'
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG || $CI_PIPELINE_SOURCE == "merge_request_event")'
    when: on_success
  - !reference [.downstream_rules, rules]

@@ -51,7 +51,7 @@ before_script:
 # Supported Devices Build Target                            #
 #-----------------------------------------------------------#
 "Supported Devices":
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-amd64
  tags:
  - linux
  - amd64
@@ -71,10 +71,10 @@ before_script:
    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------#
-# OpenRGB Common Appimage Build Steps                       #
+# OpenRGB Common AppImage Build Steps                       #
 #-----------------------------------------------------------#
 .hidden_appimage_script: &appimage_script_steps
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-${TGT_ARCH}
  tags:
  - linux
  - ${TGT_ARCH}
@@ -87,8 +87,6 @@ before_script:
    name: "${CI_PROJECT_NAME}_Linux_${TGT_NAME}_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB-${TGT_PATH}.AppImage
-    - 60-openrgb.rules
-    - README.md
    expire_in: 30 days

  rules:
@@ -100,19 +98,19 @@ before_script:
 "Linux i386 AppImage":
  variables:
    TGT_ARCH: "i386"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 i386 Build Target                    #
+# Linux (AppImage) Qt5 i386 Build Target                    #
 #-----------------------------------------------------------#
-"Linux i386 AppImage Qt6":
+"Linux i386 AppImage Qt5":
  variables:
    TGT_ARCH: "i386"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -122,7 +120,7 @@ before_script:
 "Linux amd64 AppImage":
  variables:
    TGT_ARCH: "amd64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "x86_64"
  <<: *appimage_script_steps
@@ -137,13 +135,13 @@ before_script:
  - "saas-linux-small-amd64"

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 amd64 Build Target                   #
+# Linux (AppImage) Qt5 amd64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux amd64 AppImage Qt6":
+"Linux amd64 AppImage Qt5":
  variables:
    TGT_ARCH: "amd64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "x86_64"
  <<: *appimage_script_steps

@@ -153,19 +151,19 @@ before_script:
 "Linux armhf AppImage":
  variables:
    TGT_ARCH: "armhf"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 armhf Build Target                   #
+# Linux (AppImage) Qt5 armhf Build Target                   #
 #-----------------------------------------------------------#
-"Linux armhf AppImage Qt6":
+"Linux armhf AppImage Qt5":
  variables:
    TGT_ARCH: "armhf"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -175,19 +173,19 @@ before_script:
 "Linux arm64 AppImage":
  variables:
    TGT_ARCH: "arm64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 arm64 Build Target                   #
+# Linux (AppImage) Qt5 arm64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux arm64 AppImage Qt6":
+"Linux arm64 AppImage Qt5":
  variables:
    TGT_ARCH: "arm64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -290,13 +288,16 @@ before_script:
  <<: *debian_script_steps

 #-----------------------------------------------------------#
-# Linux (.rpm, F43) 64-bit Build Target                     #
+# Linux (.rpm) Fedora 44 amd64 Build Target                 #
 #-----------------------------------------------------------#
-"Linux 64 F43 rpm":
-  image: fedora:43
+"Linux amd64 .rpm (Fedora 44)":
+  image: fedora:44
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt6-qtbase-devel git wget -y
+  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
+  - unzip hidapi-hotplug.zip
+  - dnf install ./*.rpm -y
  - rpmdev-setuptree
  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
@@ -309,7 +310,7 @@ before_script:
  - cd ${CI_PROJECT_DIR}

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_amd64_rpm_${CI_COMMIT_SHORT_SHA}"
    paths:
    - openrgb*.rpm
    expire_in: 30 days
@@ -317,6 +318,44 @@ before_script:
  rules:
    - !reference [.upstream_rules, rules]

+#-----------------------------------------------------------#
+# OpenRGB Common Flatpak Build Steps                        #
+#-----------------------------------------------------------#
+.hidden_flatpak_script: &flatpak_script_steps
+  image: ghcr.io/flathub-infra/flatpak-github-actions:kde-6.10
+  stage: build
+  tags:
+  - linux
+  - ${TGT_ARCH}
+  script:
+  - flatpak-builder --user --disable-rofiles-fuse --repo=build/repo build/flatpak-build flatpak/org.openrgb.OpenRGB.yaml
+  - flatpak build-bundle build/repo org.openrgb.OpenRGB.flatpak org.openrgb.OpenRGB
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_Flatpak_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - org.openrgb.OpenRGB.flatpak
+    expire_in: 30 days
+
+  rules:
+    - !reference [.upstream_rules, rules]
+
+#-----------------------------------------------------------#
+# Linux Flatpak amd64 Build Target                          #
+#-----------------------------------------------------------#
+"Linux amd64 Flatpak":
+  variables:
+    TGT_ARCH: "amd64"
+  <<: *flatpak_script_steps
+
+#-----------------------------------------------------------#
+# Linux Flatpak arm64 Build Target                          #
+#-----------------------------------------------------------#
+"Linux arm64 Flatpak":
+  variables:
+    TGT_ARCH: "arm64"
+  <<: *flatpak_script_steps
+
 #-----------------------------------------------------------#
 # Debian i386 Bookworm test                                 #
 #-----------------------------------------------------------#
@@ -324,10 +363,14 @@ before_script:
  image: i386/debian:bookworm
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+i386+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux i386 .deb (Debian Bookworm)"
  needs:
@@ -342,10 +385,14 @@ before_script:
  image: amd64/debian:bookworm
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
@@ -360,10 +407,14 @@ before_script:
  image: ubuntu:noble
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
@@ -372,19 +423,23 @@ before_script:
  - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------#
-# Fedora 64 v43 test                                        #
+# Fedora amd64 44 test                                      #
 #-----------------------------------------------------------#
-"Fedora 64 v43":
-  image: fedora:43
+"Fedora 64 44":
+  image: fedora:44
  stage: test
  script:
+  - dnf install unzip wget -y
+  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
+  - unzip hidapi-hotplug.zip
+  - dnf install ./*.rpm -y
  - dnf5 -y install ./openrgb*64.rpm
  - openrgb --version
  - dnf5 -y remove openrgb
  dependencies:
-  - "Linux 64 F43 rpm"
+  - "Linux amd64 .rpm (Fedora 44)"
  needs:
-  - "Linux 64 F43 rpm"
+  - "Linux amd64 .rpm (Fedora 44)"
  rules:
  - !reference [.upstream_rules, rules]

@@ -397,7 +452,7 @@ before_script:
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 32
+  - scripts\build-windows.bat 6.8.3 2022 32
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -410,17 +465,17 @@ before_script:
    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------#
-# Windows (32-bit) Qt6 Build Target                         #
+# Windows (32-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 32 Qt6":
+"Windows 32 Qt5":
  extends:
  - .shared_windows_runners
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 32
+  - scripts\build-windows.bat 5.15.0 2019 32
  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_32_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_32_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 32-bit'
    exclude:
@@ -439,7 +494,7 @@ before_script:
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 64
+  - scripts\build-windows.bat 6.8.3 2022 64
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -470,17 +525,17 @@ before_script:
  - "saas-windows-medium-amd64"

 #-----------------------------------------------------------#
-# Windows (64-bit) Qt6 Build Target                         #
+# Windows (64-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 64 Qt6 Base":
+"Windows 64 Qt5 Base":
  extends:
  - .shared_windows_runners
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 64
+  - scripts\build-windows.bat 5.15.0 2019 64
  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_64_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 64-bit'
    exclude:
@@ -491,13 +546,14 @@ before_script:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
      when: never

-"Windows 64 Qt6":
-  extends: "Windows 64 Qt6 Base"
+
+"Windows 64 Qt5":
+  extends: "Windows 64 Qt5 Base"
  rules:
  - !reference [.upstream_rules, rules]

-"Windows 64 Qt6 (Downstream)":
-  extends: "Windows 64 Qt6 Base"
+"Windows 64 Qt5 (Downstream)":
+  extends: "Windows 64 Qt5 Base"
  before_script:
    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
    - cd OpenRGB-Qt-Packages
@@ -516,10 +572,7 @@ before_script:
  - macos
  stage: build
  script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
-  - make -j16
-  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 arm

  artifacts:
    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -530,18 +583,15 @@ before_script:
  rules:
  - !reference [.upstream_rules, rules]

-"MacOS ARM64 Qt6":
+"MacOS ARM64 Qt5":
  tags:
  - macos
  stage: build
  script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - qmake OpenRGB.pro
-  - make -j16
-  - macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 arm

  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB.app
    expire_in: 30 days
@@ -554,10 +604,7 @@ before_script:
  - macos
  stage: build
  script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 intel

  artifacts:
    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -568,18 +615,15 @@ before_script:
  rules:
  - !reference [.upstream_rules, rules]

-"MacOS Intel Qt6":
+"MacOS Intel Qt5":
  tags:
  - macos
  stage: build
  script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 intel

  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB.app
    expire_in: 30 days
@@ -22,13 +22,12 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDominatorPlatinumController/
+/Controllers/CorsairDRAMController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
-/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/
@@ -0,0 +1,158 @@
+/*---------------------------------------------------------*\
+| AutoStart-Flatpak.cpp                                     |
+|                                                           |
+|   Autostart implementation for Linux via Flatpak Portal   |
+|                                                           |
+|   Adam Honse <[email protected]>      04 Sep 2026 |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "AutoStart-Flatpak.h"
+#include <gio/gio.h>
+
+AutoStart::AutoStart(std::string name)
+{
+    InitAutoStart(name);
+}
+
+void AutoStart::InitAutoStart(std::string name)
+{
+    app_name = name;
+}
+
+bool AutoStart::CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info)
+{
+    GError*             error           = nullptr;
+    GDBusConnection*    connection      = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
+
+    if(!connection)
+    {
+        if(error)
+        {
+            g_error_free(error);
+        }
+
+        return false;
+    }
+
+    /*-----------------------------------------------------*\
+    | FreeDesktop Background Portal parameters              |
+    \*-----------------------------------------------------*/
+    const char*         bus_name        = "org.freedesktop.portal.Desktop";
+    const char*         object_path     = "/org/freedesktop/portal/desktop";
+    const char*         interface_name  = "org.freedesktop.portal.Background";
+    const char*         method_name     = "RequestBackground";
+
+    /*-----------------------------------------------------*\
+    | Build the options dictionary (vardict) required by    |
+    | the Portal                                            |
+    \*-----------------------------------------------------*/
+    GVariantBuilder     options_builder;
+    g_variant_builder_init(&options_builder, G_VARIANT_TYPE_VARDICT);
+
+    /*-----------------------------------------------------*\
+    | Reason shown to the user in the system settings /     |
+    | permission prompt                                     |
+    \*-----------------------------------------------------*/
+    std::string         reason_str      = "Allow " + app_name + " to launch automatically at startup.";
+    g_variant_builder_add(&options_builder, "{sv}", "reason", g_variant_new_string(reason_str.c_str()));
+
+    /*-----------------------------------------------------*\
+    | Toggle the autostart feature state                    |
+    \*-----------------------------------------------------*/
+    g_variant_builder_add(&options_builder, "{sv}", "autostart", g_variant_new_boolean(enable));
+
+    if(enable)
+    {
+        /*-------------------------------------------------*\
+        | Pass command-line arguments to the background     |
+        | request                                           |
+        \*-------------------------------------------------*/
+        GVariantBuilder arg_builder;
+        g_variant_builder_init(&arg_builder, G_VARIANT_TYPE("as"));
+
+        /*-------------------------------------------------*\
+        | Add the primary executable path inside the        |
+        | Flatpak sandbox                                   |
+        \*-------------------------------------------------*/
+        g_variant_builder_add(&arg_builder, "s", GetExePath().c_str());
+
+        /*-------------------------------------------------*\
+        | Append any additional arguments provided by       |
+        | OpenRGB's autostart config                        |
+        \*-------------------------------------------------*/
+        if(!autostart_info.args.empty())
+        {
+            g_variant_builder_add(&arg_builder, "s", autostart_info.args.c_str());
+        }
+
+        GVariant*   commandline_args    = g_variant_builder_end(&arg_builder);
+        g_variant_builder_add(&options_builder, "{sv}", "commandline", commandline_args);
+    }
+
+    /*-----------------------------------------------------*\
+    | An empty string window handle is used since this is a |
+    | background configuration request                      |
+    \*-----------------------------------------------------*/
+    const char*     parent_window       = "";
+    GVariant*       options             = g_variant_builder_end(&options_builder);
+
+    /*-----------------------------------------------------*\
+    | Bundle parameters: (s a{sv}) -> Parent window handle, |
+    | Options dictionary                                    |
+    \*-----------------------------------------------------*/
+    GVariant*       parameters          = g_variant_new("(s@a{sv})", parent_window, options);
+    GVariant*       reply;
+
+    reply = g_dbus_connection_call_sync(connection, bus_name, object_path, interface_name, method_name, parameters, G_VARIANT_TYPE("(o)"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &error);
+
+    g_object_unref(connection);
+
+    if(error)
+    {
+        g_error_free(error);
+        return false;
+    }
+
+    if(reply)
+    {
+        g_variant_unref(reply);
+        return true;
+    }
+
+    return false;
+}
+
+bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
+{
+    return CallBackgroundPortal(true, autostart_info);
+}
+
+bool AutoStart::DisableAutoStart()
+{
+    return CallBackgroundPortal(false);
+}
+
+bool AutoStart::IsAutoStartEnabled()
+{
+    /*-----------------------------------------------------*\
+    | The FreeDesktop Background Portal does not provide a  |
+    | stateless status getter.  Sandbox permissions are     |
+    | securely managed and persisted internally by the      |
+    | host's portal service.  To implement a true state     |
+    | track here, OpenRGB will need to manage a local       |
+    | boolean flag inside its own configuration files (e.g. |
+    | OpenRGB.json).                                        |
+    \*-----------------------------------------------------*/
+    return false;
+}
+
+std::string AutoStart::GetExePath()
+{
+    /*-----------------------------------------------------*\
+    | Flatpak applications always run from this specific    |
+    | exported path hierarchy                               |
+    \*-----------------------------------------------------*/
+    return "/app/bin/openrgb";
+}
@@ -0,0 +1,31 @@
+/*---------------------------------------------------------*\
+| AutoStart-Flatpak.h                                       |
+|                                                           |
+|   Autostart implementation for Linux via Flatpak Portal   |
+|                                                           |
+|   Adam Honse <[email protected]>      04 Sep 2026 |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "AutoStart.h"
+
+class AutoStart : public AutoStartInterface
+{
+public:
+    AutoStart(std::string name);
+
+    bool        DisableAutoStart();
+    bool        EnableAutoStart(AutoStartInfo autostart_info);
+    bool        IsAutoStartEnabled();
+    std::string GetExePath();
+
+private:
+    void        InitAutoStart(std::string name);
+    bool        CallBackgroundPortal(bool enable, const AutoStartInfo& autostart_info = {});
+    
+    std::string app_name;
+};
@@ -119,6 +119,21 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
+    /*-----------------------------------------------------*\
+    | When running from an AppImage, the AppImage runtime   |
+    | sets the APPIMAGE environment variable to the path of |
+    | the AppImage file itself.  /proc/self/exe would       |
+    | instead point at the extracted binary inside the      |
+    | temporary squashfs mount, which disappears once the   |
+    | AppImage is closed, so prefer APPIMAGE when it is set |
+    \*-----------------------------------------------------*/
+    const char* appimage_path = getenv("APPIMAGE");
+
+    if(appimage_path != NULL)
+    {
+        return(std::string(appimage_path));
+    }
+
    /*-----------------------------------------------------*\
    | Create the OpenRGB executable path                    |
    \*-----------------------------------------------------*/
@@ -134,6 +149,64 @@ std::string AutoStart::GetExePath()
 | Private Methods                                           |
 \*---------------------------------------------------------*/

+/*---------------------------------------------------------*\
+| Escape a single argument for use in a .desktop Exec=      |
+| field, per the Desktop Entry Specification.               |
+|                                                           |
+| Reserved characters must be escaped by wrapping the whole |
+| argument in double quotes and backslash-escaping the      |
+| quote/backquote/backslash/dollar characters, and any      |
+| literal '%' must be doubled to '%%'.                      |
+\*---------------------------------------------------------*/
+static std::string DesktopExecEscape(const std::string& arg)
+{
+    static const std::string reserved = " \t\n\"'`\\><~|&;$*?#()%";
+
+    bool needs_quotes = false;
+    for(char c : arg)
+    {
+        if(reserved.find(c) != std::string::npos)
+        {
+            needs_quotes = true;
+            break;
+        }
+    }
+
+    std::string escaped;
+
+    if(needs_quotes)
+    {
+        escaped += '"';
+    }
+
+    for(char c : arg)
+    {
+        switch(c)
+        {
+            case '"':
+            case '`':
+            case '\\':
+            case '$':
+                escaped += '\\';
+                escaped += c;
+                break;
+            case '%':
+                escaped += "%%";
+                break;
+            default:
+                escaped += c;
+                break;
+        }
+    }
+
+    if(needs_quotes)
+    {
+        escaped += '"';
+    }
+
+    return(escaped);
+}
+
 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
    /*-----------------------------------------------------*\
@@ -154,11 +227,17 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
    /*-----------------------------------------------------*\
    | Add the executable path and arguments                 |
    \*-----------------------------------------------------*/
-    fileContents << "Exec="              << autostart_info.path;
+    fileContents << "Exec="              << DesktopExecEscape(autostart_info.path);

    if (autostart_info.args != "")
    {
-        fileContents << " " << autostart_info.args;
+        std::istringstream arg_parser(autostart_info.args);
+        std::string arg;
+
+        while(arg_parser >> arg)
+        {
+            fileContents << " " << DesktopExecEscape(arg);
+        }
    }

    fileContents << std::endl;
@@ -137,6 +137,43 @@ std::string AutoStart::GetExePath()
 | Private Methods                                           |
 \*---------------------------------------------------------*/

+/*---------------------------------------------------------*\
+| Escape a string for embedding inside an XML element       |
+| (used by the .plist generator) to avoid producing         |
+| malformed property list files.                            |
+\*---------------------------------------------------------*/
+static std::string XmlEscape(const std::string& input)
+{
+    std::string escaped;
+
+    for(char c : input)
+    {
+        switch(c)
+        {
+            case '&':
+                escaped += "&amp;";
+                break;
+            case '<':
+                escaped += "&lt;";
+                break;
+            case '>':
+                escaped += "&gt;";
+                break;
+            case '"':
+                escaped += "&quot;";
+                break;
+            case '\'':
+                escaped += "&apos;";
+                break;
+            default:
+                escaped += c;
+                break;
+        }
+    }
+
+    return(escaped);
+}
+
 std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 {
    /*-----------------------------------------------------*\
@@ -153,7 +190,8 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
    fileContents << "    <string>org.openrgb</string>"                                                                              << std::endl;
    fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
    fileContents << "    <array>"                                                                                                   << std::endl;
-    fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
+    fileContents << "        <string>" << XmlEscape(autostart_info.path) << "</string>"
+                 << std::endl;

    if(autostart_info.args != "")
    {
@@ -162,7 +200,8 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)

        while(arg_parser >> arg)
        {
-            fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
+            fileContents << "        <string>" << XmlEscape(arg) << "</string>"
+                         << std::endl;
        }
    }

@@ -12,6 +12,7 @@
 #include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
+#include "StringUtils.h"
 #include "filesystem.h"
 #include "windows.h"

@@ -71,11 +72,11 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
        HRESULT         result;
        IShellLinkW*    shellLink                   = NULL;

-        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
-        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
-        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
-        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
-        std::wstring    iconw                       = utf8_decode(autostart_info.path);
+        std::wstring    exepathw                    = StringUtils::string_to_wstring(autostart_info.path);
+        std::wstring    argumentsw                  = StringUtils::string_to_wstring(autostart_info.args);
+        std::wstring    startupfilepathw            = StringUtils::string_to_wstring(autostart_file);
+        std::wstring    descriptionw                = StringUtils::string_to_wstring(autostart_info.desc);
+        std::wstring    iconw                       = StringUtils::string_to_wstring(autostart_info.path);

        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);

@@ -150,11 +151,16 @@ std::string AutoStart::GetExePath()
    /*-----------------------------------------------------*\
    | Create the OpenRGB executable path                    |
    \*-----------------------------------------------------*/
-    char exepath[MAX_PATH] = "";
+    wchar_t exepath[MAX_PATH] = L"";

-    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
+    DWORD count = GetModuleFileNameW(NULL, exepath, MAX_PATH);

-    return(std::string(exepath, (count > 0) ? count : 0));
+    if(count == 0)
+    {
+        return(std::string());
+    }
+
+    return(StringUtils::wstring_to_string(std::wstring(exepath, count)));
 }

 /*---------------------------------------------------------*\
@@ -164,43 +170,39 @@ std::string AutoStart::GetExePath()

 void AutoStart::InitAutoStart(std::string name)
 {
-    char startMenuPath[MAX_PATH];
+    wchar_t startMenuPath[MAX_PATH];

    autostart_name = name;

    /*-----------------------------------------------------*\
    | Get startup applications path                         |
    \*-----------------------------------------------------*/
-    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
+    HRESULT result = SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);

    if(SUCCEEDED(result))
    {
-        autostart_file = std::string(startMenuPath);
+        std::string autostart_dir = StringUtils::wstring_to_string(startMenuPath);
+        autostart_dir += "\\Startup\\";

-        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
+        /*-------------------------------------------------*\
+        | Create the directory if it doesn't exist          |
+        \*-------------------------------------------------*/
+        std::error_code ec;
+
+        bool success = true;
+
+        if(!filesystem::exists(autostart_dir))
+        {
+            success = filesystem::create_directories(autostart_dir, ec);
+        }
+
+        if(success)
+        {
+            autostart_file = autostart_dir + autostart_name + ".lnk";
+        }
    }
    else
    {
        autostart_file.clear();
    }
 }
-
-/*---------------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String           |
-| (from wmi.cpp)                                            |
-\*---------------------------------------------------------*/
-std::wstring AutoStart::utf8_decode(const std::string& str)
-{
-    if(str.empty())
-    {
-        return std::wstring();
-    }
-
-    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
-
-    std::wstring wstrTo(size_needed, 0);
-
-    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-
-    return(wstrTo);
-}
@@ -24,5 +24,4 @@ public:

 private:
    void            InitAutoStart(std::string name);
-    std::wstring    utf8_decode(const std::string& str);
 };
@@ -40,9 +40,15 @@ protected:
 #include "AutoStart-Windows.h"
 #endif

+#ifdef FLATPAK_BUILD
+#include "AutoStart-Flatpak.h"
+#endif
+
 #ifdef __linux__
+#ifndef FLATPAK_BUILD
 #include "AutoStart-Linux.h"
 #endif
+#endif

 #ifdef __APPLE__
 #include "AutoStart-MacOS.h"
@@ -69,3 +69,7 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil

 Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
 In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
+
+## AI Guidelines
+
+OpenRGB is an open source project developed by humans for humans.  As a general rule, AI generated submissions are not permitted.  The licensing behind AI generated code is problematic.  If you choose to use AI for assistance in your development process, we can't stop you, but do not credit the AI in commits (no AI authorship/co-authorship).  Ultimately, you as a human developer are responsible for the code you submit and it is expected that any code you submit you fully understand and have manually vetted before submission.  Merge requests that appear to be straight from an AI output, commits with AI tool authorship or co-authorship tags, or otherwise AI generated submissions are subject to closure.
@@ -1,61 +0,0 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
-#include <hidapi.h>
-#include "Detector.h"
-
-/*-----------------------------------------------------*\
-| A4 Tech specific includes                             |
-\*-----------------------------------------------------*/
-#include "RGBController_BloodyMouse.h"
-#include "RGBController_BloodyB820R.h"
-
-/*-----------------------------------------------------*\
-| A4 Tech USB vendor ID                                 |
-\*-----------------------------------------------------*/
-#define A4_TECH_VID                                 0x09DA
-
-void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id, name);
-        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
-        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -0,0 +1,40 @@
+/*---------------------------------------------------------*\
+| BloodyB820RControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody B820R Devices                       |
+|                                                           |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyB820RController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyB820R.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody B820R", DetectBloodyB820R, A4_TECH_VID, BLOODY_B820R_PID, 2, 0xFF52, 0x0210);
@@ -173,6 +173,8 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont

 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -187,11 +189,7 @@ void RGBController_BloodyB820R::SetupZones()
    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = 6;
-    KB_zone.matrix_map->width   = 21;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    KB_zone.matrix_map.Set(6, 21, (unsigned int *)&matrix_map);
    zones.push_back(KB_zone);

    /*-------------------------------------------------*\
@@ -214,20 +212,12 @@ void RGBController_BloodyB820R::SetupZones()
    SetupColors();
 }

-void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-
 void RGBController_BloodyB820R::DeviceUpdateLEDs()
 {
    controller->SetLEDDirect(colors);
 }

-void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
+void RGBController_BloodyB820R::DeviceUpdateZoneLEDs(int zone)
 {
    std::vector<RGBColor> colour;

@@ -239,7 +229,7 @@ void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
    controller->SetLEDDirect(colour);
 }

-void RGBController_BloodyB820R::UpdateSingleLED(int led)
+void RGBController_BloodyB820R::DeviceUpdateSingleLED(int led)
 {
    std::vector<RGBColor> colour;
    colour.push_back(colors[led]);
@@ -22,11 +22,10 @@ public:
    ~RGBController_BloodyB820R();

    void    SetupZones();
-    void    ResizeZone(int zone, int new_size);

    void    DeviceUpdateLEDs();
-    void    UpdateZoneLEDs(int zone);
-    void    UpdateSingleLED(int led);
+    void    DeviceUpdateZoneLEDs(int zone);
+    void    DeviceUpdateSingleLED(int led);

    void    DeviceUpdateMode();

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| BloodyMouseControllerDetect.cpp                           |
+|                                                           |
+|   Detector for Bloody Mouse Devices                       |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyMouseController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyMouse.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectBloodyMouseControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
+        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W60_PRO_PID, 2,  0xFF33, 0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W70_MAX_PID, 2,  0xFF33, 0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_MAX_PID, 2,  0xFF33, 0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_W90_PRO_PID, 2,  0xFF33, 0x054D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectBloodyMouseControllers,  A4_TECH_VID,    BLOODY_MP_50RS_PID, 2,  0xFFF2, 0x6009);
@@ -89,6 +89,8 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont

 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -134,7 +136,6 @@ void RGBController_BloodyMouse::SetupZones()
        new_zone.leds_max       = new_zone.leds_min;
        new_zone.leds_count     = new_zone.leds_min;
        new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
-        new_zone.matrix_map     = NULL;
        zones.push_back(new_zone);

        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
@@ -160,13 +161,6 @@ void RGBController_BloodyMouse::SetupZones()
    SetupColors();
 }

-void RGBController_BloodyMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_BloodyMouse::DeviceUpdateLEDs()
 {
    std::vector<RGBColor> colour;
@@ -179,12 +173,12 @@ void RGBController_BloodyMouse::DeviceUpdateLEDs()
    controller->SetLedsDirect(colour);
 }

-void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
+void RGBController_BloodyMouse::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -30,11 +30,10 @@ public:
    ~RGBController_BloodyMouse();

    void                    SetupZones();
-    void                    ResizeZone(int zone, int new_size);

    void                    DeviceUpdateLEDs();
-    void                    UpdateZoneLEDs(int zone);
-    void                    UpdateSingleLED(int led);
+    void                    DeviceUpdateZoneLEDs(int zone);
+    void                    DeviceUpdateSingleLED(int led);

    void                    DeviceUpdateMode();

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
 #include "AMBXController.h"
+#include "DetectionManager.h"
 #include "RGBController.h"
 #include "RGBController_AMBX.h"

@@ -18,32 +18,18 @@
 #include <libusb.h>
 #endif

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMBXControllers                                                                  *
-*                                                                                          *
-*       Detect Philips amBX Gaming devices                                                 *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMBXControllers()
+DetectedControllers DetectAMBXControllers()
 {
+    DetectedControllers detected_controllers;
    libusb_context*     ctx = NULL;

-    if(libusb_init(&ctx) < 0)
+    if(libusb_init(&ctx) >= 0)
    {
-        return;
-    }
-
        libusb_device** devs;
        ssize_t num_devs = libusb_get_device_list(ctx, &devs);

-    if(num_devs <= 0)
+        if(num_devs > 0)
        {
-        libusb_exit(ctx);
-        return;
-    }
-
            for(ssize_t i = 0; i < num_devs; i++)
            {
                libusb_device* dev = devs[i];
@@ -67,7 +53,7 @@ void DetectAMBXControllers()
                    if(controller->IsInitialized())
                    {
                        RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                        detected_controllers.push_back(rgb_controller);
                    }
                    else
                    {
@@ -79,5 +65,13 @@ void DetectAMBXControllers()
            libusb_free_device_list(devs, 1);
            libusb_exit(ctx);
        }
+        else
+        {
+            libusb_exit(ctx);
+        }
+    }
+
+    return(detected_controllers);
+}

 REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);
@@ -44,6 +44,8 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)

 RGBController_AMBX::~RGBController_AMBX()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -56,7 +58,6 @@ void RGBController_AMBX::SetupZones()
    side_lights_zone.leds_min   = 2;
    side_lights_zone.leds_max   = 2;
    side_lights_zone.leds_count = 2;
-    side_lights_zone.matrix_map = NULL;
    zones.push_back(side_lights_zone);

    zone wallwasher_zone;
@@ -65,7 +66,6 @@ void RGBController_AMBX::SetupZones()
    wallwasher_zone.leds_min   = 3;
    wallwasher_zone.leds_max   = 3;
    wallwasher_zone.leds_count = 3;
-    wallwasher_zone.matrix_map = NULL;
    zones.push_back(wallwasher_zone);

    // Set up LEDs
@@ -97,11 +97,6 @@ void RGBController_AMBX::SetupZones()
    SetupColors();
 }

-void RGBController_AMBX::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    // This device does not support resizing zones
-}
-
 void RGBController_AMBX::DeviceUpdateLEDs()
 {
    if(!controller->IsInitialized())
@@ -121,7 +116,7 @@ void RGBController_AMBX::DeviceUpdateLEDs()
    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
 }

-void RGBController_AMBX::UpdateZoneLEDs(int zone)
+void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
 {
    if(!controller->IsInitialized())
    {
@@ -156,7 +151,7 @@ void RGBController_AMBX::UpdateZoneLEDs(int zone)
    controller->SetLEDColors(led_values, led_colors, zone_size);
 }

-void RGBController_AMBX::UpdateSingleLED(int led)
+void RGBController_AMBX::DeviceUpdateSingleLED(int led)
 {
    if(!controller->IsInitialized())
    {
@@ -19,11 +19,10 @@ public:
    ~RGBController_AMBX();

    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -10,8 +10,8 @@
 \*---------------------------------------------------------*/

 #include <hidapi.h>
-#include "Detector.h"
 #include "AMDWraithPrismController.h"
+#include "DetectionManager.h"
 #include "RGBController_AMDWraithPrism.h"

 /*---------------------------------------------------------*\
@@ -24,25 +24,22 @@
 \*---------------------------------------------------------*/
 #define AMD_WRAITH_PRISM_PID                        0x0051

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMDWraithPrismControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);
@@ -132,6 +132,8 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl

 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -154,7 +156,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    logo_zone.leds_min      = 1;
    logo_zone.leds_max      = 1;
    logo_zone.leds_count    = 1;
-    logo_zone.matrix_map    = NULL;
    zones.push_back(logo_zone);

    zone fan_zone;
@@ -163,7 +164,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    fan_zone.leds_min       = 1;
    fan_zone.leds_max       = 1;
    fan_zone.leds_count     = 1;
-    fan_zone.matrix_map     = NULL;
    zones.push_back(fan_zone);

    zone ring_zone;
@@ -172,7 +172,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    ring_zone.leds_min      = 15;
    ring_zone.leds_max      = 15;
    ring_zone.leds_count    = 15;
-    ring_zone.matrix_map    = NULL;
    zones.push_back(ring_zone);

    /*-----------------------------------------------------*\
@@ -205,13 +204,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    SetupColors();
 }

-void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*-----------------------------------------------------*\
-    | This device does not support resizing zones           |
-    \*-----------------------------------------------------*/
-}
-
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
@@ -271,12 +263,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
    }
 }

-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
+void RGBController_AMDWraithPrism::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -31,7 +31,7 @@ AOCKeyboardController::~AOCKeyboardController()

 std::string AOCKeyboardController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCKeyboardController::GetDeviceName()
@@ -9,36 +9,33 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AOCKeyboardController.h"
 #include "RGBController_AOCKeyboard.h"

-/*-----------------------------------------------------*\
+/*---------------------------------------------------------*\
 | AOC Keyboard IDs                                          |
-\*-----------------------------------------------------*/
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
 #define AOC_GK500_PID_2                             0x1229

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
@@ -257,35 +257,25 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont

 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
+    Shutdown();
+
    delete controller;
 }

 void RGBController_AOCKeyboard::SetupZones()
 {
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
+
    /*---------------------------------------------------------*\
    | Create the keyboard zone usiung Keyboard Layout Manager   |
    \*---------------------------------------------------------*/
    zone new_zone;
    new_zone.name                   = ZONE_EN_KEYBOARD;
    new_zone.type                   = ZONE_TYPE_MATRIX;
-
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
-
-    matrix_map_type * new_map   = new matrix_map_type;
-    new_zone.matrix_map         = new_map;
-    new_zone.matrix_map->height = new_kb.GetRowCount();
-    new_zone.matrix_map->width  = new_kb.GetColumnCount();
-
-    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
    new_zone.leds_count             = new_kb.GetKeyCount();
    new_zone.leds_min               = new_zone.leds_count;
    new_zone.leds_max               = new_zone.leds_count;
-
-    /*---------------------------------------------------------*\
-    | Matrix map still uses declared zone rows and columns      |
-    |   as the packet structure depends on the matrix map       |
-    \*---------------------------------------------------------*/
-    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+    new_zone.matrix_map             = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);

    /*---------------------------------------------------------*\
    | Create LEDs for the Matrix zone                           |
@@ -305,13 +295,6 @@ void RGBController_AOCKeyboard::SetupZones()
    SetupColors();
 }

-void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 {
    if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
@@ -331,12 +314,12 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
    }
 }

-void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AOCKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -27,7 +27,7 @@ AOCMouseController::~AOCMouseController()

 std::string AOCMouseController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCMouseController::GetDeviceName()
@@ -9,35 +9,32 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AOCMouseController.h"
 #include "RGBController_AOCMouse.h"

-/*-----------------------------------------------------*\
+/*---------------------------------------------------------*\
 | AOC Mouse IDs                                             |
-\*-----------------------------------------------------*/
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMouseControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mouse controller exists there.              *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);
@@ -123,6 +123,8 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt

 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -134,7 +136,6 @@ void RGBController_AOCMouse::SetupZones()
    logo_zone.leds_min              = 1;
    logo_zone.leds_max              = 1;
    logo_zone.leds_count            = 1;
-    logo_zone.matrix_map            = NULL;
    zones.push_back(logo_zone);

    led logo_led;
@@ -147,7 +148,6 @@ void RGBController_AOCMouse::SetupZones()
    scroll_wheel_zone.leds_min      = 1;
    scroll_wheel_zone.leds_max      = 1;
    scroll_wheel_zone.leds_count    = 1;
-    scroll_wheel_zone.matrix_map    = NULL;
    zones.push_back(scroll_wheel_zone);

    led scroll_wheel_led;
@@ -157,24 +157,17 @@ void RGBController_AOCMouse::SetupZones()
    SetupColors();
 }

-void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCMouse::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMouse::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -27,7 +27,7 @@ AOCMousematController::~AOCMousematController()

 std::string AOCMousematController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCMousematController::GetDeviceName()
@@ -9,35 +9,32 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AOCMousematController.h"
 #include "RGBController_AOCMousemat.h"

-/*-----------------------------------------------------*\
+/*---------------------------------------------------------*\
 | AOC Mousemat IDs                                          |
-\*-----------------------------------------------------*/
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_AMM700_PID                              0x1162

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMousematControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);
@@ -113,6 +113,8 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont

 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -124,7 +126,6 @@ void RGBController_AOCMousemat::SetupZones()
    mousemat_zone.leds_min      = 1;
    mousemat_zone.leds_max      = 1;
    mousemat_zone.leds_count    = 1;
-    mousemat_zone.matrix_map    = NULL;
    zones.push_back(mousemat_zone);

    led mousemat_led;
@@ -134,24 +135,17 @@ void RGBController_AOCMousemat::SetupZones()
    SetupColors();
 }

-void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCMousemat::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMousemat::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -11,12 +11,12 @@
 \*---------------------------------------------------------*/

 #include <cstring>
-#include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dmiinfo.h"
+#include "ResourceManager.h"
+#include "RGBController.h"
+#include "SettingsManager.h"
+#include "StringUtils.h"

 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
    WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }

-void PolychromeUSBController::ResizeZone(int zone, int new_size)
+void PolychromeUSBController::SetZoneSize(int zone, int new_size)
 {
    unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];

@@ -135,7 +135,7 @@ public:
                                                    unsigned int    configsize
                                                    );

-    void                                        ResizeZone(int zone, int new_size);
+    void                                        SetZoneSize(int zone, int new_size);
    void                                        SetRGSwap(bool reset);

 protected:
@@ -11,8 +11,8 @@
 \*---------------------------------------------------------*/

 #include <hidapi.h>
-#include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
+#include "DetectionManager.h"
 #include "RGBController_ASRockPolychromeUSB.h"

 /*---------------------------------------------------------*\
@@ -26,16 +26,22 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6

-void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
        RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
@@ -185,8 +185,25 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
    SetupZones();
 }

+RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_PolychromeUSB::SetupZones()
 {
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
    /*-------------------------------------------------*\
    | Clear any existing color/LED configuration        |
    \*-------------------------------------------------*/
@@ -197,40 +214,65 @@ void RGBController_PolychromeUSB::SetupZones()
    /*-------------------------------------------------*\
    | Set zones and leds                                |
    \*-------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
    {
        PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];

-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
        if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
        {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
            zones[channel_idx].leds_min                 = 0;
            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
+
+            if(first_run)
+            {
+                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+            {
+                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
                zones[channel_idx].leds_count           = device_info.num_leds;
            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+            {
+                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+            {
+                zones[channel_idx].matrix_map.width     = 0;
+                zones[channel_idx].matrix_map.height    = 0;
+                zones[channel_idx].matrix_map.map.resize(0);
+            }
+        }
        else if(device_info.device_type==PolychromeDeviceType::FIXED)
        {
            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
            zones[channel_idx].leds_min                 = device_info.num_leds;
            zones[channel_idx].leds_max                 = device_info.num_leds;
            zones[channel_idx].leds_count               = device_info.num_leds;
        }

-
        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
        {
            led new_led;
            new_led.name = zones[channel_idx].name;
            new_led.name.append(", LED ");
            new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = channel_idx;
+            new_led.value = (unsigned int)channel_idx;

            leds.push_back(new_led);
        }
-
-        zones[channel_idx].matrix_map = NULL;
    }

    SetupColors();
@@ -273,10 +315,14 @@ void RGBController_PolychromeUSB::SetupZones()
     }
 }

-void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
+void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
 {
-    zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+    if((size_t)zone_idx < zones.size())
+    {
+        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
+
+        SetupZones();
+    }
 }

 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -288,6 +334,11 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
    }
    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
+        if(zones[zone_idx].leds_count == 0)
+        {
+            continue;
+        }
+
        unsigned char set_mode = zones_info[zone_idx].mode;

        if(set_mode>modes.size())
@@ -299,8 +350,13 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
    }
 }

-void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
+void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
+    if(zones[zone].leds_count == 0)
+    {
+        return;
+    }
+
    unsigned char set_mode=zones_info[zone].mode;

    if(set_mode > modes.size())
@@ -308,20 +364,25 @@ void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
        set_mode = active_mode;
    }

-    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+    controller->WriteZone((unsigned char)zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }

-void RGBController_PolychromeUSB::UpdateSingleLED(int led)
+void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
 {
    unsigned int  channel  = leds[led].value;
    unsigned char set_mode = zones_info[channel].mode;

+    if(zones[channel].leds_count == 0)
+    {
+        return;
+    }
+
    if(set_mode > modes.size())
    {
        set_mode = active_mode;
    }

-    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+    controller->WriteZone((unsigned char)channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
 }

 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
@@ -19,14 +19,15 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
    RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
+    ~RGBController_PolychromeUSB();

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -36,7 +36,7 @@ ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()

 std::string ASRockASRRGBSMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
    char addr[5];
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
@@ -113,6 +113,8 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB

 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -135,7 +137,6 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
    new_zone->leds_min      = 1;
    new_zone->leds_max      = 1;
    new_zone->leds_count    = 1;
-    new_zone->matrix_map    = NULL;

    /*---------------------------------------------------------*\
    | Push new zone to zones vector                             |
@@ -160,27 +161,20 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
    SetupColors();
 }

-void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
    for(unsigned int led = 0; led < colors.size(); led++)
    {
-        UpdateSingleLED(led);
+        DeviceUpdateSingleLED(led);
    }
 }

-void RGBController_ASRockASRRGBSMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
 {
    unsigned char red = RGBGetRValue(colors[led]);
    unsigned char grn = RGBGetGValue(colors[led]);
@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusController.cpp                              |
+|                                                           |
+|   Driver for ASRock GPU RGB controllers                   |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "ASRockGPUSMBusController.h"
+#include "LogManager.h"
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <thread>
+
+using namespace std::chrono_literals;
+
+ASRockGPUSMBusController::ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name)
+{
+    this->bus          = bus;
+    this->dev          = dev;
+    this->device_name  = name;
+    this->num_channels = 0;
+
+    memset(enabled_channels, 0, sizeof(enabled_channels));
+    memset(led_counts, 0, sizeof(led_counts));
+}
+
+ASRockGPUSMBusController::~ASRockGPUSMBusController()
+{
+}
+
+std::string ASRockGPUSMBusController::GetDeviceLocation()
+{
+    std::string return_string(bus->info.device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string ASRockGPUSMBusController::GetDeviceName()
+{
+    return(device_name);
+}
+
+bool ASRockGPUSMBusController::WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len)
+{
+    /*-----------------------------------------------------*\
+    | SignalRGB packet format                              |
+    | [command, 0, subcommand, data...]                    |
+    | Uses pure I2C rather than SMBus                      |
+    \*-----------------------------------------------------*/
+    uint8_t packet[12];
+    memset(packet, 0, sizeof(packet));
+
+    packet[0] = command;
+    packet[1] = 0x00;
+    packet[2] = subcommand;
+
+    if(data != nullptr && len > 0)
+    {
+        uint8_t copy_len = (len > 9) ? 9 : len;
+        memcpy(&packet[3], data, copy_len);
+    }
+
+    int size   = 12;
+    int result = bus->i2c_write_block(dev, size, packet);
+
+    if(result < 0)
+    {
+        LOG_DEBUG("[ASRock GPU] Write block failed: %d", result);
+        return(false);
+    }
+
+    return(true);
+}
+
+bool ASRockGPUSMBusController::ReadBlock(uint8_t* response, uint8_t len)
+{
+    memset(response, 0, len);
+    int size   = len;
+    int result = bus->i2c_read_block(dev, &size, response);
+
+    if(result < 0)
+    {
+        LOG_DEBUG("[ASRock GPU] Read block failed: %d", result);
+        return(false);
+    }
+
+    return(true);
+}
+
+bool ASRockGPUSMBusController::DetectChannels()
+{
+    /*-----------------------------------------------------*\
+    | Get enabled channels                                 |
+    | Command 0x14, subcommand 0x01                        |
+    \*-----------------------------------------------------*/
+    if(!WriteBlock(0x14, 0x01, nullptr, 0))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to request enabled channels");
+        return(false);
+    }
+
+    std::this_thread::sleep_for(20ms);
+
+    uint8_t response[I2C_SMBUS_BLOCK_MAX];
+    if(!ReadBlock(response, sizeof(response)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to read enabled channels");
+        return(false);
+    }
+
+    LOG_TRACE("[ASRock GPU] Enabled channels response: %02X %02X %02X %02X %02X %02X", response[0], response[1], response[2], response[3], response[4], response[5]);
+
+    /*-----------------------------------------------------*\
+    | Response format                                      |
+    | Bytes 4-5 contain the channel bitmap                 |
+    \*-----------------------------------------------------*/
+    uint16_t channel_bits = response[4] | (response[5] << 8);
+    LOG_TRACE("[ASRock GPU] Channel bits: 0x%04X", channel_bits);
+
+    /*-----------------------------------------------------*\
+    | Get LED counts                                       |
+    | Command 0x14, subcommand 0x02                        |
+    \*-----------------------------------------------------*/
+    if(!WriteBlock(0x14, 0x02, nullptr, 0))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to request LED counts");
+        return(false);
+    }
+
+    std::this_thread::sleep_for(20ms);
+
+    if(!ReadBlock(response, sizeof(response)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to read LED counts");
+        return(false);
+    }
+
+    num_channels = 0;
+    for(int i = 0; i < 16; i++)
+    {
+        if(channel_bits & (1 << i))
+        {
+            enabled_channels[num_channels] = i;
+            led_counts[num_channels]       = response[4 + i];
+
+            const char* name = "Unknown";
+            if(i == ASROCK_GPU_CHANNEL_ARGB_HEADER)
+            {
+                name = "ARGB Header";
+            }
+            else if(i == ASROCK_GPU_CHANNEL_TOP_SIDE)
+            {
+                name = "Top Side";
+            }
+            else if(i == ASROCK_GPU_CHANNEL_FAN)
+            {
+                name = "Fan";
+            }
+
+            LOG_DEBUG("[ASRock GPU] Channel %d (%s) active with %d LEDs", i, name, response[4 + i]);
+            num_channels++;
+        }
+    }
+
+    LOG_DEBUG("[ASRock GPU] Found %d active channels", num_channels);
+    return(num_channels > 0);
+}
+
+void ASRockGPUSMBusController::SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue)
+{
+    /*-----------------------------------------------------*\
+    | SignalRGB color packet                               |
+    | Command 0x10, subcommand is the channel index        |
+    \*-----------------------------------------------------*/
+    uint8_t data[8] =
+    {
+        0x01,  // Mode: direct/static
+        red,
+        green,
+        blue,
+        0x80,  // Effect speed
+        0xFF,  // Brightness
+        0x00,  // Effect direction
+        0x1A   // Unknown constant
+    };
+
+    if(!WriteBlock(0x10, channel_idx, data, sizeof(data)))
+    {
+        LOG_WARNING("[ASRock GPU] Failed to set color for channel %d", channel_idx);
+    }
+}
@@ -0,0 +1,55 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusController.h                                |
+|                                                           |
+|   Driver for ASRock GPU RGB controllers                   |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+typedef uint8_t asrock_gpu_dev_id;
+
+#define ASROCK_GPU_CONTROLLER_NAME   "ASRock GPU SMBus Controller"
+#define ASROCK_GPU_SMBUS_ADDRESS     0x36
+
+/*-----------------------------------------------------*\
+| ASRock GPU Channel Names (from SignalRGB)             |
+\*-----------------------------------------------------*/
+enum
+{
+    ASROCK_GPU_CHANNEL_ARGB_HEADER  = 3,
+    ASROCK_GPU_CHANNEL_TOP_SIDE     = 6,
+    ASROCK_GPU_CHANNEL_FAN          = 7,
+};
+
+class ASRockGPUSMBusController
+{
+public:
+    ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name);
+    ~ASRockGPUSMBusController();
+
+    std::string GetDeviceLocation();
+    std::string GetDeviceName();
+
+    void        SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue);
+    bool        DetectChannels();
+
+    uint8_t     enabled_channels[16];
+    uint8_t     led_counts[16];
+    uint8_t     num_channels;
+
+private:
+    i2c_smbus_interface* bus;
+    asrock_gpu_dev_id    dev;
+    std::string          device_name;
+
+    bool        WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len);
+    bool        ReadBlock(uint8_t* response, uint8_t len);
+};
@@ -0,0 +1,47 @@
+/*---------------------------------------------------------*\
+| ASRockGPUSMBusControllerDetect.cpp                        |
+|                                                           |
+|   Detector for ASRock GPU RGB controllers                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "DetectionManager.h"
+#include "ASRockGPUSMBusController.h"
+#include "LogManager.h"
+#include "RGBController_ASRockGPUSMBus.h"
+#include "i2c_amd_gpu.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+
+DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+
+    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    {
+        return(detected_controllers);
+    }
+
+    LOG_DEBUG("[ASRock GPU] Checking GPU I2C bus for RGB controller at 0x%02X", address);
+
+    ASRockGPUSMBusController* controller = new ASRockGPUSMBusController(bus, address, name);
+
+    if(controller->DetectChannels())
+    {
+        detected_controllers.push_back(new RGBController_ASRockGPUSMBus(controller));
+    }
+    else
+    {
+        LOG_WARNING("[ASRock GPU] No active channels found, device not registered");
+        delete controller;
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend Dark", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5414, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Taichi 16GB OC", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5401, ASROCK_GPU_SMBUS_ADDRESS);
+REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend",   DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);
@@ -0,0 +1,140 @@
+/*---------------------------------------------------------*\
+| RGBController_ASRockGPUSMBus.cpp                          |
+|                                                           |
+|   RGBController for ASRock GPU RGB controllers            |
+|                                                           |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_ASRockGPUSMBus.h"
+
+/**------------------------------------------------------------------*\
+    @name ASRock GPU SMBus
+    @category GPU
+    @type I2C
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectASRockGPUSMBusControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_ASRockGPUSMBus::RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    type        = DEVICE_TYPE_GPU;
+    description = "ASRock GPU RGB Controller";
+    location    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_ASRockGPUSMBus::~RGBController_ASRockGPUSMBus()
+{
+    Shutdown();
+
+    delete controller;
+}
+
+void RGBController_ASRockGPUSMBus::SetupZones()
+{
+    /*-----------------------------------------------------*\
+    | Set up zones - one zone per channel                   |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < controller->num_channels; i++)
+    {
+        uint8_t channel_idx = controller->enabled_channels[i];
+        
+        zone new_zone;
+        new_zone.type = ZONE_TYPE_SINGLE;
+        new_zone.leds_min = 1;
+        new_zone.leds_max = 1;
+        new_zone.leds_count = 1;
+        
+        /*-----------------------------------------------------*\
+        | Channel names from SignalRGB                          |
+        \*-----------------------------------------------------*/
+        if(channel_idx == ASROCK_GPU_CHANNEL_ARGB_HEADER)
+        {
+            new_zone.name = "ARGB Header";
+        }
+        else if(channel_idx == ASROCK_GPU_CHANNEL_TOP_SIDE)
+        {
+            new_zone.name = "Top Side";
+        }
+        else if(channel_idx == ASROCK_GPU_CHANNEL_FAN)
+        {
+            new_zone.name = "Fan";
+        }
+        else
+        {
+            new_zone.name = "Channel " + std::to_string(channel_idx);
+        }
+        
+        zones.push_back(new_zone);
+        
+        /*-----------------------------------------------------*\
+        | Set up LED for this zone                              |
+        \*-----------------------------------------------------*/
+        led new_led;
+        new_led.name = new_zone.name;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_ASRockGPUSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
+void RGBController_ASRockGPUSMBus::DeviceUpdateLEDs()
+{
+    for(unsigned int i = 0; i < controller->num_channels; i++)
+    {
+        uint8_t channel_idx = controller->enabled_channels[i];
+        RGBColor color = colors[i];
+        
+        controller->SetChannelColor(channel_idx, 
+                                    RGBGetRValue(color),
+                                    RGBGetGValue(color),
+                                    RGBGetBValue(color));
+    }
+}
+
+void RGBController_ASRockGPUSMBus::UpdateZoneLEDs(int zone)
+{
+    uint8_t channel_idx = controller->enabled_channels[zone];
+    RGBColor color = colors[zone];
+    
+    controller->SetChannelColor(channel_idx,
+                                RGBGetRValue(color),
+                                RGBGetGValue(color),
+                                RGBGetBValue(color));
+}
+
+void RGBController_ASRockGPUSMBus::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_ASRockGPUSMBus::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
@@ -1,9 +1,9 @@
 /*---------------------------------------------------------*\
-| RGBController_PNYGPU.h                                    |
+| RGBController_ASRockGPUSMBus.h                            |
 |                                                           |
-|   RGBController for PNY Turing GPU                        |
+|   RGBController for ASRock GPU RGB controllers            |
 |                                                           |
-|   KendallMorgan                               17 Oct 2021 |
+|   Based on SignalRGB ASRock GPU.js plugin                 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -12,12 +12,13 @@
 #pragma once

 #include "RGBController.h"
-#include "PNYGPUController.h"
+#include "ASRockGPUSMBusController.h"

-class RGBController_PNYGPU : public RGBController
+class RGBController_ASRockGPUSMBus : public RGBController
 {
 public:
-    RGBController_PNYGPU(PNYGPUController* controller_ptr);
+    RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr);
+    ~RGBController_ASRockGPUSMBus();

    void        SetupZones();
    void        ResizeZone(int zone, int new_size);
@@ -29,5 +30,5 @@ public:
    void        DeviceUpdateMode();

 private:
-    PNYGPUController* controller;
+    ASRockGPUSMBusController* controller;
 };
@@ -36,7 +36,7 @@ ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()

 std::string ASRockPolychromeV1SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
    char addr[5];
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
@@ -230,6 +230,8 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR

 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -267,7 +269,6 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
            new_zone->leds_min      = 1;
            new_zone->leds_max      = 1;
            new_zone->leds_count    = 1;
-            new_zone->matrix_map    = NULL;

            if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
            {
@@ -297,10 +298,9 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
    SetupColors();
 }

-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
 {
-    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
-    controller-> SetARGBSize(new_size & 0xFF);
+    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
    zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }

@@ -309,19 +309,19 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
    LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
    for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
    {
-        UpdateSingleLED(zone_idx);
+        DeviceUpdateSingleLED(zone_idx);
    }
 }

-void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
-    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
+    LOG_TRACE("[%s] DeviceUpdateZoneLEDs()", name.c_str());
    DeviceUpdateLEDs();
 }

-void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateSingleLED(int zone)
 {
-    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
+    LOG_TRACE("[%s] DeviceUpdateSingleLED(%02X)", name.c_str(), zone);

    uint8_t red = RGBGetRValue(colors[zone]);
    uint8_t grn = RGBGetGValue(colors[zone]);
@@ -338,7 +338,7 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
        for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
        {
            controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
-            UpdateSingleLED(zone_idx);
+            DeviceUpdateSingleLED(zone_idx);
        }
    }
    else
@@ -23,11 +23,11 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -37,7 +37,7 @@ ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()

 std::string ASRockPolychromeV2SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->device_name);
+    std::string return_string(bus->info.device_name);
    char addr[5];
    snprintf(addr, 5, "0x%02X", dev);
    return_string.append(", address ");
@@ -185,6 +185,8 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR

 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -229,8 +231,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                new_zone->type          = ZONE_TYPE_SINGLE;
            }

-            new_zone->matrix_map        = NULL;
-
            /*---------------------------------------------------------*\
            | Push new zone to zones vector                             |
            \*---------------------------------------------------------*/
@@ -238,7 +238,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
        }
    }

-    unsigned int led_count = 0;
    /*---------------------------------------------------------*\
    | Set up LEDs                                               |
    \*---------------------------------------------------------*/
@@ -268,8 +267,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                \*---------------------------------------------------------*/
                leds.push_back(*new_led);

-                led_count++;
-
                if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                {
                    break;
@@ -281,7 +278,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
    SetupColors();
 }

-void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
 {
    /*---------------------------------------------------------*\
    | This device does not support resizing zones               |
@@ -292,16 +289,16 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
    for(unsigned int led = 0; led < colors.size(); led++)
    {
-        UpdateSingleLED(led);
+        DeviceUpdateSingleLED(led);
    }
 }

-void RGBController_ASRockPolychromeV2SMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
 {
    unsigned char red = RGBGetRValue(colors[led]);
    unsigned char grn = RGBGetGValue(colors[led]);
@@ -23,11 +23,11 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -11,7 +11,7 @@
 \*---------------------------------------------------------*/

 #include <vector>
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
@@ -22,15 +22,6 @@
 #include "i2c_smbus.h"
 #include "pci_ids.h"

-/*******************************************************************************************\
-*                                                                                           *
-*   TestForPolychromeSMBusController                                                        *
-*                                                                                           *
-*       Tests the given address to see if an ASRock RGB controller exists there.            *
-*       First does a quick write to test for a response                                     *
-*                                                                                           *
-\*******************************************************************************************/
-
 #define ASROCK_DETECTOR_NAME        "ASRock SMBus Detectector"
 #define VENDOR_NAME                 "ASRock"
 #define SMBUS_ADDRESS               0x6A
@@ -67,7 +58,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)

    return(pass);

-}   /* TestForPolychromeController() */
+}

 uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
 {
@@ -94,64 +85,54 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
    }
 }

-/******************************************************************************************\
-*                                                                                          *
-*   DetectPolychromeControllers                                                            *
-*                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
-*           dev - I2C address of Polychrome device                                         *
-*                                                                                          *
-\******************************************************************************************/
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
+{
+    DetectedControllers detected_controllers;

-void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
    {
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
        {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
            {
                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
                {
                    LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);

                    u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);

                    switch(version.msb)
                    {
                        case ASROCK_TYPE_ASRLED:
                            {
                                LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

                            case ASROCK_TYPE_POLYCHROME_V1:
                            {
                                LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

                            case ASROCK_TYPE_POLYCHROME_V2:
                            {
                                LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

@@ -172,6 +153,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
        }
    }

-}   /* DetectSMBusPolychromeControllers() */
+    return(detected_controllers);
+}

 REGISTER_I2C_DETECTOR("ASRock Motherboard SMBus Controllers", DetectASRockSMBusControllers);
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Detector for Acer Nitro HID Keyboard                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include "DetectionManager.h"
+#include "AcerNitroHidKeyboardController.h"
+#include "RGBController_AcerNitroHidKeyboard.h"
+#include "RGBController_AcerNitroHidLed.h"
+
+/*---------------------------------------------------------*\
+| HID vendor and product IDs for ENEK EC in Acer Nitro      |
+\*---------------------------------------------------------*/
+
+#define ACER_ENEC_VID           0x0CF2
+#define ACER_ENEC_PID           0x5130
+#define ACER_ENEC_USAGE_PAGE    0xFF5A
+#define ACER_ENEC_USAGE         0x01
+
+DetectedControllers DetectAcerHIDControllers(hid_device_info* info, const std::string&)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+    if(dev)
+    {
+        /*-------------------------------------------------*\
+        | Controller is shared between keyboard and onboard |
+        | led                                               |
+        \*-------------------------------------------------*/
+        std::shared_ptr<AcerNitroHidKeyboardController> controller  = std::make_shared<AcerNitroHidKeyboardController>(dev, info->path);
+        RGBController_AcerNitroHidKeyboard* rgb_kb_controller       = new RGBController_AcerNitroHidKeyboard(controller);
+        RGBController_AcerNitroHidLed* rgb_led_controller           = new RGBController_AcerNitroHidLed(controller);
+
+        detected_controllers.push_back(rgb_kb_controller);
+        detected_controllers.push_back(rgb_led_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_PU("AcerNitroHidKeyboardController", DetectAcerHIDControllers, ACER_ENEC_VID, ACER_ENEC_PID, ACER_ENEC_USAGE_PAGE, ACER_ENEC_USAGE);
@@ -0,0 +1,80 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Driver for Acer Nitro Keyboard                          |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "AcerNitroHidKeyboardController.h"
+
+AcerNitroHidKeyboardController::AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path)
+{
+    this->location  = path;
+    this->dev       = dev_handle;
+
+    device_name     = "Acer Nitro HID Keyboard";    
+}
+
+AcerNitroHidKeyboardController::~AcerNitroHidKeyboardController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
+
+std::string AcerNitroHidKeyboardController::GetLocation() const
+{
+    return("HID: " + location);
+}
+
+std::string AcerNitroHidKeyboardController::GetDeviceName() const
+{
+    return(device_name);
+}
+
+void AcerNitroHidKeyboardController::SetLEDs(const std::vector<RGBColor>& colors, unsigned char brightness, unsigned char device_id)
+{
+    std::lock_guard<std::mutex> guard(device_mutex);
+
+    for(unsigned int led_idx = 0; (led_idx < colors.size()) && (led_idx < ACER_HID_NUM_ZONES); led_idx++)
+    {
+        /*-------------------------------------------------*\
+        | Convert colors to RGB format                      |
+        \*-------------------------------------------------*/
+        unsigned char r = RGBGetRValue(colors[led_idx]);
+        unsigned char g = RGBGetGValue(colors[led_idx]);        
+        unsigned char b = RGBGetBValue(colors[led_idx]);
+
+        /*-------------------------------------------------*\
+        | Send packet                                       |
+        \*-------------------------------------------------*/
+        unsigned char zone_select                   = (unsigned char)(1<<led_idx);
+        unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, ACER_HID_MODE_STATIC, brightness, 0, 1, r, g, b, zone_select, 0};
+        hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
+    }
+}
+
+void AcerNitroHidKeyboardController::SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id)
+{
+    std::lock_guard<std::mutex> guard(device_mutex);
+
+    /*-----------------------------------------------------*\
+    | Convert color to RGB format                           |
+    \*-----------------------------------------------------*/
+    unsigned char r = RGBGetRValue(color);
+    unsigned char g = RGBGetGValue(color);        
+    unsigned char b = RGBGetBValue(color);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    | Zone select = All zones                               |
+    \*-----------------------------------------------------*/
+    unsigned char zone_select                   = 0x0F;
+    unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, mode, brightness, speed, direction, r, g, b, zone_select, 0};
+    hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
+}
@@ -0,0 +1,56 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   Driver for Acer Nitro Keyboard                          |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+enum
+{
+    ACER_HID_MODE_DIRECT    = 1,
+    ACER_HID_MODE_STATIC    = 2,
+    ACER_HID_MODE_BREATHING = 4,
+    ACER_HID_MODE_NEON      = 5,
+    ACER_HID_MODE_OPMODE    = 6,
+    ACER_HID_MODE_WAVE      = 7,
+    ACER_HID_MODE_SHIFTING  = 8,
+    ACER_HID_MODE_ZOOM      = 9,
+    ACER_HID_MODE_METEOR    = 10,
+    ACER_HID_MODE_TWINKLING = 11,
+};
+
+#define ACER_HID_NAME_BUFFER_SIZE 255
+#define ACER_HID_NUM_ZONES 4
+#define ACER_HID_PACKET_SIZE 11
+
+#include <mutex>
+#include <string>
+#include <vector>
+#include <hidapi.h>
+#include "RGBControllerInterface.h"
+
+class AcerNitroHidKeyboardController
+{
+public:
+    AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path);
+    ~AcerNitroHidKeyboardController();
+
+    std::string GetDeviceName() const;
+    std::string GetSerial() const;
+    std::string GetLocation() const;
+
+    void SetLEDs(const std::vector<RGBColor> &colors, unsigned char brightness, unsigned char device_id);
+    void SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id);
+
+private:
+    hid_device *dev;
+    std::string device_name;
+    std::string location;
+    std::mutex device_mutex;
+};
@@ -0,0 +1,231 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   RGBController for Acer Nitro HID Keyboard               |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AcerNitroHidKeyboard.h"
+
+/**------------------------------------------------------------------*\
+    @name Acer Nitro HID Keyboard
+    @category Laptop
+    @type HID
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAcerHIDControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller)
+{
+    this->controller            = controller;
+    device_id                   = 0x21;
+
+    name                        = "Acer Nitro HID Keyboard";
+    vendor                      = "Acer";
+    type                        = DEVICE_TYPE_LAPTOP;
+    description                 = "Acer Nitro HID Keyboard Device";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ACER_HID_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 100;
+    Direct.brightness           = 100;
+
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ACER_HID_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 100;
+    Static.brightness           = 100;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    Static.speed                = 0;
+
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ACER_HID_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 100;
+    Breathing.brightness        = 100;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.speed_min         = 1;
+    Breathing.speed_max         = 9;
+    Breathing.speed             = 4;
+    Breathing.colors.resize(1);
+
+    modes.push_back(Breathing);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = ACER_HID_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    Neon.brightness_min         = 0;
+    Neon.brightness_max         = 100;
+    Neon.brightness             = 100;
+    Neon.speed_min              = 1;
+    Neon.speed_max              = 9;
+    Neon.speed                  = 4;
+
+    modes.push_back(Neon);
+
+    mode Wave;
+    Wave.name                   = "Wave";
+    Wave.value                  = ACER_HID_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    Wave.color_mode             = MODE_COLORS_NONE;
+    Wave.brightness_min         = 0;
+    Wave.brightness_max         = 100;
+    Wave.brightness             = 100;
+    Wave.speed_min              = 1;
+    Wave.speed_max              = 9;
+    Wave.speed                  = 4;
+    Wave.direction              = 0;
+
+    modes.push_back(Wave);
+
+    mode Shifting;
+    Shifting.name               = "Shifting";
+    Shifting.value              = ACER_HID_MODE_SHIFTING;
+    Shifting.flags              = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Shifting.color_mode         = MODE_COLORS_NONE;
+    Shifting.brightness_min     = 0;
+    Shifting.brightness_max     = 100;
+    Shifting.brightness         = 100;
+    Shifting.speed_min          = 1;
+    Shifting.speed_max          = 9;
+    Shifting.speed              = 4;
+
+    modes.push_back(Shifting);
+
+    mode Zoom;
+    Zoom.name                   = "Zoom";
+    Zoom.value                  = ACER_HID_MODE_ZOOM;
+    Zoom.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Zoom.color_mode             = MODE_COLORS_NONE;
+    Zoom.brightness_min         = 0;
+    Zoom.brightness_max         = 100;
+    Zoom.brightness             = 100;
+    Zoom.speed_min              = 1;
+    Zoom.speed_max              = 9;
+    Zoom.speed                  = 4;
+
+    modes.push_back(Zoom);
+
+    mode Meteor;
+    Meteor.name                 = "Meteor";
+    Meteor.value                = ACER_HID_MODE_METEOR;
+    Meteor.flags                = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Meteor.color_mode           = MODE_COLORS_NONE;
+    Meteor.brightness_min       = 0;
+    Meteor.brightness_max       = 100;
+    Meteor.brightness           = 100;
+    Meteor.speed_min            = 1;
+    Meteor.speed_max            = 9;
+    Meteor.speed                = 4;
+
+    modes.push_back(Meteor);
+
+    mode Twinkling;
+    Twinkling.name              = "Twinkling";
+    Twinkling.value             = ACER_HID_MODE_TWINKLING;
+    Twinkling.flags             = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Twinkling.color_mode        = MODE_COLORS_NONE;
+    Twinkling.brightness_min    = 0;
+    Twinkling.brightness_max    = 100;
+    Twinkling.brightness        = 100;
+    Twinkling.colors_min        = 1;
+    Twinkling.colors_max        = 1;
+    Twinkling.speed_min         = 1;
+    Twinkling.speed_max         = 9;
+    Twinkling.speed             = 4;
+
+    modes.push_back(Twinkling);
+
+    SetupZones();
+}
+
+RGBController_AcerNitroHidKeyboard::~RGBController_AcerNitroHidKeyboard()
+{
+    Shutdown();
+}
+
+void RGBController_AcerNitroHidKeyboard::SetupZones()
+{
+    zone* new_zone          = new zone;
+
+    new_zone->name          = "Keyboard Backlight Zone";
+    new_zone->type          = ZONE_TYPE_LINEAR;
+    new_zone->leds_min      = 4;
+    new_zone->leds_max      = 4;
+    new_zone->leds_count    = 4;
+
+    zones.push_back(*new_zone);
+
+    for(std::size_t zone_idx = 0; zone_idx < ACER_HID_NUM_ZONES; zone_idx++)
+    {
+        led* new_led        = new led();
+        new_led->name       = "Keyboard Backlight Zone ";
+        new_led->name.append(std::to_string(zone_idx + 1));
+        new_led->value      = (unsigned int)leds.size();
+
+        leds.push_back(*new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateLEDs()
+{
+    mode& current_mode = modes[active_mode];
+    if(current_mode.value == ACER_HID_MODE_DIRECT)
+    {
+        controller->SetLEDs(colors, current_mode.brightness, device_id);
+    }
+    else
+    {
+        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
+        unsigned char direction = 1;
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
+        {
+            direction           = 2;
+        }
+        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
+    }
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateZoneLEDs(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateSingleLED(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidKeyboard::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
@@ -0,0 +1,33 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidKeyboard.cpp                    |
+|                                                           |
+|   RGBController for Acer Nitro HID Keyboard               |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AcerNitroHidKeyboardController.h"
+
+class RGBController_AcerNitroHidKeyboard : public RGBController
+{
+public:
+    RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller);
+    ~RGBController_AcerNitroHidKeyboard();
+
+    void SetupZones();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+    void DeviceUpdateMode();
+
+private:
+    std::shared_ptr<AcerNitroHidKeyboardController> controller;
+    unsigned int device_id;
+};
@@ -0,0 +1,152 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidLed.cpp                         |
+|                                                           |
+|   RGBController for Acer Nitro HID LED                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AcerNitroHidLed.h"
+
+/**------------------------------------------------------------------*\
+    @name Acer Nitro HID Led
+    @category Laptop
+    @type HID
+    @save :x:
+    @direct :white_check_mark:
+    @effects :white_check_mark:
+    @detectors DetectAcerHIDControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_AcerNitroHidLed::RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller)
+{
+    this->controller            = controller;
+    device_id                   = 0x65;
+
+    name                        = "Acer Nitro HID LED Device";
+    vendor                      = "Acer";
+    type                        = DEVICE_TYPE_LIGHT;
+    description                 = "Acer Nitro HID LED Device";
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = ACER_HID_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    Direct.brightness_min       = 0;
+    Direct.brightness_max       = 100;
+    Direct.brightness           = 100;
+
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = ACER_HID_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.brightness_min       = 0;
+    Static.brightness_max       = 100;
+    Static.brightness           = 100;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    Static.speed                = 0;
+
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = ACER_HID_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = 0;
+    Breathing.brightness_max    = 100;
+    Breathing.brightness        = 100;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 1;
+    Breathing.speed_min         = 1;
+    Breathing.speed_max         = 5;
+    Breathing.speed             = 4;
+    Breathing.colors.resize(1);
+
+    modes.push_back(Breathing);
+
+    mode Neon;
+    Neon.name                   = "Neon";
+    Neon.value                  = ACER_HID_MODE_NEON;
+    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Neon.color_mode             = MODE_COLORS_NONE;
+    Neon.brightness_min         = 0;
+    Neon.brightness_max         = 100;
+    Neon.brightness             = 100;
+    Neon.speed_min              = 1;
+    Neon.speed_max              = 5;
+    Neon.speed                  = 4;
+
+    modes.push_back(Neon);
+
+    SetupZones();
+}
+
+RGBController_AcerNitroHidLed::~RGBController_AcerNitroHidLed()
+{
+    Shutdown();
+}
+
+void RGBController_AcerNitroHidLed::SetupZones()
+{
+    zone* new_zone          = new zone;
+
+    new_zone->name          = "LED";
+    new_zone->type          = ZONE_TYPE_LINEAR;
+    new_zone->leds_min      = 1;
+    new_zone->leds_max      = 1;
+    new_zone->leds_count    = 1;
+    zones.push_back(*new_zone);
+
+    led* new_led            = new led();
+    new_led->name           = "LED";
+    new_led->value          = (unsigned int)leds.size();
+    leds.push_back(*new_led);
+
+    SetupColors();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateLEDs()
+{
+    mode& current_mode = modes[active_mode];
+    if(current_mode.value == ACER_HID_MODE_DIRECT)
+    {
+        controller->SetLEDs(colors, current_mode.brightness, device_id);
+    }
+    else
+    {
+        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
+        unsigned char direction = 1;
+        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
+        {
+            direction           = 2;
+        }
+        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
+    }
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateZoneLEDs(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateSingleLED(int)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AcerNitroHidLed::DeviceUpdateMode()
+{
+    DeviceUpdateLEDs();
+}
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_AcerNitroHidLed.cpp                         |
+|                                                           |
+|   RGBController for Acer Nitro HID LED                    |
+|                                                           |
+|   Marek Pokropiński                           Jul 27 2026 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AcerNitroHidKeyboardController.h"
+#include "RGBController_AcerNitroHidKeyboard.h"
+
+class RGBController_AcerNitroHidLed : public RGBController
+{
+public:
+    RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller);
+    ~RGBController_AcerNitroHidLed();
+
+    void SetupZones();
+
+    void DeviceUpdateLEDs();
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+
+private:
+    std::shared_ptr<AcerNitroHidKeyboardController> controller;
+    unsigned int device_id;
+};
@@ -32,6 +32,7 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
    { 0x0C01,   4 },    // Dell G5 SE 5505
    { 0x0A01,  16 },    // Dell G7 15 7500
    { 0x0E03,   4 },    // Dell G15   5511
+    { 0x0E07,   4 },    // Dell G15   5520
    { 0x0E0A,   4 }     // Dell G15   5530

 };
@@ -49,9 +50,21 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
+    { 0x0E07,   { "Left",           "Middle",       "Right",        "Numpad"    } },
    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };

+/*---------------------------------------------------------*\
+| Mapping the platform ID to the actual hardware zone IDs   |
+\*---------------------------------------------------------*/
+static const std::map<alienware_platform_id, std::vector<uint8_t>> zone_ids_table =
+{
+    { 0x0C01,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G5 SE 5505
+    { 0x0E03,   { 0x00, 0x01, 0x02, 0x03 } }, // Dell G15   5511
+    { 0x0E07,   { 0x10, 0x11, 0x12, 0x13 } }, // Dell G15   5520
+    { 0x0E0A,   { 0x10, 0x11, 0x12, 0x13 } }  // Dell G15   5530
+};
+
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
 {
    using namespace std::chrono_literals;
@@ -138,6 +151,21 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
        }
    }

+    /*-----------------------------------------------------*\
+    | Initialize hardware zone IDs                          |
+    \*-----------------------------------------------------*/
+    if(zone_ids_table.count(platform_id))
+    {
+        zone_ids = zone_ids_table.at(platform_id);
+    }
+    else
+    {
+        for(size_t i = 0; i < number_of_zones; i++)
+        {
+            zone_ids.push_back(static_cast<uint8_t>(i));
+        }
+    }
+
    /*-----------------------------------------------------*\
    | Set defaults for all zones                            |
    | It doesn't seem possible to read the controller's     |
@@ -155,6 +183,7 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
        zones[zone_idx].period      = 2000;
        zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
        zones[zone_idx].dim         = 0;
+        zones[zone_idx].direction   = 0;
    }

    /*-----------------------------------------------------*\
@@ -266,17 +295,25 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
        return(true);
    }

+    bool result = true;
+
+    /*-----------------------------------------------------*\
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
+    \*-----------------------------------------------------*/
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    {
        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Zero out buffer                                   |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        memset(usb_buf, 0x00, sizeof(usb_buf));

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Set up message packet with leading 00, per hidapi |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+        \*-------------------------------------------------*/
+        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);

        usb_buf[0x00]       = 0x00;
        usb_buf[0x01]       = 0x03;
@@ -287,21 +324,24 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)

        for(size_t i = 0; i < num_zones; i++)
        {
-        usb_buf[0x06+i] = zones[i];
+            usb_buf[0x06+i] = zones[offset + i];
        }

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Send packet                                       |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        SendHIDReport(dev, usb_buf, sizeof(usb_buf));

        HidapiAlienwareReport response = GetResponse();

-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+    }
+
+    return(result);
 }

 bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
@@ -370,17 +410,25 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
        return(false);
    }

+    bool result = true;
+
+    /*-----------------------------------------------------*\
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
+    \*-----------------------------------------------------*/
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    {
        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Zero out buffer                                   |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        memset(usb_buf, 0x00, sizeof(usb_buf));

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Set up message packet with leading 00, per hidapi |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+        \*-------------------------------------------------*/
+        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);

        usb_buf[0x00]       = 0x00;
        usb_buf[0x01]       = 0x03;
@@ -391,21 +439,24 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)

        for(size_t i = 0; i < num_zones; i++)
        {
-        usb_buf[0x06+i] = zones[i];
+            usb_buf[0x06+i] = zones[offset + i];
        }

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Send packet                                       |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        SendHIDReport(dev, usb_buf, sizeof(usb_buf));

        HidapiAlienwareReport response = GetResponse();

-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+    }
+
+    return(result);
 }

 bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
@@ -509,17 +560,25 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
        return(true);
    }

+    bool result = true;
+
+    /*-----------------------------------------------------*\
+    | Split the zone list into packet-sized chunks so it    |
+    | never overflows usb_buf                               |
+    \*-----------------------------------------------------*/
+    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    {
        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Zero out buffer                                   |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        memset(usb_buf, 0x00, sizeof(usb_buf));

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Set up message packet with leading 00, per hidapi |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones      = (uint16_t)zones.size();
+        \*-------------------------------------------------*/
+        uint16_t num_zones      = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);

        usb_buf[0x00]           = 0x00;
        usb_buf[0x01]           = 0x03;
@@ -532,21 +591,24 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo

        for(size_t i = 0; i < num_zones; i++)
        {
-        usb_buf[0x08 + i]   = zones[i];
+            usb_buf[0x08 + i]   = zones[offset + i];
        }

-    /*-----------------------------------------------------*\
+        /*-------------------------------------------------*\
        | Send packet                                       |
-    \*-----------------------------------------------------*/
+        \*-------------------------------------------------*/
        SendHIDReport(dev, usb_buf, sizeof(usb_buf));

        HidapiAlienwareReport response = GetResponse();

-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
+        /*-------------------------------------------------*\
+        | For this command, error is if the output equals   |
+        | the input                                         |
+        \*-------------------------------------------------*/
+        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+    }
+
+    return(result);
 }

 bool AlienwareController::Reset()
@@ -640,6 +702,15 @@ void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
    }
 }

+void AlienwareController::SetDirection(uint8_t zone, uint8_t direction)
+{
+    if(zone < zones.size())
+    {
+        zones[zone].direction   = direction;
+        dirty                   = true;
+    }
+}
+
 void AlienwareController::UpdateDim()
 {
    if(!dirty_dim)
@@ -655,7 +726,8 @@ void AlienwareController::UpdateDim()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        dim_zone_map[zones[i].dim].emplace_back(hw_zone);
    }

    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -682,7 +754,8 @@ bool AlienwareController::UpdateDirect()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        uint8_t hw_zone = (i < zone_ids.size()) ? zone_ids[i] : static_cast<uint8_t>(i);
+        color_zone_map[zones[i].color[0]].emplace_back(hw_zone);
    }

    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -726,8 +799,9 @@ void AlienwareController::UpdateMode()
    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);

-        result = SelectZones({static_cast<uint8_t>(zone_idx)});
+        result = SelectZones({hw_zone});

        if(!result)
        {
@@ -750,18 +824,18 @@ void AlienwareController::UpdateMode()

            case ALIENWARE_MODE_MORPH:
                {
-                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
                    uint16_t periods[2] = { zone.period,            zone.period   };
                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };

-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                }
                break;

            case ALIENWARE_MODE_SPECTRUM:
                {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH };
@@ -774,13 +848,13 @@ void AlienwareController::UpdateMode()
                                            zone.tempo,             zone.tempo,
                                            zone.tempo };

-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
                }
                break;

            case ALIENWARE_MODE_RAINBOW:
                {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
                                            ALIENWARE_MODE_MORPH };
@@ -793,18 +867,19 @@ void AlienwareController::UpdateMode()
                                            zone.tempo,             zone.tempo,
                                            zone.tempo };

-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
                }
                break;

            case ALIENWARE_MODE_BREATHING:
                {
-                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
                    uint16_t periods[2] = { zone.period,            zone.period          };
                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
                    RGBColor colors[2]  = { zone.color[0],          0x0                  };

-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
                }
                break;

@@ -831,6 +906,117 @@ void AlienwareController::UpdateMode()
    dirty = false;
 }

+void AlienwareController::SaveController()
+{
+    /*-----------------------------------------------------*\
+    | Save current mode configuration to EEPROM slot 0x0061 |
+    \*-----------------------------------------------------*/
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_REMOVE, ALIENWARE_ANIM_DEFAULT, 0);
+    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_ANIM_DEFAULT, 0);
+
+    if(!result)
+    {
+        return;
+    }
+
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        alienware_zone zone = zones[zone_idx];
+        uint8_t hw_zone = (zone_idx < zone_ids.size()) ? zone_ids[zone_idx] : static_cast<uint8_t>(zone_idx);
+
+        result = SelectZones({hw_zone});
+
+        if(!result)
+        {
+            return;
+        }
+
+        switch (zone.mode)
+        {
+            case ALIENWARE_MODE_COLOR:
+                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_PULSE:
+                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
+                break;
+
+            case ALIENWARE_MODE_MORPH:
+                {
+                    uint8_t  modes[2]   = { zone.mode,              zone.mode     };
+                    uint16_t periods[2] = { zone.period,            zone.period   };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
+                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            case ALIENWARE_MODE_SPECTRUM:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[0], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_RAINBOW:
+                {
+                    uint8_t  modes[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
+                                            ALIENWARE_MODE_MORPH };
+                    uint16_t periods[7] = { zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period,            zone.period,
+                                            zone.period };
+                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo,             zone.tempo,
+                                            zone.tempo };
+
+                    unsigned int color_idx = (zone.direction == MODE_DIRECTION_LEFT) ? (4 - 1 - (zone_idx % 4)) : (zone_idx % 4);
+                    result = MultiModeAction(modes, periods, tempos, rainbow_colors[color_idx], 7);
+                }
+                break;
+
+            case ALIENWARE_MODE_BREATHING:
+                {
+                    uint8_t  modes[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
+                    uint16_t periods[2] = { zone.period,            zone.period          };
+                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
+                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
+
+                    result = MultiModeAction(modes, periods, tempos, colors, 2);
+                }
+                break;
+
+            default:
+                result = false;
+        }
+
+        if(!result)
+        {
+            return;
+        }
+    }
+
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_DEFAULT, ALIENWARE_ANIM_DEFAULT, 0);
+    UserAnimation(ALIENWARE_COMMAND_USER_ANIM_STARTUP, ALIENWARE_ANIM_DEFAULT, 0);
+}
+
 void AlienwareController::UpdateController()
 {
    UpdateMode();
@@ -22,6 +22,14 @@
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
 #define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
+/*---------------------------------------------------------*\
+| Max zone IDs that fit in one report after the command     |
+| header.  Selections larger than this must be split across |
+| multiple packets; writing them into a single report       |
+| overflows usb_buf (e.g. desktops with ~100 zones).        |
+\*---------------------------------------------------------*/
+#define ALIENWARE_MAX_ZONES_PER_PACKET      25
 enum
 {
    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
@@ -115,11 +123,13 @@ public:
    void                        SetPeriod(uint8_t zone, uint16_t period);
    void                        SetTempo(uint8_t zone, uint16_t tempo);
    void                        SetDim(uint8_t zone, uint8_t dim);
+    void                        SetDirection(uint8_t zone, uint8_t direction);
    AlienwareReport             GetStatus(uint8_t subcommand);

    void                        UpdateDim();
    void                        UpdateMode();
    void                        UpdateController();
+    void                        SaveController();

 protected:
    hid_device* dev;
@@ -132,6 +142,7 @@ private:
        uint16_t                period;
        uint16_t                tempo;
        uint8_t                 dim;
+        uint8_t                 direction;
    } alienware_zone;

    typedef struct
@@ -145,6 +156,7 @@ private:
    std::string                 serial_number;
    std::string                 version;
    std::vector<const char*>    zone_names;
+    std::vector<uint8_t>        zone_ids;
    bool                        dirty;
    bool                        dirty_dim;

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
 #include "AlienwareController.h"
+#include "DetectionManager.h"
 #include "RGBController_Alienware.h"

 /*---------------------------------------------------------*\
@@ -22,17 +22,22 @@
 #define ALIENWARE_G_SERIES_PID1                      0x0550
 #define ALIENWARE_G_SERIES_PID2                      0x0551

-void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AlienwareController*     controller     = new AlienwareController(dev, *info, name);
        RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
@@ -39,7 +39,7 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Color;
    Color.name                 = "Static";
    Color.value                = ALIENWARE_MODE_COLOR;
-    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
    Color.color_mode           = MODE_COLORS_PER_LED;
    Color.colors_min           = 1;
    Color.colors_max           = 1;
@@ -51,13 +51,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Pulse;
    Pulse.name                 = "Flashing";
    Pulse.value                = ALIENWARE_MODE_PULSE;
-    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
    Pulse.color_mode           = MODE_COLORS_PER_LED;
    Pulse.colors_min           = 1;
    Pulse.colors_max           = 1;
-    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
-    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
-    Pulse.speed                = ALIENWARE_TEMPO_MIN;
+    Pulse.speed_min            = ALIENWARE_TEMPO_MAX;
+    Pulse.speed_max            = 50;
+    Pulse.speed                = 150;
    Pulse.brightness_min       = 100;
    Pulse.brightness_max       = 0;
    Pulse.brightness           = 0;
@@ -66,14 +66,16 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Morph;
    Morph.name                 = "Morph";
    Morph.value                = ALIENWARE_MODE_MORPH;
-    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
    Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2 * controller->GetZoneCount();
-    Morph.colors_max           = Morph.colors_min;
-    Morph.colors.resize(Morph.colors_max);
-    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
-    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
-    Morph.speed                = ALIENWARE_TEMPO_MIN;
+    Morph.colors_min           = 2;
+    Morph.colors_max           = 2 * controller->GetZoneCount();
+    Morph.colors.resize(2);
+    Morph.colors[0]            = 0x0000FF;
+    Morph.colors[1]            = 0xFF0000;
+    Morph.speed_min            = ALIENWARE_TEMPO_MAX;
+    Morph.speed_max            = 20;
+    Morph.speed                = 100;
    Morph.brightness_min       = 100;
    Morph.brightness_max       = 0;
    Morph.brightness           = 0;
@@ -82,11 +84,11 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Spectrum;
    Spectrum.name              = "Spectrum Cycle";
    Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
-    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
    Spectrum.color_mode        = MODE_COLORS_NONE;
-    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
-    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed_min         = ALIENWARE_TEMPO_MAX;
+    Spectrum.speed_max         = ALIENWARE_TEMPO_SPECTRUM;
+    Spectrum.speed             = 40;
    Spectrum.brightness_min    = 100;
    Spectrum.brightness_max    = 0;
    Spectrum.brightness        = 0;
@@ -95,11 +97,12 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Rainbow;
    Rainbow.name               = "Rainbow Wave";
    Rainbow.value              = ALIENWARE_MODE_RAINBOW;
-    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
    Rainbow.color_mode         = MODE_COLORS_NONE;
-    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
-    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed_min          = ALIENWARE_TEMPO_MAX;
+    Rainbow.speed_max          = ALIENWARE_TEMPO_SPECTRUM;
+    Rainbow.speed              = 40;
+    Rainbow.direction          = MODE_DIRECTION_RIGHT;
    Rainbow.brightness_min     = 100;
    Rainbow.brightness_max     = 0;
    Rainbow.brightness         = 0;
@@ -108,13 +111,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    mode Breathing;
    Breathing.name             = "Breathing";
    Breathing.value            = ALIENWARE_MODE_BREATHING;
-    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
    Breathing.color_mode       = MODE_COLORS_PER_LED;
    Breathing.colors_min       = 1;
    Breathing.colors_max       = 1;
-    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
-    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
-    Breathing.speed            = ALIENWARE_TEMPO_MIN;
+    Breathing.speed_min        = ALIENWARE_TEMPO_MAX;
+    Breathing.speed_max        = 50;
+    Breathing.speed            = 150;
    Breathing.brightness_min   = 100;
    Breathing.brightness_max   = 0;
    Breathing.brightness       = 0;
@@ -125,6 +128,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    controller->UpdateDim();
 }

+RGBController_Alienware::~RGBController_Alienware()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_Alienware::SetupZones()
 {
    /*-------------------------------------------------*\
@@ -141,7 +151,6 @@ void RGBController_Alienware::SetupZones()
        new_zone.leds_min   = 1;
        new_zone.leds_max   = 1;
        new_zone.leds_count = 1;
-        new_zone.matrix_map = nullptr;

        zones.emplace_back(new_zone);
    }
@@ -158,26 +167,19 @@ void RGBController_Alienware::SetupZones()
    SetupColors();
 }

-void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_Alienware::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Alienware::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_Alienware::UpdateSingleLED(int led)
+void RGBController_Alienware::DeviceUpdateSingleLED(int led)
 {
-    UpdateZoneLEDs(led);
+    DeviceUpdateZoneLEDs(led);
 }

 static bool modes_eq(const mode& mode1, const mode& mode2)
@@ -225,6 +227,7 @@ void RGBController_Alienware::DeviceUpdateMode()
            uint16_t period = 0x07d0;

            controller->SetMode(zone_idx, current_mode.value);
+            controller->SetDirection(zone_idx, current_mode.direction);

            switch(current_mode_idx)
            {
@@ -236,6 +239,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                    break;

                case ALIENWARE_MODE_PULSE:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                    controller->SetPeriod(zone_idx, period);
                    controller->SetColor( zone_idx, colors[current_zone.start_idx]);
                    controller->SetTempo( zone_idx, current_mode.speed);
@@ -243,10 +247,22 @@ void RGBController_Alienware::DeviceUpdateMode()
                    break;

                case ALIENWARE_MODE_MORPH:
+                    {
+                        RGBColor c1 = (current_mode.colors.size() >= 1) ? current_mode.colors[0] : 0x0000FF;
+                        RGBColor c2 = (current_mode.colors.size() >= 2) ? current_mode.colors[1] : 0xFF0000;
+
+                        if(current_mode.colors.size() >= (std::size_t)((zone_idx + 1) * 2))
+                        {
+                            c1 = current_mode.colors[zone_idx * 2];
+                            c2 = current_mode.colors[(zone_idx * 2) + 1];
+                        }
+
+                        period = std::max<uint16_t>(400, (uint16_t)(current_mode.speed * 10));
                        controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
+                        controller->SetColor( zone_idx, c1, c2);
                        controller->SetTempo( zone_idx, current_mode.speed);
                        controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
+                    }
                    break;

                case ALIENWARE_MODE_SPECTRUM:
@@ -257,6 +273,7 @@ void RGBController_Alienware::DeviceUpdateMode()
                    break;

                case ALIENWARE_MODE_BREATHING:
+                    period = std::max<uint16_t>(500, (uint16_t)(current_mode.speed * 10));
                    controller->SetPeriod(zone_idx, period);
                    controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
                    controller->SetTempo( zone_idx, current_mode.speed);
@@ -283,3 +300,9 @@ void RGBController_Alienware::DeviceUpdateMode()
        current_mode              = new_current_mode;
    }
 }
+
+void RGBController_Alienware::DeviceSaveMode()
+{
+    controller->SaveController();
+}
+
@@ -19,16 +19,16 @@ class RGBController_Alienware : public RGBController
 {
 public:
    RGBController_Alienware(AlienwareController* controller_ptr);
+    ~RGBController_Alienware();

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();
+    void        DeviceSaveMode();

 private:
    AlienwareController*                    controller;
@@ -319,7 +319,7 @@ void AlienwareAW410KController::SetMode
    SendCommit();
 }

-void AlienwareAW410KController::UpdateSingleLED
+void AlienwareAW410KController::DeviceUpdateSingleLED
    (
    unsigned char   led,
    unsigned char   red,
@@ -130,7 +130,7 @@ public:
                    unsigned char   blue2
                    );

-    void        UpdateSingleLED
+    void        DeviceUpdateSingleLED
                    (
                    unsigned char   led,
                    unsigned char   red,
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------*\
+| AlienwareAW410KControllerDetect.cpp                       |
+|                                                           |
+|   Detector for Alienware AW410K Keyboard                  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "AlienwareAW410KController.h"
+#include "RGBController_AlienwareAW410K.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x04F2
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW410K_PID                        0x1968
+
+DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
+        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);
@@ -278,16 +278,7 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont

 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
+    Shutdown();

    delete controller;
 }
@@ -310,14 +301,7 @@ void RGBController_AlienwareAW410K::SetupZones()

        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map.Set(6, 24, (unsigned int *)&matrix_map);
        }

        zones.push_back(new_zone);
@@ -336,13 +320,6 @@ void RGBController_AlienwareAW410K::SetupZones()
    SetupColors();
 }

-void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
 {
    std::vector<SelectedButtons>   frame_buf_keys;
@@ -374,21 +351,21 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }

-void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
 {
    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }

-void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
+void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }

 void RGBController_AlienwareAW410K::DeviceUpdateMode()
 {
    if(active_mode == 0xFFFF)
    {
-        UpdateLEDs();
+        UpdateLEDsInternal();
        return;
    }

@@ -23,11 +23,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -318,7 +318,7 @@ void AlienwareAW510KController::SetMode
    SendCommit();
 }

-void AlienwareAW510KController::UpdateSingleLED
+void AlienwareAW510KController::DeviceUpdateSingleLED
    (
    unsigned char   led,
    unsigned char   red,
@@ -132,7 +132,7 @@ public:
                    unsigned char   blue2
                    );

-    void        UpdateSingleLED
+    void        DeviceUpdateSingleLED
                    (
                    unsigned char   led,
                    unsigned char   red,
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------*\
+| AlienwareAW510KControllerDetect.cpp                       |
+|                                                           |
+|   Detector for Alienware AW510K Keyboard                  |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "DetectionManager.h"
+#include "AlienwareAW510KController.h"
+#include "RGBController_AlienwareAW510K.h"
+
+/*---------------------------------------------------------*\
+| Alienware vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x04F2
+
+/*---------------------------------------------------------*\
+| Keyboard product IDs                                      |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW510K_PID                        0x1830
+
+DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
+        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
@@ -277,16 +277,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont

 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
+    Shutdown();

    delete controller;
 }
@@ -309,14 +300,7 @@ void RGBController_AlienwareAW510K::SetupZones()

        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 7;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
        }

        zones.push_back(new_zone);
@@ -335,13 +319,6 @@ void RGBController_AlienwareAW510K::SetupZones()
    SetupColors();
 }

-void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
 {
    std::vector<SelectedKeys>   frame_buf_keys;
@@ -395,21 +372,21 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }

-void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(int zone)
 {
    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }

-void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
+void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
 {
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }

 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
    if(active_mode == 0xFFFF)
    {
-        UpdateLEDs();
+        UpdateLEDsInternal();
        return;
    }

@@ -22,11 +22,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -1,62 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
-|                                                           |
-|   Detector for Alienware Keyboard                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "Detector.h"
-#include "AlienwareAW510KController.h"
-#include "AlienwareAW410KController.h"
-#include "RGBController_AlienwareAW510K.h"
-#include "RGBController_AlienwareAW410K.h"
-
-/*-----------------------------------------------------*\
-| Alienware vendor ID                                   |
-\*-----------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
-
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAlienwareKeyboardControllers                                                     *
-*                                                                                          *
-*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
-        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
-        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}/* DetectAlienwareKeyboardControllers() */
-
-
-REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
-REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);
@@ -40,11 +40,11 @@ std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()

 void AlienwareAW3423DWFController::PerformLogin()
 {
-    unsigned char init_packet[64] =
-    {
-        0x40, 0xE1, 0x01
-    };
-    SendControlPacket(init_packet, 4);
+    unsigned char init_packet[192] = {0x00};
+    init_packet[0] = 0x40;
+    init_packet[1] = 0xE1;
+    init_packet[2] = 0x01;
+    SendControlPacket(init_packet, 192);

    std::vector<unsigned char> response = GetReportResponse();

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------*\
+| AlienwareAW3423DWFControllerDetect.cpp                    |
+|                                                           |
+|   Detector for Alienware AW3423DWF monitor                |
+|                                                           |
+|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "AlienwareAW3423DWFController.h"
+#include "DetectionManager.h"
+#include "RGBController_AlienwareAW3423DWF.h"
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_VID                               0x187C
+
+/*---------------------------------------------------------*\
+| Alienware Vendor ID                                       |
+\*---------------------------------------------------------*/
+#define ALIENWARE_AW3423DWF_PID                     0x100E
+#define ALIENWARE_USAGE_PAGE                        0xFFDA
+#define ALIENWARE_USAGE                             0x00DA
+
+DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
+        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
@@ -46,6 +46,8 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34

 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -57,7 +59,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
    Logo.leds_min           = 1;
    Logo.leds_max           = 1;
    Logo.leds_count         = 1;
-    Logo.matrix_map         = NULL;
    zones.push_back(Logo);

    led Logo_LED;
@@ -71,7 +72,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
    Number.leds_min         = 1;
    Number.leds_max         = 1;
    Number.leds_count       = 1;
-    Number.matrix_map       = NULL;
    zones.push_back(Number);

    led Number_LED;
@@ -85,7 +85,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
    PowerButton.leds_min    = 1;
    PowerButton.leds_max    = 1;
    PowerButton.leds_count  = 1;
-    PowerButton.matrix_map  = NULL;
    zones.push_back(PowerButton);

    led PowerButton_LED;
@@ -96,10 +95,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
    SetupColors();
 }

-void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-}
-
 void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
 {
    /*-----------------------------------------------------*\
@@ -118,17 +113,17 @@ void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
    {
        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
        {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
        }
    }
 }

-void RGBController_AlienwareAW3423DWF::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareAW3423DWF::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AlienwareAW3423DWF::UpdateSingleLED(int led)
+void RGBController_AlienwareAW3423DWF::DeviceUpdateSingleLED(int led)
 {
    unsigned char red = RGBGetRValue(colors[led]);
    unsigned char grn = RGBGetGValue(colors[led]);
@@ -21,11 +21,10 @@ public:
    ~RGBController_AlienwareAW3423DWF();

    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -9,12 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
-#include "AlienwareAW3423DWFController.h"
-#include "AlienwareMonitorController.h"
-#include "RGBController_AlienwareAW3423DWF.h"
-#include "RGBController_AlienwareMonitor.h"
 #include <hidapi.h>
+#include "AlienwareMonitorController.h"
+#include "DetectionManager.h"
+#include "RGBController_AlienwareMonitor.h"

 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
@@ -24,43 +22,26 @@
 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
 \*---------------------------------------------------------*/
-#define ALIENWARE_AW3423DWF_PID                     0x100E
 #define ALIENWARE_AW3225QF_PID                      0x1013
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA

-/******************************************************************************************\
-*                                                                                          *
-*   AlienwareAW3423DWFControllerDetect                                                     *
-*                                                                                          *
-*       Tests the USB address to see if an Alienware AW3423DWF exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
-        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
        RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

-REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
 REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);
@@ -46,6 +46,8 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC

 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -57,7 +59,6 @@ void RGBController_AlienwareMonitor::SetupZones()
    Logo.leds_min           = 1;
    Logo.leds_max           = 1;
    Logo.leds_count         = 1;
-    Logo.matrix_map         = NULL;
    zones.push_back(Logo);

    led Logo_LED;
@@ -71,7 +72,6 @@ void RGBController_AlienwareMonitor::SetupZones()
    Number.leds_min         = 1;
    Number.leds_max         = 1;
    Number.leds_count       = 1;
-    Number.matrix_map       = NULL;
    zones.push_back(Number);

    led Number_LED;
@@ -85,7 +85,6 @@ void RGBController_AlienwareMonitor::SetupZones()
    PowerButton.leds_min    = 1;
    PowerButton.leds_max    = 1;
    PowerButton.leds_count  = 1;
-    PowerButton.matrix_map  = NULL;
    zones.push_back(PowerButton);

    led PowerButton_LED;
@@ -96,11 +95,6 @@ void RGBController_AlienwareMonitor::SetupZones()
    SetupColors();
 }

-void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
 {
    /*-----------------------------------------------------*\
@@ -119,17 +113,17 @@ void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
    {
        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
        {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
        }
    }
 }

-void RGBController_AlienwareMonitor::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AlienwareMonitor::UpdateSingleLED(int led)
+void RGBController_AlienwareMonitor::DeviceUpdateSingleLED(int led)
 {
    unsigned char red = RGBGetRValue(colors[led]);
    unsigned char grn = RGBGetGValue(colors[led]);
@@ -21,11 +21,10 @@ RGBController_AlienwareMonitor(AlienwareMonitorController* controller_ptr);
    ~RGBController_AlienwareMonitor();

    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -9,10 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
-#include "AnnePro2Controller.h"
-#include "RGBController_AnnePro2.h"
 #include <hidapi.h>
+#include "AnnePro2Controller.h"
+#include "DetectionManager.h"
+#include "RGBController_AnnePro2.h"

 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -29,25 +29,22 @@
 #define ANNE_PRO_2_PID_4                            0xA293
 #define ANNE_PRO_2_PID_5                            0xA297

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAnnePro2Controllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);
@@ -144,6 +144,8 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt

 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -164,14 +166,7 @@ void RGBController_AnnePro2::SetupZones()

        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 5;
-            new_zone.matrix_map->width  = 14;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map.Set(5, 14, (unsigned int *)&matrix_map);
        }

        zones.push_back(new_zone);
@@ -190,13 +185,6 @@ void RGBController_AnnePro2::SetupZones()
    SetupColors();
 }

-void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AnnePro2::DeviceUpdateLEDs()
 {
    const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
@@ -228,12 +216,12 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
    controller->SendDirect(frame_buf_length, frame_buf);
 }

-void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AnnePro2::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
+void RGBController_AnnePro2::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -21,11 +21,10 @@ public:
    ~RGBController_AnnePro2();

    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -10,39 +10,38 @@
 \*---------------------------------------------------------*/

 #include <vector>
-#include "Detector.h"
 #include "ArcticController.h"
-#include "RGBController_Arctic.h"
+#include "DetectionManager.h"
 #include "find_usb_serial_port.h"
+#include "RGBController_Arctic.h"

 #define CH341_VID   0x1A86
 #define CH341_PID   0x7523

-void DetectArcticControllers()
+DetectedControllers DetectArcticControllers()
 {
-    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
+    DetectedControllers         detected_controllers;
+    std::vector<std::string>    ports;
+
+    ports = find_usb_serial_port(CH341_VID, CH341_PID);

    for(unsigned int device = 0; device < ports.size(); device++)
    {
-        ArcticController *controller = new ArcticController(*ports[device]);
+        ArcticController *controller = new ArcticController(ports[device]);

        if(controller->IsPresent())
        {
            RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
        }
        else
        {
            delete controller;
        }
-
-        delete ports[device];
    }
+
+    return(detected_controllers);
 }

 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1A86, 0x7523 )                  |
-\*---------------------------------------------------------------------------------------------------------*/
+REGISTER_CUSTOM_UDEV_RULE(arctic, "Arctic RGB controller", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1a86\", ATTRS{idProduct}==\"7523\", TAG+=\"uaccess\", TAG+=\"Arctic_RGB_controller\"");
@@ -55,6 +55,8 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)

 RGBController_Arctic::~RGBController_Arctic()
 {
+    Shutdown();
+
    keepalive_thread_run = false;
    keepalive_thread.join();
    delete controller;
@@ -70,7 +72,6 @@ void RGBController_Arctic::SetupZones()
        LedZone.leds_count  = 1;
        LedZone.leds_min    = 1;
        LedZone.leds_max    = 1;
-        LedZone.matrix_map  = nullptr;

        led Led;
        Led.name    = LedZone.name + " LED";
@@ -83,13 +84,6 @@ void RGBController_Arctic::SetupZones()
    SetupColors();
 }

-void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_Arctic::DeviceUpdateLEDs()
 {
    last_update_time = std::chrono::steady_clock::now();
@@ -97,12 +91,12 @@ void RGBController_Arctic::DeviceUpdateLEDs()
    controller->SetChannels(colors);
 }

-void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
+void RGBController_Arctic::DeviceUpdateZoneLEDs(int /* zone */)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_Arctic::UpdateSingleLED(int /* led */)
+void RGBController_Arctic::DeviceUpdateSingleLED(int /* led */)
 {
    DeviceUpdateLEDs();
 }
@@ -123,7 +117,7 @@ void RGBController_Arctic::KeepaliveThreadFunction()
        sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
        if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
        {
-            UpdateLEDs();   // Already protected thru a device update thread
+            UpdateLEDsInternal();   // Already protected thru a device update thread
            std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
        }
        else
@@ -25,11 +25,9 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AresonController.h"
 #include "RGBController_Areson.h"

@@ -28,17 +28,22 @@
 #define REDRAGON_M914_PID                              0xFA7B
 #define REDRAGON_M914_WIRELESS_PID                     0xFA7C

-void DetectAresonControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAresonControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);

    if(dev)
    {
        AresonController*     controller      = new AresonController(dev, *info, name);
        RGBController_Areson* rgb_controller  = new RGBController_Areson(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
+
+    return(detected_controllers);
 }

 REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro (Wireless)",     DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_PRO_WIRELESS_PID,      1, 0xFF02, 2);
@@ -125,6 +125,8 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)

 RGBController_Areson::~RGBController_Areson()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -137,7 +139,6 @@ void RGBController_Areson::SetupZones()
    new_zone.leds_min   = 1;
    new_zone.leds_max   = 1;
    new_zone.leds_count = 1;
-    new_zone.matrix_map = nullptr;

    zones.emplace_back(new_zone);

@@ -150,24 +151,17 @@ void RGBController_Areson::SetupZones()
    SetupColors();
 }

-void RGBController_Areson::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_Areson::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_Areson::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Areson::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateMode();
 }

-void RGBController_Areson::UpdateSingleLED(int /*led*/)
+void RGBController_Areson::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateMode();
 }
@@ -21,11 +21,10 @@ public:
    ~RGBController_Areson();

    void SetupZones();
-    void ResizeZone(int zone, int new_size);

    void DeviceUpdateLEDs();
-    void UpdateZoneLEDs(int zone);
-    void UpdateSingleLED(int led);
+    void DeviceUpdateZoneLEDs(int zone);
+    void DeviceUpdateSingleLED(int led);

    void DeviceUpdateMode();

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------*\
+| AsusAuraCoreControllerDetect.cpp                          |
+|                                                           |
+|   Detector for ASUS ROG Aura Core                         |
+|                                                           |
+|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "AsusAuraCoreController.h"
+#include "DetectionManager.h"
+#include "RGBController_AsusAuraCore.h"
+
+#define AURA_CORE_VID                   0x0B05
+
+DetectedControllers DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AuraCoreController*     controller                  = new AuraCoreController(dev, info->path);
+        RGBController_AuraCore* rgb_controller              = new RGBController_AuraCore(controller);
+
+        if(rgb_controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+        {
+            detected_controllers.push_back(rgb_controller);
+        }
+        else
+        {
+            delete rgb_controller;
+        }
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1854);
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
+REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
@@ -45,6 +45,13 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
    SetupZones();
 }

+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_AuraCore::SetupKeyboard()
 {
    name                    = "ASUS Aura Keyboard";
@@ -170,11 +177,6 @@ void RGBController_AuraCore::SetupGA15DH()
    modes.push_back(Static);
 }

-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupZones()
 {
    zone auraZone;
@@ -186,7 +188,6 @@ void RGBController_AuraCore::SetupZones()
        auraZone.leds_min   = 4;
        auraZone.leds_max   = 4;
        auraZone.leds_count = 4;
-        auraZone.matrix_map = NULL;
    }
    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
    {
@@ -195,7 +196,6 @@ void RGBController_AuraCore::SetupZones()
        auraZone.leds_min   = 20;
        auraZone.leds_max   = 20;
        auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
    }
    else
    {
@@ -215,19 +215,12 @@ void RGBController_AuraCore::SetupZones()
    SetupColors();
 }

-void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraCore::DeviceUpdateLEDs()
 {
-    UpdateZoneLEDs(0);
+    DeviceUpdateZoneLEDs(0);
 }

-void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraCore::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
    {
@@ -256,16 +249,16 @@ void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
    {
        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
        {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
        }
    }
    else
    {
-        UpdateSingleLED(0);
+        DeviceUpdateSingleLED(0);
    }
 }

-void RGBController_AuraCore::UpdateSingleLED(int led)
+void RGBController_AuraCore::DeviceUpdateSingleLED(int led)
 {
    unsigned char speed = 0xFF;
    unsigned char red   = 0;
@@ -24,11 +24,9 @@ public:
    void        SetupGA15DH();
    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

--- a/Show More
+++ b/Show More