Test Razer Blade Stealth Late 2020

2022-07-11 22:23:14 -05:00
1163 changed files with 30939 additions and 101575 deletions
@@ -6,8 +6,6 @@ OpenRGB
 openrgb
 OpenRGB-x86_64.AppImage
 60-openrgb.rules
-debian/changelog
-fedora/OpenRGB.spec

 # Directories
 .build/
@@ -118,3 +116,4 @@ compile_commands.json

 # Generated i18n files
 *.qm
+
@@ -43,7 +43,6 @@ before_script:
    name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
    paths:
    - ./*.md
-    - Supported Devices.csv
    exclude:
    - README.md
    - CONTRIBUTING.md
@@ -52,9 +51,6 @@ before_script:
  rules:
  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true

 #-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
@@ -75,13 +71,6 @@ before_script:
    - README.md
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
@@ -109,10 +98,9 @@ before_script:
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
  stage: build
  script:
-  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
  - mv -v ../openrgb*.deb ./

  artifacts:
@@ -120,16 +108,9 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
 #-----------------------------------------------------------------------#
@@ -138,10 +119,9 @@ before_script:
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
  stage: build
  script:
-  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
  - mv -v ../openrgb*.deb ./

  artifacts:
@@ -149,16 +129,9 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bullseye 32-bit Build Target                      #
 #-----------------------------------------------------------------------#
@@ -167,10 +140,9 @@ before_script:
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
  stage: build
  script:
-  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
+  - rm -v ../openrgb-dbgsym*.deb
  - mv -v ../openrgb*.deb ./

  artifacts:
@@ -178,16 +150,9 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (.deb) Debian Bullseye 64-bit Build Target                      #
 #-----------------------------------------------------------------------#
@@ -196,65 +161,6 @@ before_script:
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
  stage: build
  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.*deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.*deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm 32-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 32 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage --target-arch i386 -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm 64-bit Build Target                      #
-#-----------------------------------------------------------------------#
-"Linux 64 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
  - dpkg-buildpackage -us -B
  - rm -v ../openrgb-dbgsym*.deb
@@ -268,13 +174,6 @@ before_script:
    - openrgb-dbgsym*.deb
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (.rpm, f35) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
@@ -284,7 +183,6 @@ before_script:
  script:
  - dnf install rpmdevtools dnf-plugins-core -y
  - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
  - ls /root/
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -303,13 +201,6 @@ before_script:
    - openrgb*.rpm
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Linux (.rpm, f36) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
@@ -317,9 +208,8 @@ before_script:
  image: fedora:36
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
  - rpmdev-setuptree
-  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
  - ls /root/
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
@@ -338,13 +228,6 @@ before_script:
    - openrgb*.rpm
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Debian 32 Buster test                                                 #
 #-----------------------------------------------------------------------#
@@ -355,6 +238,7 @@ before_script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
  - "Linux 32 .deb (Debian Buster)"
@@ -371,6 +255,7 @@ before_script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
  - "Linux 64 .deb (Debian Buster)"
@@ -387,6 +272,7 @@ before_script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
  - "Linux 32 .deb (Debian Bullseye)"
@@ -403,44 +289,13 @@ before_script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
  - "Linux 64 .deb (Debian Bullseye)"
  needs:
  - "Linux 64 .deb (Debian Bullseye)"

-#-----------------------------------------------------------------------#
-# Debian 32 Bookworm test                                               #
-#-----------------------------------------------------------------------#
-"Debian 32 Bookworm":
-  image: i386/debian:bookworm
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 32 .deb (Debian Bookworm)"
-  needs:
-  - "Linux 32 .deb (Debian Bookworm)"
-
-#-----------------------------------------------------------------------#
-# Debian 64 Bookworm test                                               #
-#-----------------------------------------------------------------------#
-"Debian 64 Bookworm":
-  image: amd64/debian:bookworm
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Bookworm)"
-  needs:
-  - "Linux 64 .deb (Debian Bookworm)"
-
 #-----------------------------------------------------------------------#
 # Ubuntu 64 20.04LTS test                                               #
 #-----------------------------------------------------------------------#
@@ -451,6 +306,7 @@ before_script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
  - "Linux 64 .deb (Debian Buster)"
@@ -458,20 +314,21 @@ before_script:
  - "Linux 64 .deb (Debian Buster)"

 #-----------------------------------------------------------------------#
-# Ubuntu 64 22.04 test                                                  #
+# Ubuntu 64 21.10 test                                                  #
 #-----------------------------------------------------------------------#
-"Ubuntu 64 22.04LTS":
-  image: ubuntu:jammy
+"Ubuntu 64 21.10":
+  image: ubuntu:impish
  stage: test
  script:
  - apt update
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
+  - openrgb -l
  - apt remove -y openrgb
  dependencies:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bullseye)"
  needs:
-  - "Linux 64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bullseye)"

 #-----------------------------------------------------------------------#
 # Fedora 64 v35 test                                                    #
@@ -482,6 +339,7 @@ before_script:
  script:
  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
+  - openrgb -l
  - yum -y remove openrgb
  dependencies:
  - "Linux 64 f35 rpm"
@@ -497,6 +355,7 @@ before_script:
  script:
  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
+  - openrgb -l
  - yum -y remove openrgb
  dependencies:
  - "Linux 64 f36 rpm"
@@ -528,9 +387,9 @@ before_script:
  - mkdir _qt
  - mkdir _qt_download
  - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
  - _fold_final_

  - _fold_start_ 'extracting the downloaded qt binaries'
@@ -546,6 +405,10 @@ before_script:
  - Pop-Location
  - _fold_final_

+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
  - mkdir _build; cd _build
  - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
@@ -570,17 +433,8 @@ before_script:
    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 32-bit'
-    exclude:
-    - 'OpenRGB Windows 32-bit\*.qm'
    expire_in: 30 days

-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
 #-----------------------------------------------------------------------#
 # Windows (64-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
@@ -606,9 +460,9 @@ before_script:
  - mkdir _qt
  - mkdir _qt_download
  - Push-Location _qt_download
-  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
-  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
-  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - curl.exe -LJ -o qt-base.7z  'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
+  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
  - _fold_final_

  - _fold_start_ 'extracting the downloaded qt binaries'
@@ -624,6 +478,10 @@ before_script:
  - Pop-Location
  - _fold_final_

+  - _fold_start_ 'Generate qm files'
+  - .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
+  - _fold_final_
+
  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
  - mkdir _build; cd _build
  - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
@@ -648,8 +506,6 @@ before_script:
    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 64-bit'
-    exclude:
-    - 'OpenRGB Windows 64-bit\*.qm'
    expire_in: 30 days

 #-----------------------------------------------------------------------#
@@ -676,9 +532,6 @@ before_script:
    when: on_success
  - if: '$BUILD_MACOS =~ /.+/'
    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true

 "MacOS Intel":
  tags:
@@ -701,6 +554,3 @@ before_script:
    when: on_success
  - if: '$BUILD_MACOS =~ /.+/'
    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
@@ -10,8 +10,8 @@ CODEOWNERS @Calcprogrammer1
 #-----------------------------------------------------------------------------#
 [Controllers]
 /Controllers/AMDWraithPrismController/
+/Controllers/ASRockPolychromeSMBusController/
 /Controllers/ASRockPolychromeUSBController/
-/Controllers/ASRockSMBusController/
 /Controllers/AlienwareController/
 /Controllers/AlienwareKeyboardController/
 /Controllers/AnnePro2Controller/
@@ -40,8 +40,8 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EKController/                                  @Dr_No
 /Controllers/ENESMBusController/
 /Controllers/EVGAAmpereGPUController/                       @TheRogueZeta
-/Controllers/EVGAGP102GPUController/
-/Controllers/EVGAPascalGPUController/
+/Controllers/EVGAGP102GPUController/                        
+/Controllers/EVGAPascalGPUController/                       
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/
@@ -101,7 +102,5 @@ CODEOWNERS @Calcprogrammer1
 #   that is an exception to the above should be explicitly named here         #
 #-----------------------------------------------------------------------------#
 [Controllers]
-/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp          @TheRogueZeta
-/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h            @TheRogueZeta
-/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp      @TheRogueZeta
-/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h        @TheRogueZeta
+/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp            @TheRogueZeta
+/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h              @TheRogueZeta
@@ -1,10 +0,0 @@
-{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
-    "recommendations": [
-        "EditorConfig.EditorConfig"
-    ],
-    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
-    ]
-}
@@ -12,16 +12,6 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Follow the Style Guidelines below when making your code changes.
 * Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.

-### Pipelines, Shared Runners and Quotas
-
-Since mid 2022 Gitlab has limited the usage of shared runners to all projects and whilst quite geneorous quotas are allowed
- for open source projects it is possible to exhaust them. With that in mind not all jobs within the pipeline build are
- triggered to automatically run with every push to your branch with the exception of the Windows 64bit and Linux Appimage 64bit
- jobs. If you need to test or share another build you can still start it manually from your pipeline queue.
- Once a merge request is created all architectures and platforms will be compiled to ensure that they are ready to merge.
-
-Please refer to the following link for [further information relating to minutes and quotas](https://docs.gitlab.com/ee/ci/pipelines/cicd_minutes.html).
-
 ## Style Guidelines

 OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake build system.  While OpenRGB does use C++, I am primarily a C programmer and prefer doing things "C Style" vs. C++ style.  C++'s object oriented programming features fit the needs of a program such as OpenRGB where there are many implementations of a single interface so I chose to write it in C++ over C.  Still, however, I prefer using C-style code where possible.  When making changes to existing code files, try to follow the existing style.  Merge requests that go out of their way to restyle code will not be accepted and will be sent back for rework.
@@ -3,6 +3,7 @@
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "LogManager.h"
 #include "RGBController.h"

 /*-----------------------------------------------------*\
@@ -30,5 +31,4 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
 }

 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
 REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
@@ -8,7 +8,6 @@
 \*---------------------------------------------------------------------*/

 #include "BloodyMouseController.h"
-#include "LogManager.h"

 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
@@ -9,6 +9,7 @@

 #include <string>
 #include <hidapi/hidapi.h>
+#include "LogManager.h"
 #include "RGBController.h"

 #pragma once
@@ -17,7 +18,6 @@
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W90_MAX_PID                          0x3666

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
@@ -25,19 +25,6 @@ static const mouse_layout w60_pro
    }
 };

-static const mouse_layout w90_max
-{
-    {
-        "Scroll Wheel", { 14 }
-    },
-    {
-        "Logo",         { 7 }
-    },
-    {
-        "Rear",         { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
-    }
-};
-
 static const mouse_layout mp_50rs
 {
    {
@@ -69,6 +56,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
            type                = DEVICE_TYPE_MOUSE;
    }

+    name                        = "BloodyMouse";
    vendor                      = "Bloody";
    description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
    serial                      = controller->GetSerial();
@@ -101,15 +89,11 @@ void RGBController_BloodyMouse::SetupZones()
    | Select layout from PID                            |
    \*-------------------------------------------------*/
    mouse_layout layout;
-
    switch(controller->GetPid())
    {
        case BLOODY_W60_PRO_PID:
            layout = w60_pro;
            break;
-        case BLOODY_W90_MAX_PID:
-            layout = w90_max;
-            break;
        case BLOODY_MP_50RS_PID:
            layout = mp_50rs;
            break;
@@ -184,6 +168,11 @@ void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_BloodyMouse::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_BloodyMouse::DeviceUpdateMode()
 {
    /*---------------------------------------------------------*\
@@ -9,6 +9,7 @@

 #pragma once
 #include <vector>
+#include "LogManager.h"
 #include "RGBController.h"
 #include "BloodyMouseController.h"

@@ -33,6 +34,7 @@ public:
    void                    UpdateZoneLEDs(int zone);
    void                    UpdateSingleLED(int led);

+    void                    SetCustomMode();
    void                    DeviceUpdateMode();

 private:
@@ -17,6 +17,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
    dev         = dev_handle;
    location    = path;

+    strcpy(device_name, "AMD Wraith Prism");
+
    current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
    current_fan_speed           = 0xFF;
    current_fan_random_color    = false;
@@ -31,6 +33,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
    current_ring_speed          = 0xFF;
    current_ring_direction      = false;
    current_ring_brightness     = 0xFF;
+
+    SendEnableCommand();
 }

 AMDWraithPrismController::~AMDWraithPrismController()
@@ -43,6 +47,11 @@ std::string AMDWraithPrismController::GetLocationString()
    return("HID: " + location);
 }

+char* AMDWraithPrismController::GetDeviceName()
+{
+    return device_name;
+}
+
 std::string AMDWraithPrismController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -59,6 +68,41 @@ std::string AMDWraithPrismController::GetSerialString()
    return(return_string);
 }

+std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x00,
+        0x40, 0x21, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    usb_buf[0x03] = channel;
+
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
+
+    ret_string.append((char *)&usb_buf[0x08]);
+
+    return(ret_string);
+}
+
 std::string AMDWraithPrismController::GetFirmwareVersionString()
 {
    std::string ret_string = "";
@@ -188,7 +232,7 @@ void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
    SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
 }

-void AMDWraithPrismController::SendEnableCommand(bool direct)
+void AMDWraithPrismController::SendEnableCommand()
 {
    unsigned char usb_buf[] =
    {
@@ -211,11 +255,6 @@ void AMDWraithPrismController::SendEnableCommand(bool direct)
        0x00, 0x00, 0x00, 0x00,
    };

-    if(direct)
-    {
-        usb_buf[0x02]   = 0x03;
-    }
-
    hid_write(dev, usb_buf, 65);
    hid_read(dev, usb_buf, 64);
 }
@@ -247,48 +286,6 @@ void AMDWraithPrismController::SendApplyCommand()
    hid_read(dev, usb_buf, 64);
 }

-void AMDWraithPrismController::SendDirectPacket
-    (
-    unsigned char   size,
-    unsigned char * led_ids,
-    RGBColor *      colors
-    )
-{
-    unsigned char usb_buf[] =
-    {
-        0x00,
-        0xC0, 0x01, size, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-    };
-
-    for(unsigned int led_idx = 0; led_idx < size; led_idx++)
-    {
-        unsigned int index  = led_idx * 4;
-
-        usb_buf[index + 5]  = led_ids[led_idx];
-        usb_buf[index + 6]  = RGBGetRValue(colors[led_idx]);
-        usb_buf[index + 7]  = RGBGetGValue(colors[led_idx]);
-        usb_buf[index + 8]  = RGBGetBValue(colors[led_idx]);
-    }
-
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-}
-
 void AMDWraithPrismController::SendEffectChannelUpdate
    (
    unsigned char effect_channel,
@@ -10,8 +10,6 @@
 #include <string>
 #include <hidapi/hidapi.h>

-#include "RGBController.h"
-
 #pragma once

 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -76,7 +74,6 @@ enum
    AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE       = 0x09, /* Chase effect channel         */
    AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL       = 0x0A, /* Swirl effect channel         */
    AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE       = 0x0B, /* Morse code effect channel    */
-    AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT      = 0xFF, /* Value for direct mode        */
 };

 enum
@@ -94,11 +91,29 @@ public:
    AMDWraithPrismController(hid_device* dev_handle, const char* path);
    ~AMDWraithPrismController();

+    char* GetDeviceName();
+
    std::string GetEffectChannelString(unsigned char channel);
    std::string GetFirmwareVersionString();
    std::string GetLocationString();
    std::string GetSerialString();

+    void SetRingEffectChannel(unsigned char channel);
+
+    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+    std::string             location;
+
    unsigned char           current_fan_mode;
    unsigned char           current_fan_speed;
    unsigned char           current_fan_brightness;
@@ -115,30 +130,10 @@ public:
    bool                    current_ring_direction;
    bool                    current_ring_random_color;

-    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
-    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
-    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
-    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
-
-    void SendDirectPacket
-        (
-        unsigned char   size,
-        unsigned char * led_ids,
-        RGBColor *      colors
-        );
-
-    void SendEnableCommand(bool direct);
+    void SendEnableCommand();

    void SendApplyCommand();

-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SetRingEffectChannel(unsigned char channel);
-
    void SendEffectChannelUpdate
        (
        unsigned char effect_channel,
@@ -33,29 +33,33 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
    description = "AMD Wraith Prism Device";
    version     = controller->GetFirmwareVersionString();
    location    = controller->GetLocationString();
+    /*-----------------------------------------------------*\
+    | Don't use HID serial string, it is inconsistent on my |
+    | Wraith Prism                                          |
+    \*-----------------------------------------------------*/
+    serial      = "";//controller->GetSerialString();

    mode Direct;
    Direct.name                 = "Direct";
-    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
+    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
    Direct.brightness_min       = 0;
-    Direct.brightness_max       = 0;
-    Direct.brightness           = 0;
+    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
+    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

    mode Breathing;
    Breathing.name              = "Breathing";
    Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
    Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
    Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
    Breathing.brightness_min    = 0;
    Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
    Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.color_mode        = MODE_COLORS_PER_LED;
    Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Breathing.colors.resize(3);
    modes.push_back(Breathing);

    mode ColorCycle;
@@ -100,29 +104,27 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
    mode Chase;
    Chase.name                  = "Chase";
    Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
    Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
    Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
    Chase.brightness_min        = 0;
    Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
    Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Chase.color_mode            = MODE_COLORS_PER_LED;
    Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Chase.colors.resize(3);
    modes.push_back(Chase);

    mode Swirl;
    Swirl.name                  = "Swirl";
    Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
    Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
    Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
    Swirl.brightness_min        = 0;
    Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
    Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Swirl.color_mode            = MODE_COLORS_PER_LED;
    Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    Swirl.colors.resize(3);
    modes.push_back(Swirl);

    SetupZones();
@@ -135,14 +137,6 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()

 void RGBController_AMDWraithPrism::SetupZones()
 {
-    /*---------------------------------------------------------*\
-    | LED maps                                                  |
-    \*---------------------------------------------------------*/
-    const unsigned int logo_leds[1] =   { 0x00 };
-    const unsigned int fan_leds[1] =    { 0x01 };
-    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
-                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
-
    /*---------------------------------------------------------*\
    | Set up zones                                              |
    \*---------------------------------------------------------*/
@@ -166,39 +160,27 @@ void RGBController_AMDWraithPrism::SetupZones()

    zone ring_zone;
    ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_LINEAR;
-    ring_zone.leds_min      = 14;
-    ring_zone.leds_max      = 14;
-    ring_zone.leds_count    = 14;
+    ring_zone.type          = ZONE_TYPE_SINGLE;
+    ring_zone.leds_min      = 1;
+    ring_zone.leds_max      = 1;
+    ring_zone.leds_count    = 1;
    ring_zone.matrix_map    = NULL;
    zones.push_back(ring_zone);

    /*---------------------------------------------------------*\
    | Set up LEDs                                               |
    \*---------------------------------------------------------*/
-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led logo_led;
-        logo_led.name = "Logo LED";
-        logo_led.value = logo_leds[led_idx];
-        leds.push_back(logo_led);
-    }
+    led logo_led;
+    logo_led.name = "Logo LED";
+    leds.push_back(logo_led);

-    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
-    {
-        led fan_led;
-        fan_led.name = "Fan LED";
-        fan_led.value = fan_leds[led_idx];
-        leds.push_back(fan_led);
-    }
+    led fan_led;
+    fan_led.name = "Fan LED";
+    leds.push_back(fan_led);

-    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
-    {
-        led ring_led;
-        ring_led.name = "Ring LED";
-        ring_led.value = ring_leds[led_idx];
-        leds.push_back(ring_led);
-    }
+    led ring_led;
+    ring_led.name = "Ring LED";
+    leds.push_back(ring_led);

    SetupColors();
 }
@@ -212,95 +194,73 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    controller->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    controller->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
+    controller->SetRingColor(red, grn, blu);
+}
+
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(zone == 0)
    {
-        unsigned char   led_ids[15];
-        RGBColor        color_buf[15];
-        unsigned int    leds_count = 0;
-
-        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
-        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
-            color_buf[leds_count]   = colors[led_idx];
-
-            leds_count++;
-
-            if(leds_count >= 15)
-            {
-                controller->SendDirectPacket(15, led_ids, color_buf);
-                leds_count = 0;
-            }
-        }
-
-        if(leds_count > 0)
-        {
-            controller->SendDirectPacket(leds_count, led_ids, color_buf);
-        }
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
-        unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
-        unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
        controller->SetLogoColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[1]);
-        grn = RGBGetGValue(modes[active_mode].colors[1]);
-        blu = RGBGetBValue(modes[active_mode].colors[1]);
+    }
+    else if(zone == 1)
+    {
        controller->SetFanColor(red, grn, blu);
-
-        red = RGBGetRValue(modes[active_mode].colors[2]);
-        grn = RGBGetGValue(modes[active_mode].colors[2]);
-        blu = RGBGetBValue(modes[active_mode].colors[2]);
+    }
+    else if(zone == 2)
+    {
        controller->SetRingColor(red, grn, blu);
    }
-    else
-    {
-        controller->SetLogoColor(0, 0, 0);
-        controller->SetFanColor(0, 0, 0);
-        controller->SetRingColor(0, 0, 0);
-    }
 }

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

-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
+void RGBController_AMDWraithPrism::SetCustomMode()
 {
-    DeviceUpdateLEDs();
+    active_mode = 0;
 }

 void RGBController_AMDWraithPrism::DeviceUpdateMode()
 {
    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);

+    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
+
    switch(modes[active_mode].value)
    {
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT:
-            controller->SendEnableCommand(true);
-            controller->SendApplyCommand();
-            break;
-
        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
            break;

        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
            break;

        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            controller->SendEnableCommand(false);
-            controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
            break;
@@ -308,15 +268,11 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
        default:
            if(random)
            {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
            }
            else
            {
-                controller->SendEnableCommand(false);
-                controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
            }
@@ -25,6 +25,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -1,211 +0,0 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.cpp                |
-|                                           |
-|  Driver for AOC Keyboard lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "AOCKeyboardController.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-using namespace std::chrono_literals;
-
-AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCKeyboardController::~AOCKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AOCKeyboardController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void AOCKeyboardController::SetLightingConfig
-    (
-    unsigned char   mode,
-    unsigned char   random,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    SendStartPacket();
-    std::this_thread::sleep_for(5ms);
-
-    SendLightingConfigPacket(mode, random, brightness, speed, direction, color_data);
-    std::this_thread::sleep_for(5ms);
-
-    SendEndPacket();
-    std::this_thread::sleep_for(10ms);
-}
-
-void AOCKeyboardController::SetCustom
-    (
-    RGBColor*       color_data
-    )
-{
-    SendStartPacket();
-    std::this_thread::sleep_for(5ms);
-
-    SendCustomPacket(color_data);
-    std::this_thread::sleep_for(5ms);
-
-    SendEndPacket();
-    std::this_thread::sleep_for(5ms);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCKeyboardController::SendStartPacket()
-{
-    unsigned char buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up start packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x09;
-    buf[0x01]   = 0x21;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendEndPacket()
-{
-    unsigned char buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up end packet                                     |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x09;
-    buf[0x01]   = 0x22;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendCustomPacket
-    (
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[361];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up custom lighting packet                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data                                    |
-    \*-----------------------------------------------------*/
-    for(unsigned int color_idx = 0; color_idx < 120; color_idx++)
-    {
-        buf[color_idx + 1]      = RGBGetRValue(color_data[color_idx]);
-        buf[color_idx + 121]    = RGBGetGValue(color_data[color_idx]);
-        buf[color_idx + 241]    = RGBGetBValue(color_data[color_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, sizeof(buf));
-}
-
-void AOCKeyboardController::SendLightingConfigPacket
-    (
-    unsigned char   mode,
-    unsigned char   random,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[117];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up lighting configuration packet                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x14;
-    buf[0x01]   = 0x01;
-
-    buf[0x06]   = mode;
-
-    buf[0x07 + (9 * mode) + 0] = RGBGetRValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 1] = RGBGetGValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 2] = RGBGetBValue(color_data[0]);
-    buf[0x07 + (9 * mode) + 3] = random;
-    buf[0x07 + (9 * mode) + 4] = direction;
-    buf[0x07 + (9 * mode) + 5] = speed;
-    buf[0x07 + (9 * mode) + 6] = brightness;
-
-    unsigned short checksum = 0x4A9E;
-
-    for(unsigned int buf_idx = 0; buf_idx < 115; buf_idx++)
-    {
-        checksum += buf[buf_idx];
-    }
-
-    buf[115]    = checksum & 0xFF;
-    buf[116]    = checksum >> 8;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 117);
-}
@@ -1,107 +0,0 @@
-/*-----------------------------------------*\
-|  AOCKeyboardController.h                  |
-|                                           |
-|  Definitions and types for AOC keyboard   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Keyboard Modes                        |
-\*-----------------------------------------*/
-enum
-{
-    AOC_KEYBOARD_MODE_STATIC                    = 0x00,     /* Static mode                  */
-    AOC_KEYBOARD_MODE_BREATHING                 = 0x01,     /* Breathing mode               */
-    AOC_KEYBOARD_MODE_REACT                     = 0x02,     /* React mode                   */
-    AOC_KEYBOARD_MODE_RIPPLE                    = 0x04,     /* Ripple mode                  */
-    AOC_KEYBOARD_MODE_RADAR                     = 0x05,     /* Radar mode                   */
-    AOC_KEYBOARD_MODE_FIREWORKS                 = 0x06,     /* Fireworks mode               */
-    AOC_KEYBOARD_MODE_BLINK                     = 0x07,     /* Blink mode                   */
-    AOC_KEYBOARD_MODE_WAVE                      = 0x08,     /* Wave mode                    */
-    AOC_KEYBOARD_MODE_CUSTOM                    = 0x09,     /* Custom mode                  */
-    AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES        = 0x0A,     /* Concentric Circles mode      */
-    AOC_KEYBOARD_MODE_W_WAVE                    = 0x0B,     /* W Wave mode                  */
-};
-
-enum
-{
-    AOC_KEYBOARD_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
-    AOC_KEYBOARD_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
-    AOC_KEYBOARD_SPEED_FAST                     = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_KEYBOARD_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
-    AOC_KEYBOARD_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
-    AOC_KEYBOARD_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
-    AOC_KEYBOARD_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_KEYBOARD_SINGLE_COLOR                   = 0x00,     /* Single color mode            */
-    AOC_KEYBOARD_RANDOM                         = 0x01,     /* Random color mode            */
-};
-
-enum
-{
-    AOC_KEYBOARD_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
-    AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
-};
-
-
-class AOCKeyboardController
-{
-public:
-    AOCKeyboardController(hid_device* dev_handle, const char* path);
-    ~AOCKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SetLightingConfig
-            (
-            unsigned char   mode,
-            unsigned char   random,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-    void SetCustom
-            (
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void SendStartPacket();
-    void SendEndPacket();
-
-    void SendCustomPacket
-            (
-            RGBColor*       color_data
-            );
-
-    void SendLightingConfigPacket
-            (
-            unsigned char   mode,
-            unsigned char   random,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-};
@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_AOCKeyboard.h"
-
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_GK500_PID                               0x1178
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
-        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
@@ -1,370 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCKeyboard.h"
-#include "KeyboardLayoutManager.h"
-
-/**--------------------------------------------------------------------*\
-    @name AOC Keyboard
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCKeyboardControllers
-    @comment
-\*---------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------*\
-|  AOC Keyboard KLM Layout                                              |
-\*---------------------------------------------------------------------*/
-layout_values aoc_keyboard_offset_values =
-{
-    {
-        /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   PRSC  SCLK  PSBK                         */
-            90,         92,   77,   63,   79,   94,   81,   96,   82,   83,   98,   40,   55,   85,  100,  104,
-        /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  INS   HOME  PGUP  NLCK   NP/   NP*  NP-  */
-            75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
-        /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
-            60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
-        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
-            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
-        /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
-            15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
-    },
-    {
-        /* Add more regional layout fixes here */
-    }
-};
-
-
-RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Keyboard Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "AOC Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = AOC_KEYBOARD_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Static.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Static.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_KEYBOARD_MODE_STATIC;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_KEYBOARD_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_KEYBOARD_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_KEYBOARD_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_KEYBOARD_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
-    Breathing.speed_max             = AOC_KEYBOARD_SPEED_FAST;
-    Breathing.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode React;
-    React.name                      = "React";
-    React.value                     = AOC_KEYBOARD_MODE_REACT;
-    React.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    React.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    React.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    React.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    React.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    React.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    React.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    React.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    React.colors_min                = 1;
-    React.colors_max                = 1;
-    React.colors.resize(1);
-    modes.push_back(React);
-
-    mode Ripple;
-    Ripple.name                     = "Ripple";
-    Ripple.value                    = AOC_KEYBOARD_MODE_RIPPLE;
-    Ripple.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Ripple.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Ripple.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Ripple.speed_min                = AOC_KEYBOARD_SPEED_SLOW;
-    Ripple.speed_max                = AOC_KEYBOARD_SPEED_FAST;
-    Ripple.speed                    = AOC_KEYBOARD_SPEED_MEDIUM;
-    Ripple.colors_min               = 1;
-    Ripple.colors_max               = 1;
-    Ripple.colors.resize(1);
-    modes.push_back(Ripple);
-
-    mode Radar;
-    Radar.name                      = "Radar";
-    Radar.value                     = AOC_KEYBOARD_MODE_RADAR;
-    Radar.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Radar.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Radar.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Radar.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Radar.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Radar.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    Radar.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    Radar.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    Radar.colors_min                = 1;
-    Radar.colors_max                = 1;
-    Radar.colors.resize(1);
-    modes.push_back(Radar);
-
-    mode Fireworks;
-    Fireworks.name                  = "Fireworks";
-    Fireworks.value                 = AOC_KEYBOARD_MODE_FIREWORKS;
-    Fireworks.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Fireworks.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Fireworks.brightness_min        = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Fireworks.brightness_max        = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Fireworks.brightness            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Fireworks.speed_min             = AOC_KEYBOARD_SPEED_SLOW;
-    Fireworks.speed_max             = AOC_KEYBOARD_SPEED_FAST;
-    Fireworks.speed                 = AOC_KEYBOARD_SPEED_MEDIUM;
-    Fireworks.colors_min            = 1;
-    Fireworks.colors_max            = 1;
-    Fireworks.colors.resize(1);
-    modes.push_back(Fireworks);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_KEYBOARD_MODE_BLINK;
-    Blink.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Blink.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    Blink.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    Blink.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    Blink.colors_min                = 1;
-    Blink.colors_max                = 1;
-    Blink.colors.resize(1);
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_KEYBOARD_MODE_WAVE;
-    Wave.flags                      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
-    Wave.brightness_min             = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_KEYBOARD_SPEED_SLOW;
-    Wave.speed_max                  = AOC_KEYBOARD_SPEED_FAST;
-    Wave.speed                      = AOC_KEYBOARD_SPEED_MEDIUM;
-    Wave.colors_min                 = 1;
-    Wave.colors_max                 = 1;
-    Wave.colors.resize(1);
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_KEYBOARD_MODE_WAVE;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_KEYBOARD_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_KEYBOARD_SPEED_FAST;
-    RainbowWave.speed               = AOC_KEYBOARD_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    mode ConcentricCircles;
-    ConcentricCircles.name          = "Concentric Circles";
-    ConcentricCircles.value         = AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES;
-    ConcentricCircles.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    ConcentricCircles.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    ConcentricCircles.brightness_min= AOC_KEYBOARD_BRIGHTNESS_OFF;
-    ConcentricCircles.brightness_max= AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    ConcentricCircles.brightness    = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    ConcentricCircles.speed_min     = AOC_KEYBOARD_SPEED_SLOW;
-    ConcentricCircles.speed_max     = AOC_KEYBOARD_SPEED_FAST;
-    ConcentricCircles.speed         = AOC_KEYBOARD_SPEED_MEDIUM;
-    ConcentricCircles.colors_min    = 1;
-    ConcentricCircles.colors_max    = 1;
-    ConcentricCircles.colors.resize(1);
-    modes.push_back(ConcentricCircles);
-
-    mode WWave;
-    WWave.name                      = "W Wave";
-    WWave.value                     = AOC_KEYBOARD_MODE_W_WAVE;
-    WWave.flags                     = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    WWave.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    WWave.brightness_min            = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    WWave.brightness_max            = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    WWave.brightness                = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    WWave.speed_min                 = AOC_KEYBOARD_SPEED_SLOW;
-    WWave.speed_max                 = AOC_KEYBOARD_SPEED_FAST;
-    WWave.speed                     = AOC_KEYBOARD_SPEED_MEDIUM;
-    WWave.colors_min                = 1;
-    WWave.colors_max                = 1;
-    WWave.colors.resize(1);
-    modes.push_back(WWave);
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_KEYBOARD_MODE_CUSTOM;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_KEYBOARD_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_KEYBOARD_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    SetupZones();
-};
-
-RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AOCKeyboard::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | 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);
-
-    /*---------------------------------------------------------*\
-    | Create LEDs for the Matrix zone                           |
-    |   Place keys in the layout to populate the matrix         |
-    \*---------------------------------------------------------*/
-    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-    {
-        led new_led;
-
-        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-        leds.push_back(new_led);
-    }
-
-    zones.push_back(new_zone);
-
-
-
-    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)
-    {
-        RGBColor color_buf[120];
-
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            color_buf[leds[led_idx].value] = colors[led_idx];
-        }
-
-        controller->SetCustom(&color_buf[0]);
-    }
-    else
-    {
-        DeviceUpdateMode();
-    }
-}
-
-void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCKeyboard::DeviceUpdateMode()
-{
-    unsigned char   aoc_direction   = AOC_KEYBOARD_DIRECTION_CLOCKWISE;
-    unsigned char   aoc_random      = AOC_KEYBOARD_SINGLE_COLOR;
-    RGBColor*       aoc_colors      = &colors[0];
-
-    if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-    {
-        aoc_direction = AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-    {
-        aoc_random = AOC_KEYBOARD_RANDOM;
-    }
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        aoc_colors = &modes[active_mode].colors[0];
-    }
-
-    controller->SetLightingConfig(modes[active_mode].value,
-                                  aoc_random,
-                                  modes[active_mode].brightness,
-                                  modes[active_mode].speed,
-                                  aoc_direction,
-                                  aoc_colors);
-}
@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCKeyboard.h              |
-|                                           |
-|  Generic RGB Interface for AOC keyboard   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 5/10/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCKeyboardController.h"
-
-class RGBController_AOCKeyboard : public RGBController
-{
-public:
-    RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr);
-    ~RGBController_AOCKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCKeyboardController*  controller;
-};
@@ -1,130 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMouseController.cpp                   |
-|                                           |
-|  Driver for AOC Mouse lighting controller |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMouseController.h"
-
-#include <cstring>
-
-AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCMouseController::~AOCMouseController()
-{
-    hid_close(dev);
-}
-
-std::string AOCMouseController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCMouseController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCMouseController::SendDirect
-    (
-    RGBColor*       color_data
-    )
-{
-    SendPacket(AOC_MOUSE_MODE_STATIC_SINGLE_COLOR,
-               AOC_MOUSE_BRIGHTNESS_HIGH,
-               AOC_MOUSE_SPEED_MEDIUM,
-               AOC_MOUSE_DIRECTION_CLOCKWISE,
-               color_data);
-}
-
-void AOCMouseController::SendPacket
-    (
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[60];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up packet                                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-    buf[0x01]   = 0x03;
-    buf[0x02]   = 0x01;
-    buf[0x03]   = mode;
-    buf[0x04]   = speed;
-    buf[0x05]   = brightness;
-    buf[0x06]   = direction;
-    buf[0x07]   = 0x01;
-    buf[0x08]   = 0x02;
-    buf[0x09]   = 0xFF;
-    buf[0x0D]   = 0x01;
-    buf[0x0E]   = 0x03;
-    buf[0x0F]   = 0xFF;
-    buf[0x10]   = 0x7F;
-    buf[0x13]   = 0x01;
-    buf[0x14]   = 0x04;
-    buf[0x17]   = 0xFF;
-    buf[0x19]   = 0x01;
-    buf[0x1A]   = 0x05;
-    buf[0x1C]   = 0xFF;
-    buf[0x1F]   = 0x01;
-    buf[0x20]   = 0x06;
-    buf[0x21]   = 0xFF;
-    buf[0x23]   = 0xFF;
-    buf[0x25]   = 0x01;
-    buf[0x26]   = 0x07;
-    buf[0x27]   = 0xFF;
-    buf[0x28]   = 0xFF;
-    buf[0x2C]   = 0x0A;
-    buf[0x2D]   = 0x0A;
-    buf[0x30]   = 0x14;
-    buf[0x31]   = 0x08;
-    buf[0x3A]   = 0x32;
-    buf[0x3B]   = 0x32;
-
-    /*-----------------------------------------------------*\
-    | Copy in color                                         |
-    \*-----------------------------------------------------*/
-    buf[0x33]   = RGBGetRValue(color_data[0]);
-    buf[0x34]   = RGBGetGValue(color_data[0]);
-    buf[0x35]   = RGBGetBValue(color_data[0]);
-
-    buf[0x36]   = RGBGetRValue(color_data[1]);
-    buf[0x37]   = RGBGetGValue(color_data[1]);
-    buf[0x38]   = RGBGetBValue(color_data[1]);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 60);
-}
@@ -1,80 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMouseController.h                     |
-|                                           |
-|  Definitions and types for AOC mouse      |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Mousemat Modes                        |
-|   Note: The 0x80 bit is the random flag   |
-\*-----------------------------------------*/
-enum
-{
-    AOC_MOUSE_MODE_STATIC_SINGLE_COLOR          = 0x00,     /* Static single color mode     */
-    AOC_MOUSE_MODE_STATIC_RANDOM                = 0x80,     /* Static random color mode     */
-    AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR       = 0x01,     /* Breathing single color mode  */
-    AOC_MOUSE_MODE_BREATHING_RANDOM             = 0x81,     /* Breathing random color mode  */
-    AOC_MOUSE_MODE_BLINK_SINGLE_COLOR           = 0x02,     /* Blink single color mode      */
-    AOC_MOUSE_MODE_BLINK_RANDOM                 = 0x82,     /* Blink random color mode      */
-    AOC_MOUSE_MODE_WAVE_SINGLE_COLOR            = 0x03,     /* Wave single color mode       */
-    AOC_MOUSE_MODE_WAVE_RANDOM                  = 0x83,     /* Wave random color mode       */
-    AOC_MOUSE_MODE_DPI                          = 0x04,     /* DPI mode                     */
-};
-
-enum
-{
-    AOC_MOUSE_SPEED_SLOW                        = 0x03,     /* Slowest speed                */
-    AOC_MOUSE_SPEED_MEDIUM                      = 0x02,     /* Medium speed                 */
-    AOC_MOUSE_SPEED_FAST                        = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_MOUSE_BRIGHTNESS_OFF                    = 0x00,     /* Lowest brightness (off)      */
-    AOC_MOUSE_BRIGHTNESS_LOW                    = 0x01,     /* Low brightness               */
-    AOC_MOUSE_BRIGHTNESS_MEDIUM                 = 0x02,     /* Medium brightness            */
-    AOC_MOUSE_BRIGHTNESS_HIGH                   = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_MOUSE_DIRECTION_CLOCKWISE               = 0x00,     /* Clockwise direction          */
-    AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE        = 0x01,     /* Counter-clockwise direction  */
-};
-
-class AOCMouseController
-{
-public:
-    AOCMouseController(hid_device* dev_handle, const char* path);
-    ~AOCMouseController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-            (
-            RGBColor*       color_data
-            );
-
-    void SendPacket
-            (
-            unsigned char   mode,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};
@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCMouseController.h"
-#include "RGBController.h"
-#include "RGBController_AOCMouse.h"
-
-/*-----------------------------------------------------*\
-| AOC Mousemat 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)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
-        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
-        rgb_controller->name                   = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);
@@ -1,215 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.cpp               |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCMouse.h"
-
-/**------------------------------------------------------------------*\
-    @name AOC Mouse
-    @category Mouse
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCMouseControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Mouse Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSE;
-    description = "AOC Mouse Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_MOUSE_MODE_STATIC_SINGLE_COLOR;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_MOUSE_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_MOUSE_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_MOUSE_MODE_STATIC_RANDOM;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_MOUSE_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_MOUSE_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_MOUSE_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_MOUSE_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_MOUSE_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.brightness_min        = AOC_MOUSE_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_MOUSE_SPEED_SLOW;
-    Breathing.speed_max             = AOC_MOUSE_SPEED_FAST;
-    Breathing.speed                 = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Breathing);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_MOUSE_MODE_BLINK_SINGLE_COLOR;
-    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_PER_LED;
-    Blink.brightness_min            = AOC_MOUSE_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_MOUSE_SPEED_SLOW;
-    Blink.speed_max                 = AOC_MOUSE_SPEED_FAST;
-    Blink.speed                     = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_MOUSE_MODE_WAVE_SINGLE_COLOR;
-    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_PER_LED;
-    Wave.brightness_min             = AOC_MOUSE_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_MOUSE_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_MOUSE_SPEED_SLOW;
-    Wave.speed_max                  = AOC_MOUSE_SPEED_FAST;
-    Wave.speed                      = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_MOUSE_MODE_WAVE_RANDOM;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_MOUSE_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_MOUSE_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_MOUSE_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_MOUSE_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_MOUSE_SPEED_FAST;
-    RainbowWave.speed               = AOC_MOUSE_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    mode DPI;
-    DPI.name                        = "DPI";
-    DPI.value                       = AOC_MOUSE_MODE_DPI;
-    DPI.flags                       = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    DPI.color_mode                  = MODE_COLORS_RANDOM;
-    DPI.brightness_min              = AOC_MOUSE_BRIGHTNESS_OFF;
-    DPI.brightness_max              = AOC_MOUSE_BRIGHTNESS_HIGH;
-    DPI.brightness                  = AOC_MOUSE_BRIGHTNESS_HIGH;
-    modes.push_back(DPI);
-
-    SetupZones();
-};
-
-RGBController_AOCMouse::~RGBController_AOCMouse()
-{
-    delete controller;
-}
-
-void RGBController_AOCMouse::SetupZones()
-{
-    zone logo_zone;
-    logo_zone.name                  = "Logo";
-    logo_zone.type                  = ZONE_TYPE_SINGLE;
-    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;
-    logo_led.name                   = "Logo";
-    leds.push_back(logo_led);
-
-    zone scroll_wheel_zone;
-    scroll_wheel_zone.name          = "Scroll Wheel";
-    scroll_wheel_zone.type          = ZONE_TYPE_SINGLE;
-    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;
-    scroll_wheel_led.name           = "Scroll Wheel";
-    leds.push_back(scroll_wheel_led);
-
-    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*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMouse::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AOC_MOUSE_MODE_STATIC_SINGLE_COLOR)
-    {
-        controller->SendDirect(&colors[0]);
-    }
-    else
-    {
-        unsigned char   aoc_direction   = AOC_MOUSE_DIRECTION_CLOCKWISE;
-        unsigned int    aoc_mode        = modes[active_mode].value;
-
-        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-        {
-            aoc_direction = AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(modes[active_mode].value)
-            {
-                case AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSE_MODE_BREATHING_RANDOM;
-                    break;
-
-                case AOC_MOUSE_MODE_BLINK_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSE_MODE_BLINK_RANDOM;
-                    break;
-            }
-        }
-
-        controller->SendPacket(aoc_mode,
-                               modes[active_mode].brightness,
-                               modes[active_mode].speed,
-                               aoc_direction,
-                               &colors[0]);
-    }
-}
@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMouse.h                 |
-|                                           |
-|  Generic RGB Interface for AOC mouse      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/20/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCMouseController.h"
-
-class RGBController_AOCMouse : public RGBController
-{
-public:
-    RGBController_AOCMouse(AOCMouseController* controller_ptr);
-    ~RGBController_AOCMouse();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCMouseController*  controller;
-};
@@ -1,112 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMousematController.cpp                |
-|                                           |
-|  Driver for AOC Mousemat lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "AOCMousematController.h"
-
-#include <cstring>
-
-AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AOCMousematController::~AOCMousematController()
-{
-    hid_close(dev);
-}
-
-std::string AOCMousematController::GetDeviceLocation()
-{
-    return("HID " + location);
-}
-
-std::string AOCMousematController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void AOCMousematController::SendDirect
-    (
-    RGBColor*       color_data
-    )
-{
-    SendPacket(AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR,
-               AOC_MOUSEMAT_BRIGHTNESS_HIGH,
-               AOC_MOUSEMAT_SPEED_MEDIUM,
-               AOC_MOUSEMAT_DIRECTION_CLOCKWISE,
-               color_data);
-}
-
-void AOCMousematController::SendPacket
-    (
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed,
-    unsigned char   direction,
-    RGBColor*       color_data
-    )
-{
-    unsigned char buf[32];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up packet                                         |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x20;
-    buf[0x01]   = brightness;
-    buf[0x02]   = speed;
-    buf[0x03]   = direction;
-    buf[0x04]   = 0x01;
-    buf[0x05]   = mode;
-    buf[0x09]   = 0xFF;
-    buf[0x0C]   = 0xFF;
-    buf[0x0D]   = 0x3F;
-    buf[0x0F]   = 0xFF;
-    buf[0x10]   = 0xFF;
-    buf[0x13]   = 0xFF;
-    buf[0x17]   = 0xFF;
-    buf[0x19]   = 0xFF;
-    buf[0x1A]   = 0xFF;
-    buf[0x1B]   = 0xFF;
-    buf[0x1D]   = 0xFF;
-    buf[0x1E]   = 0x32;
-    buf[0x1F]   = 0x32;
-
-    /*-----------------------------------------------------*\
-    | Copy in color                                         |
-    \*-----------------------------------------------------*/
-    buf[0x06]   = RGBGetRValue(color_data[0]);
-    buf[0x07]   = RGBGetGValue(color_data[0]);
-    buf[0x08]   = RGBGetBValue(color_data[0]);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 32);
-}
@@ -1,79 +0,0 @@
-/*-----------------------------------------*\
-|  AOCMousematController.h                  |
-|                                           |
-|  Definitions and types for AOC mousemat   |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*-----------------------------------------*\
-| AOC Mousemat Modes                        |
-|   Note: The 0x80 bit is the random flag   |
-\*-----------------------------------------*/
-enum
-{
-    AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR       = 0x00,     /* Static single color mode     */
-    AOC_MOUSEMAT_MODE_STATIC_RANDOM             = 0x80,     /* Static random color mode     */
-    AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR    = 0x01,     /* Breathing single color mode  */
-    AOC_MOUSEMAT_MODE_BREATHING_RANDOM          = 0x81,     /* Breathing random color mode  */
-    AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR        = 0x02,     /* Blink single color mode      */
-    AOC_MOUSEMAT_MODE_BLINK_RANDOM              = 0x82,     /* Blink random color mode      */
-    AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR         = 0x03,     /* Wave single color mode       */
-    AOC_MOUSEMAT_MODE_WAVE_RANDOM               = 0x83,     /* Wave random color mode       */
-};
-
-enum
-{
-    AOC_MOUSEMAT_SPEED_SLOW                     = 0x03,     /* Slowest speed                */
-    AOC_MOUSEMAT_SPEED_MEDIUM                   = 0x02,     /* Medium speed                 */
-    AOC_MOUSEMAT_SPEED_FAST                     = 0x01,     /* Fastest speed                */
-};
-
-enum
-{
-    AOC_MOUSEMAT_BRIGHTNESS_OFF                 = 0x00,     /* Lowest brightness (off)      */
-    AOC_MOUSEMAT_BRIGHTNESS_LOW                 = 0x01,     /* Low brightness               */
-    AOC_MOUSEMAT_BRIGHTNESS_MEDIUM              = 0x02,     /* Medium brightness            */
-    AOC_MOUSEMAT_BRIGHTNESS_HIGH                = 0x03,     /* Highest brightness           */
-};
-
-enum
-{
-    AOC_MOUSEMAT_DIRECTION_CLOCKWISE            = 0x00,     /* Clockwise direction          */
-    AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE     = 0x01,     /* Counter-clockwise direction  */
-};
-
-class AOCMousematController
-{
-public:
-    AOCMousematController(hid_device* dev_handle, const char* path);
-    ~AOCMousematController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-            (
-            RGBColor*       color_data
-            );
-
-    void SendPacket
-            (
-            unsigned char   mode,
-            unsigned char   brightness,
-            unsigned char   speed,
-            unsigned char   direction,
-            RGBColor*       color_data
-            );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-};
@@ -1,34 +0,0 @@
-#include "Detector.h"
-#include "AOCMousematController.h"
-#include "RGBController.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)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
-        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);
@@ -1,192 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.cpp            |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController_AOCMousemat.h"
-
-/**------------------------------------------------------------------*\
-    @name AOC Mousemat
-    @category Mousemat
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAOCMousematControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "AOC Mousemat Device";
-    vendor      = "AOC";
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = "AOC Mousemat Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    Direct.brightness_min           = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Direct.brightness_max           = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Direct.brightness               = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    modes.push_back(Direct);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name              = "Spectrum Cycle";
-    SpectrumCycle.value             = AOC_MOUSEMAT_MODE_STATIC_RANDOM;
-    SpectrumCycle.flags             = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.color_mode        = MODE_COLORS_RANDOM;
-    SpectrumCycle.brightness_min    = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    SpectrumCycle.brightness_max    = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    SpectrumCycle.brightness        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    SpectrumCycle.speed_min         = AOC_MOUSEMAT_SPEED_SLOW;
-    SpectrumCycle.speed_max         = AOC_MOUSEMAT_SPEED_FAST;
-    SpectrumCycle.speed             = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(SpectrumCycle);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.brightness_min        = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Breathing.brightness_max        = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Breathing.brightness            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Breathing.speed_min             = AOC_MOUSEMAT_SPEED_SLOW;
-    Breathing.speed_max             = AOC_MOUSEMAT_SPEED_FAST;
-    Breathing.speed                 = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Breathing);
-
-    mode Blink;
-    Blink.name                      = "Flashing";
-    Blink.value                     = AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR;
-    Blink.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Blink.color_mode                = MODE_COLORS_PER_LED;
-    Blink.brightness_min            = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Blink.brightness_max            = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Blink.brightness                = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Blink.speed_min                 = AOC_MOUSEMAT_SPEED_SLOW;
-    Blink.speed_max                 = AOC_MOUSEMAT_SPEED_FAST;
-    Blink.speed                     = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Blink);
-
-    mode Wave;
-    Wave.name                       = "Wave";
-    Wave.value                      = AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR;
-    Wave.flags                      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode                 = MODE_COLORS_PER_LED;
-    Wave.brightness_min             = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    Wave.brightness_max             = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Wave.brightness                 = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    Wave.speed_min                  = AOC_MOUSEMAT_SPEED_SLOW;
-    Wave.speed_max                  = AOC_MOUSEMAT_SPEED_FAST;
-    Wave.speed                      = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(Wave);
-
-    mode RainbowWave;
-    RainbowWave.name                = "Rainbow Wave";
-    RainbowWave.value               = AOC_MOUSEMAT_MODE_WAVE_RANDOM;
-    RainbowWave.flags               = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    RainbowWave.color_mode          = MODE_COLORS_RANDOM;
-    RainbowWave.brightness_min      = AOC_MOUSEMAT_BRIGHTNESS_OFF;
-    RainbowWave.brightness_max      = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    RainbowWave.brightness          = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
-    RainbowWave.speed_min           = AOC_MOUSEMAT_SPEED_SLOW;
-    RainbowWave.speed_max           = AOC_MOUSEMAT_SPEED_FAST;
-    RainbowWave.speed               = AOC_MOUSEMAT_SPEED_MEDIUM;
-    modes.push_back(RainbowWave);
-
-    SetupZones();
-};
-
-RGBController_AOCMousemat::~RGBController_AOCMousemat()
-{
-    delete controller;
-}
-
-void RGBController_AOCMousemat::SetupZones()
-{
-    zone mousemat_zone;
-    mousemat_zone.name          = "Mousemat";
-    mousemat_zone.type          = ZONE_TYPE_SINGLE;
-    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;
-    mousemat_led.name           = "Mousemat";
-    leds.push_back(mousemat_led);
-
-    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*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AOCMousemat::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR)
-    {
-        controller->SendDirect(&colors[0]);
-    }
-    else
-    {
-        unsigned char   aoc_direction   = AOC_MOUSEMAT_DIRECTION_CLOCKWISE;
-        unsigned int    aoc_mode        = modes[active_mode].value;
-
-        if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
-        {
-            aoc_direction = AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            switch(modes[active_mode].value)
-            {
-                case AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSEMAT_MODE_BREATHING_RANDOM;
-                    break;
-
-                case AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR:
-                    aoc_mode = AOC_MOUSEMAT_MODE_BLINK_RANDOM;
-                    break;
-            }
-        }
-
-        controller->SendPacket(aoc_mode,
-                               modes[active_mode].brightness,
-                               modes[active_mode].speed,
-                               aoc_direction,
-                               &colors[0]);
-    }
-}
@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AOCMousemat.h              |
-|                                           |
-|  Generic RGB Interface for AOC mousemat   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/15/2023   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AOCMousematController.h"
-
-class RGBController_AOCMousemat : public RGBController
-{
-public:
-    RGBController_AOCMousemat(AOCMousematController* controller_ptr);
-    ~RGBController_AOCMousemat();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AOCMousematController*  controller;
-};
@@ -5,38 +5,21 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/
-#include <cstring>
-#include <stdio.h>

 #include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
 #include "ASRockPolychromeUSBController.h"
+#include <cstring>
+#include <stdio.h>
 #include "dependencies/dmiinfo.h"

 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
 #define POLYCHROME_USB_WRITE_HEADER     0x15
 #define POLYCHROME_USB_SET_ZONE         0x10
-#define POLYCHROME_USB_INITIAL_CHUNK    0xE3
-#define POLYCHROME_USB_SEND_CHUNK       0xE4
 #define POLYCHROME_USB_INIT             0xA4
 #define POLYCHROME_USB_COMMIT           0x12

-const char* polychrome_USB_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Addressable Header 1",
-    "Addressable Header 2",
-    "PCH",
-    "IO Cover",
-    "PCB",
-    "Addressable Header 3/Audio",
-};
-
 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
 {
    DMIInfo       dmi;
@@ -77,7 +60,7 @@ std::string PolychromeUSBController::GetSerialString()
    {
        return("");
    }
-
+    
    std::wstring return_wstring = serial_string;
    std::string return_string(return_wstring.begin(), return_wstring.end());

@@ -87,64 +70,19 @@ std::string PolychromeUSBController::GetSerialString()
 void PolychromeUSBController::SetDeviceInfo()
 {
    PolychromeDeviceInfo newdev_info;
-
    ReadConfigTables();

-    /*--------------------------------------------------*\
-    | Read settings to check for configured RGSwap       |
-    \*--------------------------------------------------*/
-    const std::string detector_name     = "ASRock Polychrome USB";
-    const std::string json_rgswap       = "RGSwap";
-    SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
-    json device_settings                = settings_manager->GetSettings(detector_name);
-
-    /*---------------------------------------------------------*\
-    | Get RGSwap settings from the settings manager             |
-    | If RGSwap settings are not found then write them out      |
-    | Onboard leds are set to their existing values,            |
-    | Addressable RGB and RGB headers are set to false          |
-    \*---------------------------------------------------------*/
-    if(!device_settings.contains(json_rgswap))
-    {
-        device_settings[json_rgswap][polychrome_USB_zone_names[0]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[1]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[2]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[3]] = false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[4]] = ((configtable[8] >> 4) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[5]] = ((configtable[8] >> 5) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[6]] = ((configtable[8] >> 6) & 1) ? true : false;
-        device_settings[json_rgswap][polychrome_USB_zone_names[7]] = false;
-
-        settings_manager->SetSettings(detector_name, device_settings);
-        settings_manager->SaveSettings();
-    }
-    else
-    {
-        for(std::size_t idx = 0; idx < 8; idx++)
-        {
-            if(device_settings[json_rgswap].contains(polychrome_USB_zone_names[idx]))
-            {
-                rgswapconfig[idx] = device_settings[json_rgswap][polychrome_USB_zone_names[idx]];
-            }
-        }
-    }
-
-    bool rgswap_final[8] = {0};
-
    for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
    {
-        if(configtable[zonecnt] == 0x1E || !((configtable[9] >> zonecnt) & 1))
+        if(configtable[zonecnt] == 0x1E)
        {
 			/*-----------------------------------------------------------------------*\
 			| If we don't have this device type (0x1E) we will skip it and continue.  |
-            | Or if the device is not available we skip it and continue               |
 			\*-----------------------------------------------------------------------*/
            continue;
        }

        newdev_info.num_leds = configtable[zonecnt];
-        newdev_info.rgswap = ((configtable[8] >> zonecnt) & 1) || rgswapconfig[zonecnt];
-        rgswap_final[zonecnt] = newdev_info.rgswap;

 		/*--------------------------------------------------------------------------------------------------*\
 		| We will need to know what zone type this is, so that we can look up the name and make calls later. |
@@ -158,11 +96,6 @@ void PolychromeUSBController::SetDeviceInfo()
            \*-----------------------------------------*/
            case POLYCHROME_USB_ZONE_ARGB1:
            case POLYCHROME_USB_ZONE_ARGB2:
-            /*---------------------------------------------*\
-            | The last led channel is allocated to a       |
-            | third ARGB header on some newer motherboards |
-            \*---------------------------------------------*/
-            case POLYCHROME_USB_ZONE_AUDIO:
                newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
                break;

@@ -172,9 +105,10 @@ void PolychromeUSBController::SetDeviceInfo()
            case POLYCHROME_USB_ZONE_PCH:
            case POLYCHROME_USB_ZONE_IOCOVER:
            case POLYCHROME_USB_ZONE_PCB:
+            case POLYCHROME_USB_ZONE_AUDIO:
                newdev_info.device_type = PolychromeDeviceType::FIXED;
                break;
-
+            
            /*-----------------------------------------*\
            | Type: Fixed                               |
            \*-----------------------------------------*/
@@ -187,26 +121,6 @@ void PolychromeUSBController::SetDeviceInfo()

        device_info.push_back(newdev_info);
    }
-
-    // set rgswap to match our settings
-    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)
-{
-    unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
-
-    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, POLYCHROME_USB_ZONE_MAX_NUM);
-
-    configtable[zone] = new_size;
-
-    for(unsigned int i = 0; i < POLYCHROME_USB_ZONE_MAX_NUM; i++)
-    {
-        zonecfg[i] = configtable[i];
-    }
-
-    unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
-    WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }

 void PolychromeUSBController::WriteZone
@@ -214,13 +128,13 @@ void PolychromeUSBController::WriteZone
    unsigned char   zone,
    unsigned char   mode,
    unsigned char   speed,
-    RGBColor        rgb,
+    RGBColor        rgb, 
    bool            allzone = false
    )
 {

 	/*----------------------------------------------------*\
-    | Get the device info so we can look up the zone type. |
+    | Get the device info so we can look up the zone type. | 
 	\*----------------------------------------------------*/
    PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];

@@ -235,20 +149,10 @@ void PolychromeUSBController::WriteZone
    | Set up message packet with leading 00                  |
    \*-----------------------------------------------------*/
 	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = device_info.zone_type;
+    usb_buf[0x03] = device_info.zone_type; 
 	usb_buf[0x04] = mode;
-
-    if(device_info.rgswap)
-    {
-        usb_buf[0x05] = RGBGetRValue(rgb);
-        usb_buf[0x06] = RGBGetGValue(rgb);
-    }
-    else
-    {
-        usb_buf[0x05] = RGBGetGValue(rgb);
-        usb_buf[0x06] = RGBGetRValue(rgb);
-    }
-
+	usb_buf[0x05] = RGBGetRValue(rgb);
+	usb_buf[0x06] = RGBGetGValue(rgb);
 	usb_buf[0x07] = RGBGetBValue(rgb);
 	usb_buf[0x08] = speed;
 	usb_buf[0x09] = 0xFF;
@@ -261,128 +165,34 @@ void PolychromeUSBController::WriteZone
    hid_read(dev, usb_buf, 64);
 };

-void PolychromeUSBController::WriteAllZones
+void PolychromeUSBController::WriteRGSwap
    (
-    const std::vector<PolychromeZoneInfo>&  /*zones_info*/,
-    const std::vector<zone>&                zones
+    bool ahdr1,
+    bool ahdr0,
+    bool hdr1,
+    bool hdr0
    )
 {
-    std::vector<unsigned char> combined_leds_rgb;
-    std::size_t max_led_count = 0;
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++){
-        PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone_idx];
-
-        for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
-        {
-            if(device_info.rgswap)
-            {
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-            }
-            else
-            {
-                combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
-                combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
-            }
-            combined_leds_rgb.push_back(RGBGetBValue(zones[zone_idx].colors[led_idx]));
-        }
-        max_led_count += zones[zone_idx].leds_max;
-    }
-    combined_leds_rgb.resize((max_led_count + 8) * 3, 0);
-
    unsigned char usb_buf[65];
+
    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
    \*-----------------------------------------------------*/
    memset(usb_buf, 0x00, sizeof(usb_buf));

    /*-----------------------------------------------------*\
-    | Set up initial message packet with leading 00         |
+    | Set up message packet with leading 00                 |
    \*-----------------------------------------------------*/
-    usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = 0xFF;
-    usb_buf[0x04] = POLYCHROME_USB_INITIAL_CHUNK;
-    usb_buf[0x07] = 0xFF;
-    usb_buf[0x40] = 0x65;
+	usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;

-    std::size_t initial_led_offset = 9;
-    std::size_t message_byte_capacity = 54;           // 18 leds * 3 bytes
+    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
+	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;

-    std::size_t led_byte_idx = 0;
-
-    while(led_byte_idx < combined_leds_rgb.size())
-    {
-        for(std::size_t byte_idx = 0; byte_idx < message_byte_capacity; byte_idx++)
-        {
-            usb_buf[initial_led_offset + byte_idx] = combined_leds_rgb[led_byte_idx++];
-            if(led_byte_idx >= combined_leds_rgb.size())
-            {
-                break;
-            }
-        }
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 65);
-
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet with leading 00                  |
-        \*-----------------------------------------------------*/
-        usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-        usb_buf[0x03] = 0xFF;
-        usb_buf[0x04] = POLYCHROME_USB_SEND_CHUNK;
-        usb_buf[0x40] = 0x65;
-
-        initial_led_offset = 5;
-        message_byte_capacity = 57;                 // 19 leds * 3 bytes
-    }
-}
-
-/*-----------------------------------------------------*\
-| If reset is true, rgswap is set to the values         |
-| specified in the settings file, otherwise set to off  |
-\*-----------------------------------------------------*/
-void PolychromeUSBController::SetRGSwap(bool reset)
-{
-    if(reset)
-    {
-        bool rg[8] = {0};
-        std::vector<PolychromeDeviceInfo> devices_info = GetPolychromeDevices();
-        for (PolychromeDeviceInfo device : devices_info)
-        {
-            rg[device.zone_type] = device.rgswap;
-        }
-        WriteRGSwap(rg[0], rg[1], rg[2], rg[3], rg[4], rg[5], rg[6], rg[7]);
-    }
-    else
-    {
-        /*-----------------------------------------------------------------*\
-        | Disable RGSwap as it causes flashing on each update in direct mode|
-        \*-----------------------------------------------------------------*/
-        WriteRGSwap(0, 0, 0, 0, 0, 0, 0, 0);
-    }
-}
-
-void PolychromeUSBController::WriteRGSwap
-    (
-    bool hdr0,
-    bool hdr1,
-    bool ahdr0,
-    bool ahdr1,
-    bool pch,
-    bool io,
-    bool pcb,
-    bool chnl8
-    )
-{
-    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
-    WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }

 void PolychromeUSBController::WriteHeader
@@ -435,7 +245,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
    | Set up config table request packet                    |
    \*-----------------------------------------------------*/
    usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
-    usb_buf[0x03]   = device_info.zone_type;
+    usb_buf[0x03]   = device_info.zone_type; 

    /*-----------------------------------------------------*\
    | Send packet                                           |
@@ -447,28 +257,13 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
    \*-----------------------------------------------------*/
    memset(usb_buf, 0x00, sizeof(usb_buf));
    hid_read(dev, usb_buf, 64);
-
+    
    r   = usb_buf[0x05];
    g   = usb_buf[0x06];
    b   = usb_buf[0x07];

-    /*------------------------------------------------------*\
-    | Set Chroma mode (0xE2) & Per-Led mode (0xE3) as Direct |
-    \*------------------------------------------------------*/
-    zoneinfo.mode   = usb_buf[0x04] != 0xE2 && usb_buf[0x04] != 0xE3 && usb_buf[0x04] < 0x0F ? usb_buf[0x04] : 0x0F;
-
-    /*------------------------------------------------------*\
-    | G & R are swapped since RGSwap is disabled on init,    |
-    | Unless overwritten in settings                         |
-    \*------------------------------------------------------*/
-    if(device_info.rgswap)
-    {
-        zoneinfo.color  = ToRGBColor(r,g,b);
-    }
-    else
-    {
-        zoneinfo.color  = ToRGBColor(g,r,b);
-    }
+    zoneinfo.mode   = usb_buf[0x04];
+    zoneinfo.color  = ToRGBColor(r,g,b);  
    zoneinfo.speed  = usb_buf[0x08];
    zoneinfo.zone   = usb_buf[0x03];

@@ -479,7 +274,7 @@ void PolychromeUSBController::ReadConfigTables()
 {
    unsigned char usb_buf[65];
    unsigned char maxzoneleds[8];
-    unsigned char rgswap;
+    unsigned char rgbswap;
    unsigned char header1;

    /*-----------------------------------------------------*\
@@ -506,7 +301,7 @@ void PolychromeUSBController::ReadConfigTables()

    /*-----------------------------------------------------*\
    | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
-    | PCB, AUDIO/ARGB3                                      |
+    | PCB, AUDIO                                            |
    \*-----------------------------------------------------*/
    memcpy(&maxzoneleds,&usb_buf[0x04],8);

@@ -526,10 +321,10 @@ void PolychromeUSBController::ReadConfigTables()
    hid_read(dev, usb_buf, 64);

    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
+    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
+    | ARGB1, RGB2, RGB1 if available                        |
    \*-----------------------------------------------------*/
-    rgswap=usb_buf[4];
+    rgbswap=usb_buf[4];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -545,15 +340,10 @@ void PolychromeUSBController::ReadConfigTables()
    hid_write(dev, usb_buf, 64);
    memset(usb_buf, 0x00, sizeof(usb_buf));
    hid_read(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH,   |
-    | ARGB2,ARGB1, RGB2, RGB1 if available                  |
-    \*-----------------------------------------------------*/
    header1=usb_buf[4];

    memcpy(configtable,&maxzoneleds,8);
-    configtable[8]=rgswap;
+    configtable[8]=rgbswap;
    configtable[9]=header1;
    return;
 }
@@ -5,7 +5,6 @@
 |  lighting controller                      |
 |                                           |
 |  Ed Kambulow (dredvard) 12/20/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/

 #include "RGBController.h"
@@ -17,7 +16,7 @@
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_USB_NUM_MODES            16          /* Number of Polychrome USB modes       */
+#define POLYCHROME_USB_NUM_MODES            15          /* Number of Polychrome USB modes       */

 enum
 {
@@ -36,7 +35,6 @@ enum
    POLYCHROME_USB_MODE_NEON                = 0x0C,     /* Neon effect mode                     */
    POLYCHROME_USB_MODE_WATER               = 0x0D,     /* Water effect mode                    */
    POLYCHROME_USB_MODE_RAINBOW             = 0x0E,     /* Rainbow effect mode                  */
-    POLYCHROME_USB_MODE_DIRECT              = 0x0F,     /* CHROMA CONNECT effect mode           */
 };

 enum
@@ -59,7 +57,17 @@ enum
    POLYCHROME_USB_ZONE_UNAVAILABLE         = 0x1E,     // Value from LEDCOUNT CFG if zone not present
 };

-extern const char* polychrome_USB_zone_names[];
+static const char* polychrome_USB_zone_names[] =
+{
+    "RGB LED 1 Header",
+    "RGB LED 2 Header",
+    "Addressable Header 1",
+    "Addressable Header 2",
+    "PCH",
+    "IO Cover",
+    "PCB",
+    "Audio",
+};

 enum
 {
@@ -70,7 +78,7 @@ enum
    POLYCHROME_USB_ZONE_PCH          = 0X04,  // PCH
    POLYCHROME_USB_ZONE_IOCOVER      = 0X05,  // IOCOVER
    POLYCHROME_USB_ZONE_PCB          = 0X06,  // PCB - Could be mixed swapped with 0x07
-    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO/ARGB Header 3
+    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO
 };

 enum class PolychromeDeviceType
@@ -92,7 +100,6 @@ struct PolychromeDeviceInfo
    unsigned char           effect_channel;
    unsigned char           num_leds;
 	unsigned char			zone_type;
-    bool        			rgswap;
    PolychromeDeviceType    device_type;
 };

@@ -120,12 +127,6 @@ public:
                                                    bool            allzone
                                                    );

-    void                                        WriteAllZones
-                                                    (
-                                                    const std::vector<PolychromeZoneInfo> &zones_info,
-                                                    const std::vector<zone> &zones
-                                                    );
-
    void                                        WriteHeader
                                                    (
                                                    unsigned char   cfg,
@@ -133,31 +134,17 @@ public:
                                                    unsigned int    configsize
                                                    );

-    void                                        ResizeZone(int zone, int new_size);
-    void                                        SetRGSwap(bool reset);
-
 protected:
    hid_device*                         dev;
    std::vector<PolychromeDeviceInfo>   device_info;
    std::string                         location;

-    void WriteRGSwap
-        (
-        bool hdr0,
-        bool hdr1,
-        bool ahdr0,
-        bool ahdr1,
-        bool pch,
-        bool io,
-        bool pcb,
-        bool chnl8
-        );
+    void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);

 private:
    unsigned int  led_count;
    std::string   device_name;
    unsigned char configtable[12];
-    bool          rgswapconfig[8] = { 0 };

    void SetDeviceInfo();    
    void ReadConfigTables();
@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/

 #include "RGBController_ASRockPolychromeUSB.h"
@@ -23,6 +22,7 @@
    @effects :white_check_mark:
    @detectors DetectPolychromeUSBControllers
    @comment ASRock Polychrome controllers will save with each update.
+        Per ARGB LED support is not possible with these devices.
 \*-------------------------------------------------------------------*/

 RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
@@ -173,14 +173,12 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
    Rainbow.color_mode          = MODE_COLORS_NONE;
    modes.push_back(Rainbow);

-    mode Direct;
-    Direct.name                = "Direct";
-    Direct.value               = POLYCHROME_USB_MODE_DIRECT;
-    Direct.flags               = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode          = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
    SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode(1);
 }

 void RGBController_PolychromeUSB::SetupZones()
@@ -233,6 +231,16 @@ void RGBController_PolychromeUSB::SetupZones()

    SetupColors();

+    /*---------------------------------------------------------*\
+    | Initialize colors for each LED                            |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        unsigned char led = (unsigned char)leds[led_idx].value;
+
+        colors[led_idx] = controller->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
+    }
+
    /*---------------------------------------------------------*\
    | Initialize zone info to track zone, speed, mode           |
    | B550 Boards have modes, speed for each zone               |
@@ -244,46 +252,30 @@ void RGBController_PolychromeUSB::SetupZones()
        zones_info.push_back(zoneinfo);
    }

-     /*---------------------------------------------------------*\
-     | Initialize colors for each LED                            |
-     | We cannot currently get the individual led color so       |
-     | we use the zone color in each zone to set all leds        |
-     | !!TODO: in Per-Led mode, zone color is always black       |
-     \*---------------------------------------------------------*/
-     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-     {
-         unsigned char led = (unsigned char)leds[led_idx].value;
-
-         colors[led_idx] = zones_info[led].color;
-     }
-
-     /*-------------------------------------------------*\
-     | Initialize active mode                            |
-     \*-------------------------------------------------*/
-     active_mode = zones_info.size() > 1 ? zones_info[0].mode : 0x0;
-
-     /*-----------------------------------------------------*\
-     | If in Direct mode, reset all Leds to match interface  |
-     \*-----------------------------------------------------*/
-     if(active_mode == 0x0F)
-     {
-        controller->WriteAllZones(zones_info, zones);
-     }
 }

 void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 {
+     unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
+
+    /*---------------------------------------------------------*\
+    | This device does not currently support resizing zones     |
+    \*---------------------------------------------------------*/
    zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+
+    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
+
+    for(unsigned int i = 0; i < zones.size(); i++)
+    {
+        zonecfg[i]=zones[i].leds_count;
+    }
+
+    // unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
+    // WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
 }

 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
 {
-    if(POLYCHROME_USB_MODE_DIRECT == zones_info[0].mode )
-    {
-        controller->WriteAllZones(zones_info,zones);
-        return;
-    }
    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        unsigned char set_mode = zones_info[zone_idx].mode;
@@ -332,14 +324,13 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
    return(active_mode);
 }

+void RGBController_PolychromeUSB::SetCustomMode()
+{
+    active_mode = POLYCHROME_USB_MODE_STATIC;
+}
+
 void RGBController_PolychromeUSB::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------------------*\
-    | Disable RGSwap as it causes flashing on each update in direct mode|
-    | Otherwise, reset to values specified in settings.json             |
-    \*-----------------------------------------------------------------*/
-    controller->SetRGSwap(modes[active_mode].name != "Direct");
-
    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        if(zones[zone_idx].leds_count > 0)
@@ -5,7 +5,6 @@
 |  ASRock Polychrome USB Driver             |
 |                                           |
 |  Ed Kambulow (Dredvard) 12/26/2020        |
-|  Shady Nawara (ShadyNawara) 01/16/2023    |
 \*-----------------------------------------*/

 #pragma once
@@ -26,6 +25,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -22,6 +22,7 @@ ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_i
    this->dev = dev;

    DMIInfo dmi;
+
    device_name =   "ASRock " + dmi.getMainboard();

    ReadLEDConfiguration();
@@ -61,9 +62,9 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
    | The LED configuration register holds 6 bytes, so the first read should return 6   |
    | If not, set all zone sizes to zero                                                |
    \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("[%s] Reading Zone sizes from controller", device_name.c_str());
+    LOG_DEBUG("[%s] Reading LED config from controller", device_name.c_str());
    uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
+    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_LED_CONFIG, asrock_zone_count) == 0x06)
    {
        zone_led_count[POLYCHROME_V1_ZONE_1]           = asrock_zone_count[0];
        zone_led_count[POLYCHROME_V1_ZONE_2]           = asrock_zone_count[1];
@@ -85,156 +86,27 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
    }
 }

-uint8_t ASRockPolychromeV1SMBusController::GetARGBColorOrder()
+uint8_t ASRockPolychromeV1SMBusController::GetMode()
 {
-    uint8_t temp[1] = { 0x00 };
-    LOG_TRACE("[%s] Reading ARGB color order config from the controller", device_name.c_str());
-
-    //Read the data
-    if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, temp) == 0x01)
-    {
-        if(temp[0] == 1)
-        {
-            LOG_DEBUG("[%s] Color order is GRB for the ARGB header", device_name.c_str());
-        }
-        else
-        {
-            LOG_DEBUG("[%s] Color order is RGB for the ARGB header", device_name.c_str());
-        }
-        return temp[0];
-    }
-    else
-    {
-        return 0;
-    }
+    return(active_mode);
 }

-RGBColor ASRockPolychromeV1SMBusController::GetZoneColor(uint8_t zone)
+void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
 {
-    LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone);
-    return zone_config[zone].color;
-}
-
-uint8_t ASRockPolychromeV1SMBusController::GetZoneMode(uint8_t zone)
-{
-    LOG_TRACE("[%s] Retreving mode %02X from zone_modes for zone %02d", device_name.c_str(), zone_config[zone].mode, zone);
-    return(zone_config[zone].mode);
-}
-
-void ASRockPolychromeV1SMBusController::LoadZoneConfig()
-{
-    uint8_t zone[1] = { 0x00 };
-    uint8_t mode[1] = { 0xFF };
-    uint8_t color_speed_pkt[4] = { 0, 0, 0, 0 };
-
-    LOG_TRACE("[%s] Reading modes from all zones", device_name.c_str());
-    //Polychrome v1 supports per zone modes so we need to set the zone before we can read the mode.
-    //Write the zone index.
-
-    for(uint8_t zone_idx = 0 ; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx ++)
-    {
-        if(zone_led_count[zone_idx] > 0)
-        {
-            zone[0] = zone_idx;
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, zone);
-
-            //Read the data back.
-            if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, zone) == 0x01)
-            {
-                //Validate that we changed correctly.
-                if(zone[0] == zone_idx)
-                {
-                    //Read the mode for the zone.
-                    if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_MODE, mode) == 0x01)
-                    {
-                        LOG_DEBUG("[%s] Mode 0x%02x for zone %02d", device_name.c_str(), mode[0], zone_idx);
-                        zone_config[zone_idx].mode = mode[0];
-
-                        bus->i2c_smbus_read_block_data(dev, zone_config[zone_idx].mode, color_speed_pkt);
-
-                        zone_config[zone_idx].color = color_speed_pkt[0] << 16 | color_speed_pkt[1] << 8 | color_speed_pkt[2];
-                        zone_config[zone_idx].speed = color_speed_pkt [3];
-
-                        LOG_TRACE("[%s] Mode config: %06X, %02X", device_name.c_str(), zone_config[zone_idx].color, zone_config[zone_idx].speed );
-                    }
-                }
-                else
-                {
-                    LOG_WARNING("[%s] Zone mode register failed to change!", device_name.c_str() );
-                }
-            }
-        }
-        else
-        {
-            zone_config[zone_idx].mode = 0;
-            zone_config[zone_idx].color = 0;
-            zone_config[zone_idx].speed = 0;
-        }
-    }
-}
-
-void ASRockPolychromeV1SMBusController::SetARGBColorOrder(bool value)
-{
-    uint8_t temp[1] = { 0x00 };
-
-    LOG_TRACE("[%s] Setting ARGB color order config to the controller", device_name.c_str());
-
-    temp[0] = (value) ? 0x01 : 0x00;
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, 1, temp);
-    GetARGBColorOrder();
-}
-
-bool ASRockPolychromeV1SMBusController::SetARGBSize(uint8_t new_size)
-{
-    LOG_DEBUG("[%s] Setting ARGB header to %02d.", device_name.c_str(), new_size);
-
-    uint8_t asrock_zone_count[6] = { 0x0 };
-    uint8_t new_asrock_zone_count[6] = { 0x0 };
-
-    //memcpy(new_asrock_zone_count, zone_led_count, sizeof(new_asrock_zone_count - 1));
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_1] = zone_led_count[POLYCHROME_V1_ZONE_1];
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_2] = zone_led_count[POLYCHROME_V1_ZONE_2];
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_3] = zone_led_count[POLYCHROME_V1_ZONE_3];
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_4] = zone_led_count[POLYCHROME_V1_ZONE_4];
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_5] = zone_led_count[POLYCHROME_V1_ZONE_5];
-    new_asrock_zone_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = new_size;
-
-    //Write the new config to the register
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, 6, new_asrock_zone_count);
-
-    //Validate the write
-    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
-    {
-        for (uint8_t i = 0; i < 6; i++)
-        {
-            if (new_asrock_zone_count[i] != asrock_zone_count[i])
-            {
-                LOG_WARNING("[%s] Failed to validate zone %02d size!", device_name.c_str(), i);
-                return false;
-            }
-        }
-        LOG_DEBUG("[%s] Zone configuration validation completed.", device_name.c_str());
-        return true;
-    }
-    return false;
-}
-
-void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t red, uint8_t green, uint8_t blue)
-{
-    LOG_TRACE("[%s] Updating color and speed for zone %02d: 0x%06X", device_name.c_str(), zone, (red << 16 | green << 8 | blue));
-    uint8_t color_speed_pkt[4] = { red, green, blue, zone_config[zone].speed };
-    uint8_t select_zone_pkt[1]  = { zone };
+    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
+    uint8_t select_led_pkt[1]  = { led };
+    

    /*-----------------------------------------------------*\
-    | Select Zone                                           |
+    | Select LED                                            |
    \*-----------------------------------------------------*/
-    if(zone_config[zone].mode != POLYCHROME_V1_MODE_OFF)
+    if(active_mode != POLYCHROME_V1_MODE_OFF)
    {
-        bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, select_zone_pkt);
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, select_led_pkt);
        std::this_thread::sleep_for(1ms);
    }

-    switch(zone_config[zone].mode)
+    switch(active_mode)
    {
        /*-----------------------------------------------------*\
        | These modes take 4 bytes in R/G/B/S order             |
@@ -250,7 +122,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t
        case POLYCHROME_V1_MODE_NEON:
        case POLYCHROME_V1_MODE_WATER:

-            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 4, color_speed_pkt);
+            bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
            break;

        /*-----------------------------------------------------*\
@@ -259,7 +131,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t
        default:
        case POLYCHROME_V1_MODE_STATIC:
        case POLYCHROME_V1_MODE_MUSIC:
-            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 3, color_speed_pkt);
+            bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
            break;

        /*-----------------------------------------------------*\
@@ -268,7 +140,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t
        case POLYCHROME_V1_MODE_RANDOM:
        case POLYCHROME_V1_MODE_WAVE:
        case POLYCHROME_V1_MODE_RAINBOW:
-            bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 1, &zone_config[zone].speed);
+            bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
            break;

        /*-----------------------------------------------------*\
@@ -281,12 +153,12 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t

 }

-void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone, uint8_t mode, uint8_t speed)
+void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
 {
-    LOG_TRACE("[%s] Updating mode for zone %02d, Mode 0x%02X, Speed 0x%02X", device_name.c_str(), zone, mode, speed);
-    uint8_t led_count_pkt[1]    = { 0x00 };
-    zone_config[zone].mode      = mode;
-    zone_config[zone].speed     = speed;
+    uint8_t led_count_pkt[1]  = { 0x00 };
+    active_zone                     = zone;
+    active_mode                     = mode;
+    active_speed                    = speed;

    /*-----------------------------------------------------*\
    | Make sure set all register is set to 0                |
@@ -297,12 +169,12 @@ void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone, uint8_t mode, uint
    /*-----------------------------------------------------*\
    | Set the zone we are working on                        |
    \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, &zone);
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, &active_zone);
    std::this_thread::sleep_for(1ms);

    /*-----------------------------------------------------*\
    | Write the mode                                        |
    \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &zone_config[zone].mode);
-    std::this_thread::sleep_for(1ms);
+    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &active_mode);
+    std::this_thread::sleep_for(1ms);    
 }
@@ -9,7 +9,6 @@
 \*-----------------------------------------*/

 #include "i2c_smbus.h"
-#include "RGBController.h"
 #include <string>

 #pragma once
@@ -25,22 +24,22 @@ enum
    \*------------------------------------------------------------------------------------------*/
    POLYCHROME_V1_REG_FIRMWARE_VER          = 0x00,     /* Firmware version Major.Minor         */
    POLYCHROME_V1_REG_MODE                  = 0x30,     /* Mode selection register              */
-    POLYCHROME_V1_REG_ZONE_SELECT           = 0x31,     /* Zone selection register              */
+    POLYCHROME_V1_REG_LED_SELECT            = 0x31,     /* LED selection register               */
    POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
-    POLYCHROME_V1_REG_ZONE_SIZE             = 0x33,     /* Zone size configuration register     */
-    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bitstream reversing register    */
+    POLYCHROME_V1_REG_LED_CONFIG            = 0x33,     /* LED configuration register           */
+    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
 };

 enum
 {
    POLYCHROME_V1_ZONE_1                    = 0x00,     /* RGB LED 1 Header                     */
    POLYCHROME_V1_ZONE_2                    = 0x01,     /* RGB LED 2 Header                     */
-    POLYCHROME_V1_ZONE_3                    = 0x02,     /* PCH Zone                             */
-    POLYCHROME_V1_ZONE_4                    = 0x03,     /* IO Cover Zone                        */
-    POLYCHROME_V1_ZONE_5                    = 0x04,     /* Audio Zone LEDs                      */
+    POLYCHROME_V1_ZONE_3                    = 0x02,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V1_ZONE_4                    = 0x03,     /* Audio/PCH Zone LEDs                  */
+    POLYCHROME_V1_ZONE_5                    = 0x04,     /* IO Cover Zone LEDs                   */
    POLYCHROME_V1_ZONE_ADDRESSABLE          = 0x05,     /* Addressable LED header               */
    POLYCHROME_V1_ZONE_COUNT                = 0x06,     /* Total number of zones                */
-    POLYCHROME_V1_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maximum number of ARGB LEDs          */
+    POLYCHROME_V1_ZONE_ADDRESSABLE_MAX      = 0x64,     /* Maxinum number of ARGB LEDs          */
 };

 /*----------------------------------------------------------------------------------------------*\
@@ -52,7 +51,7 @@ enum
 {
    POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
    POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breathing effect mode                */
+    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
    POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
    POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
    POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
@@ -120,13 +119,6 @@ enum
    POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
 };

-struct zone_cfg
-{
-    uint8_t     mode;
-    uint8_t     speed;
-    RGBColor    color;
-};
-
 class ASRockPolychromeV1SMBusController
 {
 public:
@@ -136,24 +128,20 @@ public:
    std::string             GetDeviceLocation();
    std::string             GetDeviceName();
    std::string             GetFirmwareVersion();
-
-    uint8_t                 GetARGBColorOrder();
-    RGBColor                GetZoneColor(uint8_t zone);
-    uint8_t                 GetZoneMode(uint8_t zone);
-    void                    LoadZoneConfig();
-    void                    SetARGBColorOrder(bool value);
-    bool                    SetARGBSize(uint8_t led_count);
+    uint8_t                 GetMode();
    void                    SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
    void                    SetMode(uint8_t zone, uint8_t mode, uint8_t speed);

    uint8_t                 zone_led_count[6];
-    zone_cfg                zone_config[6];
    uint16_t                fw_version;
-
+    
 private:
    std::string             device_name;
+    uint8_t                 active_zone;
+    uint8_t                 active_mode;
+    uint8_t                 active_speed;
    i2c_smbus_interface*    bus;
    polychrome_dev_id       dev;

-    void                    ReadLEDConfiguration();
+    void                ReadLEDConfiguration();
 };
@@ -26,14 +26,14 @@

 RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;

-    name                        = controller->GetDeviceName();
-    vendor                      = "ASRock";
-    version                     = controller->GetFirmwareVersion();
-    type                        = DEVICE_TYPE_MOTHERBOARD;
-    description                 = "ASRock ASR RGB LED Device";
-    location                    = controller->GetDeviceLocation();
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock ASR RGB LED Device";
+    location    = controller->GetDeviceLocation();

    mode Off;
    Off.name                    = "Off";
@@ -196,6 +196,11 @@ void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
    controller->SetColorsAndSpeed(led, red, grn, blu);
 }

+void RGBController_ASRockASRRGBSMBus::SetCustomMode()
+{
+    active_mode = 1;
+}
+
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateMode()
 {

@@ -26,6 +26,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -7,7 +7,6 @@
 |  Adam Honse (CalcProgrammer1) 12/15/2019  |
 \*-----------------------------------------*/

-#include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"

 static const char* polychrome_v1_zone_names[] =
@@ -30,42 +29,38 @@ static const char* polychrome_v1_zone_names[] =
    @detectors DetectASRockSMBusControllers
    @comment ASRock Polychrome v1 controllers will save with each update.
        Per ARGB LED support is not possible with these devices.
-        ARGB size  and color order is set using the `ARGB Header Config mode`
-        `Right` = GRB mode that is needed for WS2812B ARGB devices and `Left` = RGB used for WS2811 strips
-        The modes speed slider will set the size of the header
-        Spectrum Cycles uses the RGB values to set the individual color brightness.
 \*-------------------------------------------------------------------*/

 RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;

-    name                        = controller->GetDeviceName();
-    vendor                      = "ASRock";
-    version                     = controller->GetFirmwareVersion();
-    type                        = DEVICE_TYPE_MOTHERBOARD;
-    description                 = "ASRock Polychrome v1 Device";
-    location                    = controller->GetDeviceLocation();
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock Polychrome v1 Device";
+    location    = controller->GetDeviceLocation();


    mode Off;
    Off.name                    = "Off";
    Off.value                   = POLYCHROME_V1_MODE_OFF;
-    Off.flags                   = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.flags                   = 0;
    Off.color_mode              = MODE_COLORS_NONE;
    modes.push_back(Off);

    mode Static;
    Static.name                 = "Static";
    Static.value                = POLYCHROME_V1_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
    Static.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Static);

    mode Breathing;
    Breathing.name              = "Breathing";
    Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
    Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
    Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
    Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
@@ -75,7 +70,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Strobe;
    Strobe.name                 = "Strobe";
    Strobe.value                = POLYCHROME_V1_MODE_STROBE;
-    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
+    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
    Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
    Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
    Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
@@ -85,17 +80,17 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode SpectrumCycle;
    SpectrumCycle.name          = "Spectrum Cycle";
    SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
    SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
    SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
    SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
-    SpectrumCycle.color_mode    = MODE_COLORS_PER_LED;
+    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
    modes.push_back(SpectrumCycle);

    mode Random;
    Random.name                 = "Random";
    Random.value                = POLYCHROME_V1_MODE_RANDOM;
-    Random.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Random.flags                = MODE_FLAG_HAS_SPEED;
    Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
    Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
    Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
@@ -103,16 +98,16 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    modes.push_back(Random);

    mode Music;
-    Music.name                  = "Music";
-    Music.value                 = POLYCHROME_V1_MODE_MUSIC;
-    Music.flags                 = MODE_FLAG_AUTOMATIC_SAVE;
-    Music.color_mode            = MODE_COLORS_NONE;
+    Music.name                 = "Music";
+    Music.value                = POLYCHROME_V1_MODE_MUSIC;
+    Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Music.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Music);

    mode Wave;
    Wave.name                   = "Wave";
    Wave.value                  = POLYCHROME_V1_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Wave.flags                  = MODE_FLAG_HAS_SPEED;
    Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
    Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
    Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
@@ -122,10 +117,11 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    /*---------------------------------------------------------------------*\
    | Comment out until per zone modes are working. These are only for ARGB |
    \*---------------------------------------------------------------------*/
+    /*
    mode Spring;
    Spring.name                 = "Spring";
    Spring.value                = POLYCHROME_V1_MODE_SPRING;
-    Spring.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Spring.flags                = MODE_FLAG_HAS_SPEED;
    Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
    Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
    Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
@@ -135,7 +131,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Stack;
    Stack.name                  = "Stack";
    Stack.value                 = POLYCHROME_V1_MODE_STACK;
-    Stack.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Stack.flags                 = MODE_FLAG_HAS_SPEED;
    Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
    Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
    Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
@@ -145,7 +141,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Cram;
    Cram.name                   = "Cram";
    Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-    Cram.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Cram.flags                  = MODE_FLAG_HAS_SPEED;
    Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
    Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
    Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
@@ -155,7 +151,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Scan;
    Scan.name                   = "Scan";
    Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-    Scan.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Scan.flags                  = MODE_FLAG_HAS_SPEED;
    Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
    Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
    Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
@@ -165,7 +161,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Neon;
    Neon.name                   = "Neon";
    Neon.value                  = POLYCHROME_V1_MODE_NEON;
-    Neon.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Neon.flags                  = MODE_FLAG_HAS_SPEED;
    Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
    Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
    Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
@@ -175,7 +171,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Water;
    Water.name                  = "Water";
    Water.value                 = POLYCHROME_V1_MODE_WATER;
-    Water.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Water.flags                 = MODE_FLAG_HAS_SPEED;
    Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
    Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
    Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
@@ -185,44 +181,15 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Rainbow;
    Rainbow.name                = "Rainbow";
    Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
+    Rainbow.flags               = MODE_FLAG_HAS_SPEED;
    Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
    Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
    Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
    Rainbow.color_mode          = MODE_COLORS_NONE;
    modes.push_back(Rainbow);
-
-    /*---------------------------------------------------------------------*\
-    | This ARGB_Config section is a hack to allow users to configure the    |
-    | RGB vs GRB mode using the direction of the mode as well as set the    |
-    | size of the devices connected to the header using the brightness      |
-    | value.                                                                |
-    |                                                                       |
-    | The mode should be removed onece the device settings are avaiable.    |
-    \*---------------------------------------------------------------------*/
-    mode ARGB_Config;
-    ARGB_Config.name            = "ARGB Header Config";
-    ARGB_Config.value           = POLYCHROME_V1_REG_ARGB_GRB;
-    ARGB_Config.flags           = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_SPEED  | MODE_FLAG_AUTOMATIC_SAVE;
-    ARGB_Config.speed           = controller->zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE];
-    ARGB_Config.speed_min       = 1;
-    ARGB_Config.speed_max       = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
-    ARGB_Config.direction       = controller -> GetARGBColorOrder();
-    ARGB_Config.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(ARGB_Config);
+    */

    SetupZones();
-
-    controller->LoadZoneConfig();
-    active_mode = getModeIndex(controller->zone_config[0].mode); // Hard coding zone 0 until per zone modes are available.
-
-    if(active_mode != POLYCHROME_V1_MODE_OFF)
-    {
-        for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
-        {
-            zones[zone_idx].colors[0] = controller->GetZoneColor(zoneIndexMap[zone_idx]);
-        }
-    }
 }

 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
@@ -230,18 +197,6 @@ RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
    delete controller;
 }

-uint8_t RGBController_ASRockPolychromeV1SMBus::getModeIndex(uint8_t mode_value)
-{
-    for(uint8_t mode_index = 0; mode_index < modes.size(); mode_index++)
-    {
-        if (modes[mode_index].value == mode_value)
-        {
-            return mode_index;
-        }
-    }
-    return 0;
-}
-
 void RGBController_ASRockPolychromeV1SMBus::SetupZones()
 {
    /*---------------------------------------------------------*\
@@ -255,92 +210,118 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
    {
        if(controller->zone_led_count[zone_idx] > 0)
        {
-            zone*   new_zone        = new zone();
+            zone* new_zone = new zone();
+
            /*---------------------------------------------------------*\
            | Set zone name to channel name                             |
            \*---------------------------------------------------------*/
+
            new_zone->name          = polychrome_v1_zone_names[zone_idx];
-            new_zone->type          = ZONE_TYPE_SINGLE;
+
            new_zone->leds_min      = 1;
            new_zone->leds_max      = 1;
+            //new_zone->leds_count    = zone_led_count[zone_idx];
            new_zone->leds_count    = 1;
+
+            new_zone->type          = ZONE_TYPE_SINGLE;
+
            new_zone->matrix_map    = NULL;

-            if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
-            {
-                new_zone->leds_max  = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
-            }
            /*---------------------------------------------------------*\
            | Push new zone to zones vector                             |
            \*---------------------------------------------------------*/
            zones.push_back(*new_zone);
+        }
+    }

-            /*---------------------------------------------------------*\
-            | Each zone only has one LED                                |
-            \*---------------------------------------------------------*/
-            led*    new_led         = new led();
+    uint8_t led_count = 0;
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    for(uint8_t zone_idx = 0; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx++)
+    {
+        if(controller->zone_led_count[zone_idx] > 0)
+        {
+            for(uint8_t led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
+            {
+                /*---------------------------------------------------------*\
+                | Each zone only has one LED                                |
+                \*---------------------------------------------------------*/
+                led* new_led = new led();

-            new_led->name           = polychrome_v1_zone_names[zone_idx];
-            new_led->value          = zone_idx;
+                new_led->name           = polychrome_v1_zone_names[zone_idx];

-            /*---------------------------------------------------------*\
-            | Push new LED to LEDs vector                               |
-            \*---------------------------------------------------------*/
-            leds.push_back(*new_led);
-            zoneIndexMap.push_back(zone_idx);
+                new_led->name.append(" " + std::to_string(led_idx + 1));
+                new_led->value = 0;
+
+                new_led->value              = zone_idx;
+
+                /*---------------------------------------------------------*\
+                | Push new LED to LEDs vector                               |
+                \*---------------------------------------------------------*/
+                leds.push_back(*new_led);
+
+                led_count++;
+
+                if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
+                {
+                    break;
+                }
+            }
        }
    }

    SetupColors();
 }

-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
 {
-    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
-    controller-> SetARGBSize(new_size & 0xFF);
-    zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
 }

 void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
 {
-    LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
-    for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
+    for (std::size_t led = 0; led < colors.size(); led++)
    {
-        UpdateSingleLED(zone_idx);
+        UpdateSingleLED(led);
    }
 }

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

-void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int led)
 {
-    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
+    unsigned char red = RGBGetRValue(colors[led]);
+    unsigned char grn = RGBGetGValue(colors[led]);
+    unsigned char blu = RGBGetBValue(colors[led]);

-    uint8_t red = RGBGetRValue(colors[zone]);
-    uint8_t grn = RGBGetGValue(colors[zone]);
-    uint8_t blu = RGBGetBValue(colors[zone]);
+    /*---------------------------------------------------------*\
+    | If the LED value is non-zero, this LED overrides the LED  |
+    | index                                                     |
+    \*---------------------------------------------------------*/
+    if(leds[led].value != 0)
+    {
+        led = leds[led].value;
+    }

-    controller->SetColorsAndSpeed(zoneIndexMap[zone], red, grn, blu);
+    controller->SetColorsAndSpeed(led, red, grn, blu);
+}
+
+void RGBController_ASRockPolychromeV1SMBus::SetCustomMode()
+{
+    active_mode = 1;
 }

 void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
 {
-    LOG_TRACE("[%s] DeviceUpdateMode()", name.c_str());
-    if(modes[active_mode].value != POLYCHROME_V1_REG_ARGB_GRB)
+    for(uint8_t led_idx = 0; led_idx < leds.size(); led_idx++)
    {
-        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);
-        }
-    }
-    else
-    {
-        controller-> SetARGBColorOrder(modes[active_mode].direction);
-        controller-> SetARGBSize(modes[active_mode].speed);
+        controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
    }
+    DeviceUpdateLEDs();
 }
@@ -26,10 +26,9 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
 };
@@ -33,14 +33,14 @@ static const char* polychrome_v2_zone_names[] =

 RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;

-    name                        = controller->GetDeviceName();
-    vendor                      = "ASRock";
-    version                     = controller->GetFirmwareVersion();
-    type                        = DEVICE_TYPE_MOTHERBOARD;
-    description                 = "ASRock Polychrome v2 Device";
-    location                    = controller->GetDeviceLocation();
+    name        = controller->GetDeviceName();
+    vendor      = "ASRock";
+    version     = controller->GetFirmwareVersion();
+    type        = DEVICE_TYPE_MOTHERBOARD;
+    description = "ASRock Polychrome v2 Device";
+    location    = controller->GetDeviceLocation();


    mode Off;
@@ -316,6 +316,11 @@ void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
    controller->SetColorsAndSpeed(led, red, grn, blu);
 }

+void RGBController_ASRockPolychromeV2SMBus::SetCustomMode()
+{
+    active_mode = 1;
+}
+
 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateMode()
 {

@@ -26,6 +26,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -15,7 +15,6 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "LogManager.h"

 typedef uint32_t alienware_platform_id;

@@ -25,10 +24,8 @@ typedef uint32_t alienware_platform_id;
 \*---------------------------------------------------------*/
 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
-
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
 };

 /*---------------------------------------------------------*\
@@ -42,8 +39,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                  "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
-                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
 };

 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -117,13 +113,10 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic

    if(zone_names_table.count(platform_id))
    {
-        LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
        zone_names = zone_names_table.at(platform_id);
    }
    else
    {
-        LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
-
        /*-------------------------------------------------*\
        | If this is an unknown controller, set the name of |
        | all regions to "Unknown"                          |
@@ -599,14 +592,13 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)

 void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
 {
-    if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
-    {
-        return;
-    }
+    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));

-    zones[zone].color[0] = color1;
-    zones[zone].color[1] = color2;
-    dirty = true;
+	if(dirty)
+	{
+		zones[zone].color[0] = color1;
+        zones[zone].color[1] = color2;
+	}
 }

 void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
@@ -19,7 +19,7 @@

 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-#define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
 enum
 {
    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
@@ -179,6 +179,11 @@ void RGBController_Alienware::UpdateSingleLED(int led)
    UpdateZoneLEDs(led);
 }

+void RGBController_Alienware::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 static bool modes_eq(const mode& mode1, const mode& mode2)
 {
    return( ( mode1.name           == mode2.name       )
@@ -29,6 +29,8 @@ public:

    void        DeviceUpdateMode();

+    void        SetCustomMode();
+
 private:
    AlienwareController*                    controller;
    std::chrono::steady_clock::time_point   last_packet_ts;
@@ -172,7 +172,7 @@ void AlienwareAW510KController::SendInitialize()

 void AlienwareAW510KController::SetDirect
    (
-    unsigned char   /*zone*/,
+    unsigned char   zone,
    unsigned char   r,
    unsigned char   g,
    unsigned char   b
@@ -222,7 +222,7 @@ void AlienwareAW510KController::SendDirectOn
    | To Guarantee the data are always %4 =0 append   |
    | zeros at end of last packet                     |
    \*-----------------------------------------------*/
-    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
+    for(int i = 0; i < (frame_data.size() % 4); i++)
    {
        SelectedKeys key;
        key.idx     = 0x00;
@@ -358,7 +358,7 @@ void AlienwareAW510KController::UpdateSingleLED
 }
 void AlienwareAW510KController::SendMode
    (
-    unsigned char   /*zone*/,
+    unsigned char   zone,
    unsigned char   mode,
    unsigned short  speed,
    unsigned char   direction,
@@ -45,9 +45,9 @@ typedef struct
    const char *        name;
    const unsigned char zone;
    const unsigned char idx;
-} aw510k_led_type;
+} led_type;

-static const aw510k_led_type led_names[] =
+static const led_type led_names[] =
 {
    /* Key Label                Zone,                                      Index  */
    { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
@@ -171,21 +171,21 @@ static const aw510k_led_type led_names[] =

 RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;

-    name                            = "Alienware AW510K Keyboard Device";
-    vendor                          = "Alienware";
-    type                            = DEVICE_TYPE_KEYBOARD;
-    description                     = "Alienware AW510K Keyboard Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "Alienware AW510K Keyboard Device";
+    vendor      = "Alienware";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Alienware AW510K Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();

-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
+    mode Direct_Per_LED;
+    Direct_Per_LED.name             = "Direct";
+    Direct_Per_LED.value            = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
+    Direct_Per_LED.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct_Per_LED.color_mode       = MODE_COLORS_PER_LED;
+    modes.push_back(Direct_Per_LED);

    mode Static;
    Static.name                     = "Static";
@@ -403,6 +403,11 @@ void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }

+void RGBController_AlienwareAW510K::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
    if(active_mode == 0xFFFF)
@@ -26,6 +26,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -9,7 +9,6 @@
 #define ANNE_PRO_2_PID_2 0x8009
 #define ANNE_PRO_2_PID_3 0xA292
 #define ANNE_PRO_2_PID_4 0xA293
-#define ANNE_PRO_2_PID_5 0xA297

 /******************************************************************************************\
 *                                                                                          *
@@ -35,4 +34,3 @@ REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID,
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);
@@ -23,7 +23,7 @@ static unsigned int matrix_map[5][14] =

 static const char* zone_names[] =
 {
-    ZONE_EN_KEYBOARD,
+    "Keyboard",
 };

 static zone_type zone_types[] =
@@ -40,9 +40,9 @@ typedef struct
 {
    const char *        name;
    const unsigned char idx;
-} annepro2_led_type;
+} led_type;

-static const annepro2_led_type led_names[] =
+static const led_type led_names[] =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0       },
@@ -236,6 +236,11 @@ void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AnnePro2::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AnnePro2::DeviceUpdateMode()
 {

@@ -24,6 +24,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -1,155 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "ArcticController.h"
-#include <cstring>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_COMMAND_SET_RGB          0x00
-#define ARCTIC_COMMAND_IDENTIFY         0x5C
-
-#define ARCTIC_RESPONSE_BUFFER_LENGTH   15
-#define ARCTIC_RESPONSE_COMMAND_OFFSET  0
-#define ARCTIC_RESPONSE_DATA_OFFSET     1
-#define ARCTIC_RESPONSE_DATA_LENGTH     12
-#define ARCTIC_RESPONSE_XOR_CSUM_OFFSET 13
-#define ARCTIC_RESPONSE_ADD_CSUM_OFFSET 14
-
-#define ARCTIC_COMMAND_BUFFER_LENGTH(payload_size)  (sizeof(header) + 1 + payload_size)
-#define ARCTIC_COMMAND_COMMAND_OFFSET               (sizeof(header))
-#define ARCTIC_COMMAND_PAYLOAD_OFFSET               (sizeof(header) + 1)
-
-const unsigned char header[] =
-{
-    0x01,
-    0x02,
-    0x03,
-    0xFF,
-    0x05,
-    0xFF,
-    0x02,
-    0x03
-};
-
-const unsigned char identify_payload[] =
-{
-    0x01,
-    0xFE,
-    0x01,
-    0xFE
-};
-
-ArcticController::ArcticController(const std::string &portname)
-: serialport(portname.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false)
-{
-    port_name = portname;
-    serialport.serial_set_dtr(true);
-}
-
-ArcticController::~ArcticController()
-{
-    serialport.serial_set_dtr(false);
-}
-
-static void FormatCommandBuffer(char *buffer, char command)
-{
-    std::memcpy(buffer, header, sizeof(header));
-    buffer[ARCTIC_COMMAND_COMMAND_OFFSET] = command;
-}
-
-void ArcticController::SetChannels(std::vector<RGBColor> colors)
-{
-    char* buffer = new char[ARCTIC_COMMAND_BUFFER_LENGTH(colors.size() * 3)];
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_SET_RGB);
-
-    for(unsigned int channel = 0; channel < colors.size(); channel++)
-    {
-        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;
-
-        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
-        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
-        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
-    }
-
-    serialport.serial_write(buffer, sizeof(buffer));
-
-    delete[] buffer;
-}
-
-static char XORChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum ^= data[i];
-    }
-
-    return sum;
-}
-
-static char AddChecksum(char *data, int length)
-{
-    char sum = 0;
-
-    for(int i = 0; i < length; i++)
-    {
-        sum = (char)(sum + data[i]);
-    }
-
-    return sum;
-}
-
-bool ArcticController::IsPresent()
-{
-    char buffer[ARCTIC_COMMAND_BUFFER_LENGTH(sizeof(identify_payload))];
-    char response[ARCTIC_RESPONSE_BUFFER_LENGTH];
-    int ret;
-
-    FormatCommandBuffer(buffer, ARCTIC_COMMAND_IDENTIFY);
-    std::memcpy(buffer + ARCTIC_COMMAND_PAYLOAD_OFFSET, identify_payload, sizeof(identify_payload));
-
-    serialport.serial_flush_rx();
-    ret = serialport.serial_write(buffer, sizeof(buffer));
-    if(ret != sizeof(buffer))
-    {
-        return false;
-    }
-
-    std::this_thread::sleep_for(100ms);
-
-    ret = serialport.serial_read(response, sizeof(response));
-    if(ret != sizeof(response))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_COMMAND_OFFSET] != ARCTIC_COMMAND_IDENTIFY)
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_XOR_CSUM_OFFSET] != XORChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    if(response[ARCTIC_RESPONSE_ADD_CSUM_OFFSET] != AddChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
-    {
-        return false;
-    }
-
-    return true;
-}
-
-std::string ArcticController::GetLocation()
-{
-    return port_name;
-}
@@ -1,29 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticController.h                       |
-|                                           |
-|  Controller Interface for Arctic devices  |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include <algorithm>
-
-#include "RGBController.h"
-#include "serial_port.h"
-
-class ArcticController
-{
-public:
-    ArcticController(const std::string &portname);
-    ~ArcticController();
-
-    void SetChannels(std::vector<RGBColor> colors);
-    bool IsPresent();
-
-    std::string GetLocation();
-
-private:
-    std::string port_name;
-    serial_port serialport;
-};
@@ -1,48 +0,0 @@
-/*-----------------------------------------*\
-|  ArcticControllerDetect.cpp               |
-|                                           |
-|  Detect Arctic RGB controllers            |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "RGBController_Arctic.h"
-#include "find_usb_serial_port.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define CH341_VID   0x1A86
-#define CH341_PID   0x7523
-
-void DetectArcticControllers()
-{
-    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
-
-    for(unsigned int device = 0; device < ports.size(); device++)
-    {
-        ArcticController *controller = new ArcticController(*ports[device]);
-
-        if(controller->IsPresent())
-        {
-            RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
-        }
-
-        delete ports[device];
-    }
-}
-
-REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-/*---------------------------------------------------------------------------------------------------------*\
-| Entries for dynamic UDEV rules                                                                            |
-|                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
-\*---------------------------------------------------------------------------------------------------------*/
@@ -1,131 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 01/09/2023         |
-\*-----------------------------------------*/
-
-#include "RGBController_Arctic.h"
-#include <math.h>
-
-using namespace std::chrono_literals;
-
-#define ARCTIC_NUM_CHANNELS     4
-#define ARCTIC_SLEEP_THRESHOLD  100ms
-#define ARCTIC_KEEPALIVE_PERIOD 500ms  /* Device requires at least 1s */
-
-/**------------------------------------------------------------------*\
-    @name Arctic RGB Controller Devices
-    @category LEDStrip
-    @type Serial
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectArcticControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Arctic RGB Controller";
-    vendor      = "Arctic";
-    description = "Arctic 4-Channel RGB Controller";
-    location    = controller->GetLocation();
-    type        = DEVICE_TYPE_LEDSTRIP;
-
-    mode DirectMode;
-    DirectMode.name         = "Direct";
-    DirectMode.value        = 0;
-    DirectMode.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
-    DirectMode.color_mode   = MODE_COLORS_PER_LED;
-
-    modes.push_back(DirectMode);
-
-    SetupZones();
-
-    keepalive_thread_run = true;
-    keepalive_thread = std::thread(&RGBController_Arctic::KeepaliveThreadFunction, this);
-}
-
-RGBController_Arctic::~RGBController_Arctic()
-{
-    keepalive_thread_run = false;
-    keepalive_thread.join();
-    delete controller;
-}
-
-void RGBController_Arctic::SetupZones()
-{
-    for(int channel = 0; channel < ARCTIC_NUM_CHANNELS; channel++)
-    {
-        zone LedZone;
-        LedZone.name        = "LED Strip " + std::to_string(channel);
-        LedZone.type        = ZONE_TYPE_SINGLE;
-        LedZone.leds_count  = 1;
-        LedZone.leds_min    = 1;
-        LedZone.leds_max    = 1;
-        LedZone.matrix_map  = nullptr;
-
-        led Led;
-        Led.name    = LedZone.name + " LED";
-        Led.value   = channel;
-
-        zones.push_back(LedZone);
-        leds.push_back(Led);
-    }
-
-    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();
-
-    controller->SetChannels(colors);
-}
-
-void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::UpdateSingleLED(int /* led */)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Arctic::DeviceUpdateMode()
-{
-    /*---------------------------------------------------------*\
-    | This device does not support mode updates                 |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Arctic::KeepaliveThreadFunction()
-{
-    std::chrono::nanoseconds sleep_time;
-
-    while(keepalive_thread_run.load())
-    {
-        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
-            std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
-        }
-        else
-        {
-            std::this_thread::sleep_for(sleep_time);
-        }
-    }
-}
@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Arctic.h                   |
-|                                           |
-|  Generic RGB Interface for Arctic devices |
-|                                           |
-|  Armin Wolf (Wer-Wolf) 27/08/2023         |
-\*-----------------------------------------*/
-
-#pragma once
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "serial_port.h"
-#include <chrono>
-#include <thread>
-
-class RGBController_Arctic : public RGBController
-{
-public:
-    RGBController_Arctic(ArcticController* controller_ptr);
-    ~RGBController_Arctic();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        KeepaliveThreadFunction();
-
-private:
-    ArcticController*                                   controller;
-    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
-    std::atomic<bool>                                   keepalive_thread_run;
-    std::thread                                         keepalive_thread;
-};
-
@@ -2,12 +2,9 @@
 #include "AsusAuraCoreController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
-#include "RGBController_AsusAuraCoreLaptop.h"
 #include <hidapi/hidapi.h>

-#define AURA_CORE_VID                   0x0B05
-
-#define AURA_STRIX_SCAR_15_PID          0x19B6
+#define AURA_CORE_VID 0x0B05

 /******************************************************************************************\
 *                                                                                          *
@@ -17,14 +14,13 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
+void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
+    if( dev )
    {
-        AuraCoreController*     controller                  = new AuraCoreController(dev, info->path);
-        RGBController_AuraCore* rgb_controller              = new RGBController_AuraCore(controller);
+        AuraCoreController*     controller     = new AuraCoreController(dev, info->path);
+        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
        // Constructor sets the name
        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
        {
@@ -37,22 +33,6 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*n
    }
 }

-void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
-        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-
-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);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, AURA_STRIX_SCAR_15_PID,  0xFF31, 0x79);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17",      DetectAsusAuraCoreLaptopControllers,    AURA_CORE_VID, 0x1866,                  0xFF31, 0x79);
+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);
@@ -1,358 +0,0 @@
-/*---------------------------------------------------------------------*\
-|  AsusAuraCoreLaptopController.cpp                                     |
-|                                                                       |
-|  Driver for Asus Aura Core Laptop USB Controller                      |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
-
-#include "AsusAuraCoreLaptopController.h"
-
-#include "SettingsManager.h"
-
-static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
-                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
-                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
-{
-/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
-            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
-
-/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
-            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
-
-/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
-            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
-
-/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
-            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
-
-/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
-            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
-
-/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
-            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
-
-/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
-           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
-
-/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
-           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
-
-/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
-           137, 159, 160, 161, 142, 175,   2,   3,   4,   5,
-
-/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
-             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
-
-};
-
-static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
-{
-    "Logo",
-    ZONE_EN_KEYBOARD,
-    "Lightbar",
-    "Lid Edges"
-};
-
-static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
-{
-    " when booting",
-    " when awake",
-    " when sleeping",
-    " when off",
-};
-
-AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
-{
-    const uint8_t sz    = HID_MAX_STR;
-    wchar_t       tmp[sz];
-
-    dev                 = dev_handle;
-    location            = path;
-
-    hid_get_manufacturer_string(dev, tmp, sz);
-    std::wstring wName = std::wstring(tmp);
-    device_name = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmp, sz);
-    wName = std::wstring(tmp);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    SetPowerConfigFromJSON();
-}
-
-AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
-{
-    hid_close(dev);
-}
-
-std::string AsusAuraCoreLaptopController::GetDeviceName()
-{
-    return device_name;
-}
-
-std::string AsusAuraCoreLaptopController::GetSerial()
-{
-    const uint8_t sz    = HID_MAX_STR;
-    wchar_t       tmp[sz];
-
-    int ret             = hid_get_serial_number_string(dev, tmp, sz);
-
-    if (ret != 0)
-    {
-        LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str());
-        return("");
-    }
-
-    std::wstring w_tmp  = std::wstring(tmp);
-    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
-
-    return serial;
-}
-
-std::string AsusAuraCoreLaptopController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction)
-{
-    bool needs_update       = !( (current_mode          == mode         )   &&
-                                 (current_speed         == speed        )   &&
-                                 (current_brightness    == brightness   )   &&
-                                 (current_c1            == color1       )   &&
-                                 (current_c2            == color2       )   &&
-                                 (current_random        == random       )   &&
-                                 (current_direction     == direction    )   );
-
-    if(needs_update)
-    {
-        current_mode        = mode;
-        current_speed       = speed;
-        current_brightness  = brightness;
-        current_c1          = color1;
-        current_c2          = color2;
-        current_random      = random;
-        current_direction   = direction;
-
-        SendUpdate();
-        SendBrightness();
-    }
-}
-
-void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
-{
-    /*---------------------------------------------------------*\
-    | The keyboard zone is a set of 168 keys (indexed from 0)   |
-    |   sent in 11 packets of 16 triplets. The Lid and Lightbar |
-    |   zones are sent in one final packet afterwards.          |
-    \*---------------------------------------------------------*/
-    const uint8_t  key_set                                  = 167;
-    const uint8_t  led_count                                = 178;
-    const uint16_t map_size                                 = 3 * led_count;
-    const uint8_t leds_per_packet                           = 16;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
-                                                                0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
-    uint8_t key_buf[map_size];
-
-    memset(key_buf, 0, map_size);
-
-    for(size_t led_index = 0; led_index < colors.size(); led_index++)
-    {
-        uint16_t offset         = 3 * packet_map[led_index];
-
-        key_buf[offset]         = RGBGetRValue(colors[led_index]);
-        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
-        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
-    }
-
-    for(size_t i = 0; i < key_set; i+=leds_per_packet)
-    {
-        uint8_t leds_remaining  = key_set - i;
-
-        if(leds_remaining < leds_per_packet)
-        {
-            buffer[07]          = leds_remaining;
-        }
-
-        buffer[06]              = i;
-        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
-
-        hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-    }
-
-    buffer[4] = 0x04;
-    buffer[5] = 0x00;
-    buffer[6] = 0x00;
-    buffer[7] = 0x00;
-    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-void AsusAuraCoreLaptopController::SendBrightness()
-{
-    const uint8_t index                                     = 2;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
-
-    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
-    buffer[4] = current_brightness;
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-void AsusAuraCoreLaptopController::SendUpdate()
-{
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_UPDATE };
-
-    buffer[ASUSAURACORELAPTOP_ZONE_BYTE]                    = 0;
-    buffer[ASUSAURACORELAPTOP_MODE_BYTE]                    = current_mode;
-    buffer[ASUSAURACORELAPTOP_R1_BYTE]                      = RGBGetRValue(current_c1);
-    buffer[ASUSAURACORELAPTOP_G1_BYTE]                      = RGBGetGValue(current_c1);
-    buffer[ASUSAURACORELAPTOP_B1_BYTE]                      = RGBGetBValue(current_c1);
-    buffer[ASUSAURACORELAPTOP_SPEED_BYTE]                   = current_speed;
-    buffer[ASUSAURACORELAPTOP_DIRECTION_BYTE]               = current_direction;
-    buffer[ASUSAURACORELAPTOP_DATA_BYTE]                    = current_random;
-    buffer[ASUSAURACORELAPTOP_R2_BYTE]                      = RGBGetRValue(current_c2);
-    buffer[ASUSAURACORELAPTOP_G2_BYTE]                      = RGBGetGValue(current_c2);
-    buffer[ASUSAURACORELAPTOP_B2_BYTE]                      = RGBGetBValue(current_c2);
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-
-    SendApply();
-}
-
-void AsusAuraCoreLaptopController::SendApply()
-{
-    const uint8_t index                                     = 2;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_APPLY };
-
-    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-void AsusAuraCoreLaptopController::SendSet()
-{
-    const uint8_t index                                     = 2;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_SET };
-
-    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-std::vector<p_state> AsusAuraCoreLaptopController::PowerConfigArray()
-{
-    std::vector<p_state>    temp;
-
-    for(uint8_t zone_index = 0; zone_index < ASUSAURACORELAPTOP_POWER_ZONES; zone_index++)
-    {
-        for(uint8_t state_index = 0; state_index < ASUSAURACORELAPTOP_POWER_STATES; state_index++)
-        {
-            p_state new_state;
-
-            new_state.zone  = power_zones[zone_index] + power_states[state_index];
-            new_state.state = true;
-
-            temp.push_back(new_state);
-        }
-    }
-
-    return temp;
-}
-
-void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
-{
-    std::vector<p_state> power_config   = PowerConfigArray();
-    const std::string section_power     = "PowerConfig";
-    const std::string detector_name     = "Asus Aura Core Laptop";
-    SettingsManager* settings_manager   = ResourceManager::get()->GetSettingsManager();
-    json device_settings                = settings_manager->GetSettings(detector_name);
-
-    /*---------------------------------------------------------*\
-    | Get Power state config from the settings manager          |
-    |   If PowerConfig is not found then write it to settings   |
-    \*---------------------------------------------------------*/
-    if(!device_settings.contains(section_power))
-    {
-        json pcfg;
-
-        for(size_t i = 0; i < power_config.size(); i++)
-        {
-            pcfg[power_config[i].zone]  = power_config[i].state;
-        }
-
-        device_settings[section_power]  = pcfg;
-        settings_manager->SetSettings(detector_name, device_settings);
-        settings_manager->SaveSettings();
-    }
-    else
-    {
-        for(size_t i = 0; i < power_config.size(); i++)
-        {
-            std::string key_name        = power_config[i].zone;
-
-            if(device_settings[section_power].contains(key_name))
-            {
-                power_config[i].state   = device_settings[section_power][key_name];
-                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
-            }
-        }
-    }
-
-    /*-----------------------------------------------------------------------------*\
-    | Power state flags are packed in zones but the order is inconsistent.          |
-    |   With thanks to AsusCtl for helping to decipher the packet captures          |
-    |   https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150  |
-    \*-----------------------------------------------------------------------------*/
-    bool flag_array[] =
-    {
-        power_config[0].state,      power_config[4].state,
-        power_config[1].state,      power_config[5].state,
-        !power_config[2].state,     !power_config[6].state,
-        !power_config[3].state,     !power_config[7].state,
-
-        false,                      power_config[8].state,
-        power_config[9].state,      !power_config[10].state,
-        !power_config[11].state,    false,
-        false,                      false,
-
-        power_config[12].state,     power_config[13].state,
-        !power_config[14].state,    !power_config[15].state
-    };
-
-    uint32_t flags      = PackPowerFlags(flag_array);
-    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
-    SendPowerConfig(flags);
-}
-
-void AsusAuraCoreLaptopController::SendPowerConfig(uint32_t flags)
-{
-    const uint8_t index                                     = 6;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_POWER, 0x01, 0x00, 0x00, 0x0F };
-
-    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
-
-    buffer[3] = flags           & 0xFF;
-    buffer[4] = (flags >> 8)    & 0xFF;
-    buffer[5] = (flags >> 16)   & 0xFF;
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-uint32_t AsusAuraCoreLaptopController::PackPowerFlags(bool flags[])
-{
-    uint32_t temp = {};
-    const uint8_t length = 32;
-
-    for (size_t i = 0; i < length; ++i)
-    {
-        uint32_t flag = {flags[i]};
-        flag <<= i;
-        temp |= flag;
-    }
-
-    return temp;
-}
@@ -1,134 +0,0 @@
-/*---------------------------------------------------------------------*\
-|  AsusAuraCoreLaptopController.h                                       |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-#include "LogManager.h"
-#include "RGBController.h"
-#include "ResourceManager.h"
-#include "RGBControllerKeyNames.h"
-
-#pragma once
-
-#define NA                                      0xFFFFFFFF
-#define HID_MAX_STR                             255
-#define ASUSAURACORELAPTOP_TIMEOUT              250
-#define ASUSAURACORELAPTOP_READ_PACKET_SIZE     64
-#define ASUSAURACORELAPTOP_WRITE_PACKET_SIZE    64   //Buffer requires a prepended ReportID hence + 1
-
-#define ASUSAURACORELAPTOP_KEYCOUNT             91
-#define ASUSAURACORELAPTOP_KEY_WIDTH            18
-#define ASUSAURACORELAPTOP_KEY_HEIGHT           7
-#define ASUSAURACORELAPTOP_LIGHTBARCOUNT        6
-#define ASUSAURACORELAPTOP_LIDCOUNT             3
-#define ASUSAURACORELAPTOP_POWER_ZONES          4
-#define ASUSAURACORELAPTOP_POWER_STATES         4
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255
-
-enum
-{
-    ASUSAURACORELAPTOP_MODE_OFF                 = 0x00, //Turn off - All leds off
-    ASUSAURACORELAPTOP_MODE_DIRECT              = 0xFF, //Direct Led Control - Independently set LEDs in zone
-    ASUSAURACORELAPTOP_MODE_STATIC              = 0x00, //Static Mode - Set entire zone to a single color.
-    ASUSAURACORELAPTOP_MODE_BREATHING           = 0x01, //Breathing Mode - Fades between fully off and fully on.
-    ASUSAURACORELAPTOP_MODE_SPECTRUM            = 0x02, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
-    ASUSAURACORELAPTOP_MODE_RAINBOW             = 0x03, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
-    ASUSAURACORELAPTOP_MODE_FLASHING            = 0x0A, //Flashing Mode - Abruptly changing between fully off and fully on.
-
-    /*-------------------------------------------------*\
-    | Modes not implemented in the Armoury Crate        |
-    |   OEM software that were discovered.              |
-    \*-------------------------------------------------*/
-    ASUSAURACORELAPTOP_MODE_STARRY_NIGHT        = 0x04, //Starry Night Mode
-    ASUSAURACORELAPTOP_MODE_RAIN                = 0x05, //Rain Mode
-    ASUSAURACORELAPTOP_MODE_REACT_FADE          = 0x06, //Reactive Fade Mode
-    ASUSAURACORELAPTOP_MODE_REACT_LASER         = 0x07, //Reactive Laser Mode
-    ASUSAURACORELAPTOP_MODE_REACT_RIPPLE        = 0x08, //Reactive Ripple Mode
-    ASUSAURACORELAPTOP_MODE_COMET               = 0x0B, //Comet Mode
-    ASUSAURACORELAPTOP_MODE_FLASHNDASH          = 0x0C, //Flash n Dash Mode
-    ASUSAURACORELAPTOP_MODE_KEYSTONE            = 0x0D, //Keystone Mode
-};
-
-enum
-{
-    ASUSAURACORELAPTOP_ZONE_BYTE                = 2,
-    ASUSAURACORELAPTOP_MODE_BYTE                = 3,
-    ASUSAURACORELAPTOP_R1_BYTE                  = 4,
-    ASUSAURACORELAPTOP_G1_BYTE                  = 5,
-    ASUSAURACORELAPTOP_B1_BYTE                  = 6,
-    ASUSAURACORELAPTOP_SPEED_BYTE               = 7,
-    ASUSAURACORELAPTOP_DIRECTION_BYTE           = 8,
-    ASUSAURACORELAPTOP_DATA_BYTE                = 9,
-    ASUSAURACORELAPTOP_R2_BYTE                  = 10,
-    ASUSAURACORELAPTOP_G2_BYTE                  = 11,
-    ASUSAURACORELAPTOP_B2_BYTE                  = 12,
-};
-
-enum
-{
-    ASUSAURACORELAPTOP_REPORT_ID                = 0x5D,
-    ASUSAURACORELAPTOP_CMD_BRIGHTNESS           = 0xBA,
-    ASUSAURACORELAPTOP_CMD_DIRECT               = 0xBC,
-    ASUSAURACORELAPTOP_CMD_POWER                = 0xBD,
-    ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
-    ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
-    ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
-};
-
-enum
-{
-    ASUSAURACORELAPTOP_SPEED_SLOWEST            = 0xE1, // Slowest speed
-    ASUSAURACORELAPTOP_SPEED_NORMAL             = 0xEB, // Normal speed
-    ASUSAURACORELAPTOP_SPEED_FASTEST            = 0xF5, // Fastest speed
-};
-
-struct p_state
-{
-    std::string zone;
-    bool        state;
-};
-
-class AsusAuraCoreLaptopController
-{
-public:
-    AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
-    ~AsusAuraCoreLaptopController();
-
-    std::string             GetDeviceName();
-    std::string             GetSerial();
-    std::string             GetLocation();
-
-    void                    SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
-    void                    SetLedsDirect(std::vector<RGBColor> colors);
-private:
-    std::string             device_name;
-    std::string             location;
-    hid_device*             dev;
-
-    uint8_t                 current_mode;
-    uint8_t                 current_speed;
-    uint8_t                 current_direction;
-
-    RGBColor                current_c1;
-    RGBColor                current_c2;
-    uint8_t                 current_brightness;
-    uint8_t                 current_random;
-
-    void                    SendApply();
-    void                    SendBrightness();
-    void                    SendSet();
-    void                    SendUpdate();
-
-    void                    SetPowerConfigFromJSON();
-    void                    SendPowerConfig(uint32_t flags);
-    uint32_t                PackPowerFlags(bool flags[]);
-    std::vector<p_state>    PowerConfigArray();
-};
@@ -44,39 +44,39 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt

 void RGBController_AuraCore::SetupKeyboard()
 {
-    name                    = "ASUS Aura Keyboard";
-    vendor                  = "ASUS";
-    type                    = DEVICE_TYPE_KEYBOARD;
-    description             = "ASUS Aura Core Device";
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Core Device";

    mode Static;
-    Static.name             = "Static";
-    Static.value            = AURA_CORE_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode       = MODE_COLORS_PER_LED;
+    Static.name       = "Static";
+    Static.value      = AURA_CORE_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Static);

    mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = AURA_CORE_MODE_BREATHING;
-    Breathing.flags         = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode    = MODE_COLORS_PER_LED;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_CORE_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Breathing);

    mode ColorCycle;
-    ColorCycle.name         = "Color Cycle";
-    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags        = 0;
-    ColorCycle.color_mode   = MODE_COLORS_NONE;
+    ColorCycle.name       = "Color Cycle";
+    ColorCycle.value      = AURA_CORE_MODE_SPECTRUM_CYCLE;
+    ColorCycle.flags      = 0;
+    ColorCycle.color_mode = MODE_COLORS_NONE;
    modes.push_back(ColorCycle);
 }

 void RGBController_AuraCore::SetupGA15DH()
 {
-    name                    = "ASUS Aura GA15DH";
-    vendor                  = "ASUS";
-    type                    = DEVICE_TYPE_LEDSTRIP;
-    description             = "ASUS Aura Core Device";
+    name        = "ASUS Aura GA15DH";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    description = "ASUS Aura Core Device";

    mode Static;
    Static.name             = "Static";
@@ -160,10 +160,10 @@ void RGBController_AuraCore::SetupGA15DH()
    modes.push_back(Irradiation);

    mode Direct;
-    Static.name             = "Direct";
-    Static.value            = AURA_CORE_MODE_DIRECT;
-    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode       = MODE_COLORS_PER_LED;
+    Static.name       = "Direct";
+    Static.value      = AURA_CORE_MODE_DIRECT;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Static);
 }

@@ -312,6 +312,11 @@ void RGBController_AuraCore::UpdateSingleLED(int led)
    controller->SendApply();
 }

+void RGBController_AuraCore::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraCore::DeviceUpdateMode()
 {
    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
@@ -27,6 +27,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -1,495 +0,0 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_AsusAuraCoreLaptop.cpp                                 |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
-
-#include "RGBController_AsusAuraCoreLaptop.h"
-
-static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
-{
-    {  NA,  NA,  86,  87,  88,  89,  90,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
-    {   0,  NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  NA },
-    {  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA },
-    {  31,  NA,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  NA,  45,  NA },
-    {  46,  NA,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  NA,  58,  NA,  59,  NA },
-    {  60,  NA,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  NA,  72,  NA,  73,  NA },
-    {  74,  75,  76,  77,  NA,  NA,  NA,  78,  NA,  NA,  NA,  79,  80,  81,  82,  83,  84,  85 }
-};
-
-static const char *led_names[] =
-{
-    KEY_EN_ESCAPE,              //00
-    KEY_EN_F1,
-    KEY_EN_F2,
-    KEY_EN_F3,
-    KEY_EN_F4,
-    KEY_EN_F5,
-    KEY_EN_F6,
-    KEY_EN_F7,
-    KEY_EN_F8,
-    KEY_EN_F9,
-    KEY_EN_F10,                 //10
-    KEY_EN_F11,
-    KEY_EN_F12,
-    KEY_EN_DELETE,
-
-    KEY_EN_BACK_TICK,
-    KEY_EN_1,
-    KEY_EN_2,
-    KEY_EN_3,
-    KEY_EN_4,
-    KEY_EN_5,
-    KEY_EN_6,                   //20
-    KEY_EN_7,
-    KEY_EN_8,
-    KEY_EN_9,
-    KEY_EN_0,
-    KEY_EN_MINUS,
-    KEY_EN_EQUALS,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_BACKSPACE,
-    KEY_EN_MEDIA_PLAY_PAUSE,    //30
-
-    KEY_EN_TAB,
-    KEY_EN_Q,
-    KEY_EN_W,
-    KEY_EN_E,
-    KEY_EN_R,
-    KEY_EN_T,
-    KEY_EN_Y,
-    KEY_EN_U,
-    KEY_EN_I,
-    KEY_EN_O,                   //40
-    KEY_EN_P,
-    KEY_EN_LEFT_BRACKET,
-    KEY_EN_RIGHT_BRACKET,
-    KEY_EN_ANSI_BACK_SLASH,
-    KEY_EN_MEDIA_STOP,
-
-    KEY_EN_CAPS_LOCK,
-    KEY_EN_A,
-    KEY_EN_S,
-    KEY_EN_D,
-    KEY_EN_F,                   //50
-    KEY_EN_G,
-    KEY_EN_H,
-    KEY_EN_J,
-    KEY_EN_K,
-    KEY_EN_L,
-    KEY_EN_SEMICOLON,
-    KEY_EN_QUOTE,
-    KEY_EN_ANSI_ENTER,
-    KEY_EN_MEDIA_PREVIOUS,
-
-    KEY_EN_LEFT_SHIFT,          //60
-    KEY_EN_Z,
-    KEY_EN_X,
-    KEY_EN_C,
-    KEY_EN_V,
-    KEY_EN_B,
-    KEY_EN_N,
-    KEY_EN_M,
-    KEY_EN_COMMA,
-    KEY_EN_PERIOD,
-    KEY_EN_FORWARD_SLASH,       //70
-    KEY_EN_RIGHT_SHIFT,
-    KEY_EN_UP_ARROW,
-    KEY_EN_MEDIA_NEXT,
-
-    KEY_EN_LEFT_CONTROL,
-    KEY_EN_LEFT_FUNCTION,
-    KEY_EN_LEFT_WINDOWS,
-    KEY_EN_LEFT_ALT,
-    KEY_EN_SPACE,
-    KEY_EN_RIGHT_ALT,
-    KEY_EN_RIGHT_CONTROL,       //80
-    KEY_EN_LEFT_ARROW,
-    KEY_EN_DOWN_ARROW,
-    KEY_EN_RIGHT_ARROW,
-    KEY_EN_PRINT_SCREEN,
-    "Asus Keystone",
-
-    KEY_EN_MEDIA_VOLUME_DOWN,
-    KEY_EN_MEDIA_VOLUME_UP,
-    "Key: Mic On/Off",
-    "Key: HyperFan",
-    "Key: Armoury Crate",       //90
-
-    "Lightbar LED 1",
-    "Lightbar LED 2",
-    "Lightbar LED 3",
-    "Lightbar LED 4",
-    "Lightbar LED 5",
-    "Lightbar LED 6",
-
-    "Logo",
-    "Lid Left",
-    "Lid Right",                //99
-};
-
-/**------------------------------------------------------------------*\
-    @name AsusAuraCoreLaptop
-    @category DEVICE_TYPE_KEYBOARD
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraCoreLaptopControllers
-    @comment Power profiles for this controller are set to `On` for all power
-        state and scan be adjusted in the JSON config file.
-
-        For each zone available LEDs can be set as `On = true` or `Off = false` when
-        * Booting
-        * Awake (Normal Usage)
-        * Sleeping
-        * Shutdown / Power Off
-\*-------------------------------------------------------------------*/
-
-RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "Asus Aura Core Laptop";
-    vendor                      = "Asus";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = controller->GetDeviceName();
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ASUSAURACORELAPTOP_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ASUSAURACORELAPTOP_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(Static.colors_max);
-    Static.brightness_min       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Static.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Static.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Static.speed_min            = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Static.speed_max            = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.speed                = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ASUSAURACORELAPTOP_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(Breathing.colors_min);
-    Breathing.brightness_min    = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Breathing.brightness        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Breathing.speed_min         = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Breathing.speed_max         = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed             = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name               = "Flashing";
-    Flashing.value              = ASUSAURACORELAPTOP_MODE_FLASHING;
-    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Flashing.colors_min         = 1;
-    Flashing.colors_max         = 1;
-    Flashing.colors.resize(Flashing.colors_max);
-    Flashing.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Flashing.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Flashing.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Flashing.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Flashing.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Flashing.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Flashing);
-
-    mode Spectrum;
-    Spectrum.name               = "Spectrum Cycle";
-    Spectrum.value              = ASUSAURACORELAPTOP_MODE_SPECTRUM;
-    Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Spectrum.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Spectrum.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Spectrum.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Spectrum.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Spectrum.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Spectrum.color_mode         = MODE_COLORS_NONE;
-    Spectrum.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Spectrum);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow Wave";
-    Rainbow.value               = ASUSAURACORELAPTOP_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    Rainbow.brightness_min      = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Rainbow.brightness_max      = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Rainbow.brightness          = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Rainbow.speed_min           = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Rainbow.speed_max           = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Rainbow.color_mode          = MODE_COLORS_NONE;
-    Rainbow.speed               = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Rainbow);
-
-    mode Starry;
-    Starry.name                 = "Starry Night";
-    Starry.value                = ASUSAURACORELAPTOP_MODE_STARRY_NIGHT;
-    Starry.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Starry.colors_min           = 1;
-    Starry.colors_max           = 2;
-    Starry.colors.resize(Starry.colors_min);
-    Starry.brightness_min       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Starry.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Starry.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Starry.speed_min            = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Starry.speed_max            = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Starry.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Starry.speed                = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Starry);
-
-    mode Rain;
-    Rain.name                   = "Rain";
-    Rain.value                  = ASUSAURACORELAPTOP_MODE_RAIN;
-    Rain.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rain.brightness_min         = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Rain.brightness_max         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Rain.brightness             = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Rain.speed_min              = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Rain.speed_max              = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Rain.color_mode             = MODE_COLORS_NONE;
-    Rain.speed                  = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Rain);
-
-    mode ReactFade;
-    ReactFade.name              = "Reactive - Fade";
-    ReactFade.value             = ASUSAURACORELAPTOP_MODE_REACT_FADE;
-    ReactFade.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    ReactFade.colors_min        = 1;
-    ReactFade.colors_max        = 1;
-    ReactFade.colors.resize(ReactFade.colors_max);
-    ReactFade.brightness_min    = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    ReactFade.brightness_max    = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactFade.brightness        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactFade.speed_min         = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    ReactFade.speed_max         = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    ReactFade.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    ReactFade.speed             = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(ReactFade);
-
-    mode ReactLaser;
-    ReactLaser.name             = "Reactive - Laser";
-    ReactLaser.value            = ASUSAURACORELAPTOP_MODE_REACT_LASER;
-    ReactLaser.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    ReactLaser.colors_min       = 1;
-    ReactLaser.colors_max       = 1;
-    ReactLaser.colors.resize(ReactLaser.colors_max);
-    ReactLaser.brightness_min   = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    ReactLaser.brightness_max   = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactLaser.brightness       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactLaser.speed_min        = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    ReactLaser.speed_max        = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    ReactLaser.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    ReactLaser.speed            = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(ReactLaser);
-
-    mode ReactRipple;
-    ReactRipple.name            = "Reactive - Ripple";
-    ReactRipple.value           = ASUSAURACORELAPTOP_MODE_REACT_RIPPLE;
-    ReactRipple.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    ReactRipple.colors_min      = 1;
-    ReactRipple.colors_max      = 1;
-    ReactRipple.colors.resize(ReactRipple.colors_max);
-    ReactRipple.brightness_min  = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    ReactRipple.brightness_max  = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactRipple.brightness      = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    ReactRipple.speed_min       = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    ReactRipple.speed_max       = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    ReactRipple.color_mode      = MODE_COLORS_MODE_SPECIFIC;
-    ReactRipple.speed           = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(ReactRipple);
-
-    mode Comet;
-    Comet.name                  = "Comet";
-    Comet.value                 = ASUSAURACORELAPTOP_MODE_COMET;
-    Comet.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
-    Comet.colors_min            = 1;
-    Comet.colors_max            = 1;
-    Comet.colors.resize(Comet.colors_max);
-    Comet.brightness_min        = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Comet.brightness_max        = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Comet.brightness            = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Comet.speed_min             = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Comet.speed_max             = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Comet.speed                 = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Comet);
-
-    mode FlashNDash;
-    FlashNDash.name             = "Flash N Dash";
-    FlashNDash.value            = ASUSAURACORELAPTOP_MODE_FLASHNDASH;
-    FlashNDash.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
-    FlashNDash.colors_min       = 1;
-    FlashNDash.colors_max       = 1;
-    FlashNDash.colors.resize(FlashNDash.colors_max);
-    FlashNDash.brightness_min   = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    FlashNDash.brightness_max   = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    FlashNDash.brightness       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    FlashNDash.speed_min        = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    FlashNDash.speed_max        = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    FlashNDash.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    FlashNDash.speed            = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(FlashNDash);
-
-    mode Keystone;
-    Keystone.name               = "Keystone";
-    Keystone.value              = ASUSAURACORELAPTOP_MODE_KEYSTONE;
-    Keystone.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Keystone.colors_min         = 1;
-    Keystone.colors_max         = 1;
-    Keystone.colors.resize(Keystone.colors_max);
-    Keystone.brightness_min     = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Keystone.brightness_max     = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Keystone.brightness         = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Keystone.speed_min          = ASUSAURACORELAPTOP_SPEED_SLOWEST;
-    Keystone.speed_max          = ASUSAURACORELAPTOP_SPEED_FASTEST;
-    Keystone.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Keystone.speed              = ASUSAURACORELAPTOP_SPEED_NORMAL;
-    modes.push_back(Keystone);
-
-    mode Off;
-    Off.name                    = "Off";
-    Off.value                   = ASUSAURACORELAPTOP_MODE_OFF;
-    Off.color_mode              = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    Init_Controller();
-    SetupZones();
-}
-
-RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
-{
-    delete controller;
-}
-
-void RGBController_AsusAuraCoreLaptop::Init_Controller()
-{
-    /*-------------------------------------------------*\
-    | Create the keyboard zone and add the matix map    |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = "Keyboard Zone";
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_max            = ASUSAURACORELAPTOP_KEYCOUNT;
-    KB_zone.leds_count          = ASUSAURACORELAPTOP_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = ASUSAURACORELAPTOP_KEY_HEIGHT;
-    KB_zone.matrix_map->width   = ASUSAURACORELAPTOP_KEY_WIDTH;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    zone lightbar;
-    lightbar.name               = "Lightbar Zone";
-    lightbar.type               = ZONE_TYPE_LINEAR;
-    lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
-    lightbar.matrix_map         = NULL;
-
-    zones.push_back(lightbar);
-
-    zone lid;
-    lid.name                    = "Lid Zone";
-    lid.type                    = ZONE_TYPE_LINEAR;
-    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
-    lid.matrix_map              = NULL;
-
-    zones.push_back(lid);
-}
-
-void RGBController_AsusAuraCoreLaptop::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        int zone_offset = leds.size();
-
-        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
-        {
-            led new_led;
-            new_led.value   = led_index + zone_offset;
-            new_led.name    = led_names[new_led.value];
-            leds.push_back(new_led);
-        }
-    }
-
-    SetupColors();
-}
-
-void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
-{
-    controller->SetLedsDirect(colors);
-}
-
-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
-    {
-        colour.push_back(zones[zone].colors[i]);
-    }
-
-    controller->SetLedsDirect(colour);
-}
-
-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
-{
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
-
-    controller->SetLedsDirect(colour);
-}
-
-void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
-{
-    mode set_mode       = modes[active_mode];
-
-    if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
-    {
-        return;
-    }
-    uint8_t random      = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
-    RGBColor color1     = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
-    RGBColor color2     = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
-
-    controller->SetMode(set_mode.value, set_mode.speed, set_mode.brightness, color1, color2, random, set_mode.direction );
-}
@@ -1,35 +0,0 @@
-/*---------------------------------------------------------------------*\
-|  RGBController_AsusAuraCoreLaptop.h                                   |
-|                                                                       |
-|  Driver for AsusAuraCoreLaptop USB Controller                         |
-|                                                                       |
-|  Chris M (Dr_No)          28 Jul 2022                                 |
-|                                                                       |
-\*---------------------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "AsusAuraCoreLaptopController.h"
-
-class RGBController_AsusAuraCoreLaptop : public RGBController
-{
-public:
-    RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController* controller_ptr);
-    ~RGBController_AsusAuraCoreLaptop();
-
-    void                SetupZones();
-    void                ResizeZone(int zone, int new_size);
-
-    void                DeviceUpdateLEDs();
-    void                UpdateZoneLEDs(int zone);
-    void                UpdateSingleLED(int led);
-
-    void                DeviceUpdateMode();
-
-private:
-    void                Init_Controller();
-
-    AsusAuraCoreLaptopController*      controller;
-};
@@ -65,12 +65,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
    }
 } /* DetectAsusAuraGPUControllers() */

-/*-----------------------------------------*\
-|  NVidia GPUs                              |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
@@ -91,46 +86,36 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G"            , DetectAs
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G"                , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming"   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G", DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);
-
-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix"                        , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC"            , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC"           , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
@@ -183,6 +183,11 @@ void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AuraGPU::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraGPU::DeviceUpdateMode()
 {
    int new_mode       = modes[active_mode].value;
@@ -25,6 +25,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -15,7 +15,6 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    unsigned char num_total_mainboard_leds  = config_table[0x1B];
    unsigned char num_rgb_headers           = config_table[0x1D];
    unsigned char num_addressable_headers   = config_table[0x02];
-    unsigned char effect_channel            = 0;

    if(num_total_mainboard_leds < num_rgb_headers)
    {
@@ -25,18 +24,14 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    /*-----------------------------------------------------*\
    | Add mainboard device                                  |
    \*-----------------------------------------------------*/
-    if(num_total_mainboard_leds > 0)
-    {
-        device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
-        effect_channel++;
-    }
+    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});

    /*-----------------------------------------------------*\
    | Add addressable devices                               |
    \*-----------------------------------------------------*/
    for(int i = 0; i < num_addressable_headers; i++)
    {
-        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
+        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
    }
 }

@@ -86,24 +81,11 @@ void AuraMainboardController::SetMode
    unsigned char   grn,
    unsigned char   blu
    )
-{
-    SetMode(channel, mode, red, grn, blu, false);
-}
-
-void AuraMainboardController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu,
-    bool            shutdown_effect
-    )
 {
    this->mode = mode;
    RGBColor color = ToRGBColor(red, grn, blu);

-    SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
+    SendEffect(device_info[channel].effect_channel, mode);
    if(mode == AURA_MODE_DIRECT)
    {
        return;
@@ -129,8 +111,7 @@ void AuraMainboardController::SetMode
        channel,
        start_led,
        device_info[channel].num_leds,
-        led_data,
-        shutdown_effect
+        led_data
    );
 }

@@ -142,8 +123,7 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
 void AuraMainboardController::SendEffect
    (
    unsigned char   channel,
-    unsigned char   mode,
-    bool            shutdown_effect
+    unsigned char   mode
    )
 {
    unsigned char usb_buf[65];
@@ -160,7 +140,7 @@ void AuraMainboardController::SendEffect
    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
    usb_buf[0x02]   = channel;
    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;
    usb_buf[0x05]   = mode;

    /*-----------------------------------------------------*\
@@ -174,8 +154,7 @@ void AuraMainboardController::SendColor
    unsigned char   /*channel*/,
    unsigned char   start_led,
    unsigned char   led_count,
-    unsigned char*  led_data,
-    bool            shutdown_effect
+    unsigned char*  led_data
    )
 {
    unsigned short  mask = GetMask(start_led, led_count);
@@ -193,7 +172,7 @@ void AuraMainboardController::SendColor
    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
    usb_buf[0x02]   = mask >> 8;
    usb_buf[0x03]   = mask & 0xff;
-    usb_buf[0x04]   = shutdown_effect ? 0x01 : 0x00;
+    usb_buf[0x04]   = 0x00;

    /*-----------------------------------------------------*\
    | Copy in color data bytes                              |
@@ -44,28 +44,15 @@ public:
        unsigned char   blu
        );

-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        bool            shutdown_effect
-        );
-
-    void SendCommit();
-
 private:
    unsigned int mode;

    unsigned short GetMask(int start, int size);
-
+    
    void SendEffect
        (
        unsigned char   channel,
-        unsigned char   mode,
-        bool            shutdown_effect
+        unsigned char   mode
        );

    void SendColor
@@ -73,7 +60,8 @@ private:
        unsigned char   channel,
        unsigned char   start_led,
        unsigned char   led_count,
-        unsigned char*  led_data,
-        bool            shutdown_effect
+        unsigned char*  led_data
        );
+
+    void SendCommit();
 };
@@ -83,19 +83,17 @@ void AuraMonitorController::UpdateLed
    usb_buf[0x02]   = 0xA1;
    usb_buf[0x03]   = 0x80;

-    unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
-
-    usb_buf[0x04]   = offset + led * 3;
+    usb_buf[0x04]   = 16 + led * 3;
    usb_buf[0x05]   = red;
    
    hid_send_feature_report(dev, usb_buf, 8);

-    usb_buf[0x04]   = offset + led * 3 + 1;
+    usb_buf[0x04]   = 16 + led * 3 + 1;
    usb_buf[0x05]   = blue;
    
    hid_send_feature_report(dev, usb_buf, 8);

-    usb_buf[0x04]   = offset + led * 3 + 2;
+    usb_buf[0x04]   = 16 + led * 3 + 2;
    usb_buf[0x05]   = green;
    
    hid_send_feature_report(dev, usb_buf, 8);
@@ -15,11 +15,8 @@

 enum
 {
-    AURA_ROG_STRIX_XG27AQ_PID   = 0x198C,
-    AURA_ROG_STRIX_XG27AQM_PID  = 0x19BB,
-    AURA_ROG_STRIX_XG279Q_PID   = 0x1919,
-    AURA_ROG_STRIX_XG27W_PID    = 0x1933,
-    AURA_ROG_PG32UQ_PID         = 0x19B9,
+    AURA_ROG_STRIX_XG27AQ_PID    = 0x198C,
+    AURA_ROG_PG32UQ_PID          = 0x19B9,
 };


@@ -67,17 +67,15 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
            break;

        case 1:
-        case 2:
            {
                char version[9];
-                int wireless_offset = (protocol == 2 ? 14 : 13);
-                int offset = (wireless ? wireless_offset : 4);
+                int offset = (wireless ? 13 : 4);
                snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
                str = std::string(version);
            }
            break;

-        case 3:
+        case 2:
            {
                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
                str = std::string(offset, offset + 4);
@@ -85,11 +83,11 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
            }
            break;

-        case 4:
+        case 3:
            {
-                char version[16];
+                char version[9];
                int offset = (wireless ? 13 : 4);
-                snprintf(version, 16, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
+                snprintf(version, 9, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
                str = std::string(version);
            }
            break;
@@ -18,18 +18,12 @@
 #define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID          0x18B1
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID          0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID          0x18A0
-#define AURA_ROG_GLADIUS_III_PID                    0x197B
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID       0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID       0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID        0x1981
 #define AURA_ROG_CHAKRAM_WIRELESS_PID               0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID                0x18E3
 #define AURA_ROG_CHAKRAM_CORE_PID                   0x1958
-#define AURA_ROG_CHAKRAM_X_USB_PID                  0x1A18
-#define AURA_ROG_CHAKRAM_X_2_4_PID                  0x1A1A
-#define AURA_ROG_SPATHA_X_USB_PID                   0x1977
-#define AURA_ROG_SPATHA_X_2_4_PID                   0x1979
-#define AURA_ROG_SPATHA_X_DOCK_PID                  0x1979
 #define AURA_ROG_PUGIO_PID                          0x1846
 #define AURA_ROG_PUGIO_II_WIRED_PID                 0x1906
 #define AURA_ROG_PUGIO_II_WIRELESS_PID              0x1908
@@ -47,15 +41,12 @@
 #define AURA_TUF_M3_PID                             0x1910
 #define AURA_TUF_M5_PID                             0x1898

-#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID             0xFFFF
-
 enum
 {
    AURA_MOUSE_ZONE_LOGO        = 0,
    AURA_MOUSE_ZONE_SCROLL      = 1,
    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
    AURA_MOUSE_ZONE_ALL         = 3,
-    AURA_MOUSE_ZONE_DOCK        = 4,
 };

 enum
@@ -183,26 +174,13 @@ static std::map<int,mouse_type> aura_mouse_devices =
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
        }
    },
-    {
-        AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
-        {
-            255,
-            1,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
    {
        AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
        {
            255,
            1,
            0,
-            100,
+            64,
            false,
            1,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -215,7 +193,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            true,
            1,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -228,7 +206,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
            255,
            1,
            0,
-            100,
+            64,
            true,
            1,
            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
@@ -274,58 +252,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
    },
-    {
-        AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            false,
-            2,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            true,
-            2,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_USB_PID, // ROG Spatha X USB
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
-        {
-            15, // technically until 255, but unusably slow after 15
-            1,
-            0,
-            100,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
    {
        AURA_ROG_PUGIO_PID, // ROG Pugio
        {
@@ -373,9 +299,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            false,
-            4,
+            3,
            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
+            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
        }
    },
    {
@@ -529,22 +455,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
            0,
            4,
            false,
-            3,
+            2,
            { AURA_MOUSE_ZONE_LOGO },
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
    },
-    {
-        AURA_ROG_SPATHA_X_DOCK_FAKE_PID, // Asus ROG Spatha X Dock (only in wireless mode)
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_DOCK },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
 };
@@ -55,8 +55,8 @@ std::string AuraMousematController::GetVersion()
    unsigned char usb_buf_out[65];
    hid_read(dev, usb_buf_out, 65);

-    char version[9];
-    snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
+    char version[5];
+    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
    return std::string(version);
 }

@@ -110,13 +110,13 @@ void AuraMousematController::UpdateDevice
    usb_buf[0x08]   = pattern;
    usb_buf[0x09]   = 0x00;

-    for(unsigned int i = 0; i < colors.size(); i++)
+    for(int i = 0; i < colors.size(); i++)
    {
        usb_buf[0x0a + i * 3]   = RGBGetRValue(colors[i]);
        usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);
        usb_buf[0x0c + i * 3]   = RGBGetBValue(colors[i]);
    }
-
+    
    hid_write(dev, usb_buf, 65);
 }

@@ -128,7 +128,7 @@ void AuraMousematController::SaveMode()

    usb_save_buf[0x00]   = 0xEE;
    usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x03;
+    usb_save_buf[0x02]   = 0x55;

    hid_write(dev, usb_save_buf, 65);
 }
@@ -12,6 +12,9 @@

 AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
+	const int szTemp = ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR;
+	wchar_t tmpName[szTemp];
+
 	/*-----------------------------------------------------*\
 	| Add addressable devices                               |
 	|    Manually adding device info for now                |
@@ -30,7 +33,7 @@ std::string AsusAuraRyuoAIOController::GetLocation()
 	return("HID: " + location);
 }

-void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
+void AsusAuraRyuoAIOController::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu)
 {
 	/*---------------------------------------------------------*\
 	| This interface is not used in this controller however is  |
@@ -53,7 +56,7 @@ void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed,
 	}
 }

-void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
+void AsusAuraRyuoAIOController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
 {
 	/*---------------------------------------------------------*\
 	| This interface is not used in this controller however is  |
@@ -17,14 +17,11 @@
 #include <string.h>
 #include <cmath>

-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
    dev         = dev_handle;
    location    = path;
    device_pid  = pid;
-    rev_version = version;
-
-    is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
 }

 AuraTUFKeyboardController::~AuraTUFKeyboardController()
@@ -37,26 +34,6 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string clean_serial(const std::wstring& wstr)
-{
-    // Skip non-ASCII, trailing garbage in serial numbers. Required by the
-    // Scope II 96, whose original firmware outputs garbage, which even differs
-    // after computer reboots and therefore breaks OpenRGB profile matching.
-    std::string result;
-    for(auto c : wstr)
-    {
-        // Forbid control chars and anything above final printable low-ASCII.
-        if(c < 32 || c > 126)
-        {
-            break;
-        }
-
-        result += c;
-    }
-
-    return(result);
-}
-
 std::string AuraTUFKeyboardController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -67,166 +44,65 @@ std::string AuraTUFKeyboardController::GetSerialString()
        return("");
    }

-    std::wstring serial_wstring = serial_string;
-    std::string return_string = clean_serial(serial_wstring);
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());

    return(return_string);
 }

 std::string AuraTUFKeyboardController::GetVersion()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x00;
-
-        ClearResponses();
-
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        
-        switch(device_pid)
-        {
-            case AURA_TUF_K3_GAMING_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
-                break;
-            default:
-                snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
-        }
-
-        return std::string(version);
-    }
-    else
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x10;
-        usb_buf[0x02]   = 0x01;
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = 0x00; // set to 1 to get firmware version of numpad
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
-
-        unsigned char usb_buf1[65];
-        memset(usb_buf1, 0x00, sizeof(usb_buf1));
-        usb_buf1[0x00]   = 0x00;
-        usb_buf1[0x01]   = 0x12;
-        usb_buf1[0x02]   = 0x22;
-
-        ClearResponses();
-        hid_write(dev, usb_buf1, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        char version[9];
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
-
-        return std::string(version);
-    }
-}
-
-int AuraTUFKeyboardController::GetLayout()
-{
-    if(device_pid != AURA_ROG_CLAYMORE_PID)
-    {
-        unsigned char usb_buf[65];
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x12;
-        usb_buf[0x02]   = 0x12;
-
-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-
-        unsigned char usb_buf_out[65];
-        hid_read(dev, usb_buf_out, 65);
-
-        return(usb_buf_out[4] * 100 + usb_buf_out[5]);
-    }
-    else
-    {
-        switch(rev_version >> 0b1100)
-        {
-            case 1:
-                return 117;
-            case 2:
-                return 204;
-            case 3:
-                return 221;
-            case 4:
-                return 117;
-            default:
-                return 117;
-        }
-    }
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-int AuraTUFKeyboardController::GetNumpadLocation()
 {
    unsigned char usb_buf[65];
    memset(usb_buf, 0x00, sizeof(usb_buf));
-
    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x40;
-    usb_buf[0x02]   = 0x60;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x00;

-    ClearResponses();
    hid_write(dev, usb_buf, 65);

    unsigned char usb_buf_out[65];
    hid_read(dev, usb_buf_out, 65);

-    return(usb_buf_out[5] * 2 + usb_buf_out[4]);
+    char version[9];
+    if (device_pid == AURA_TUF_K3_GAMING_PID)
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
+    }
+    else
+    {
+        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
+    }
+    
+    return std::string(version);
+}
+
+int AuraTUFKeyboardController::GetLayout()
+{
+    unsigned char usb_buf[65];
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x12;
+    usb_buf[0x02]   = 0x12;
+
+    hid_write(dev, usb_buf, 65);
+
+    unsigned char usb_buf_out[65];
+    hid_read(dev, usb_buf_out, 65);
+
+    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
 }

 void AuraTUFKeyboardController::SaveMode()
 {
    unsigned char usb_save_buf[65];
+
    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));

    usb_save_buf[0x00]   = 0x00;
    usb_save_buf[0x01]   = 0x50;
    usb_save_buf[0x02]   = 0x55;

-    ClearResponses();
    hid_write(dev, usb_save_buf, 65);
-    AwaitResponse(60);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x41;
-    usb_buf[0x02]   = type;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }

 void AuraTUFKeyboardController::UpdateSingleLed
@@ -241,10 +117,11 @@ void AuraTUFKeyboardController::UpdateSingleLed
    | Set up message packet for single LED                  |
    \*-----------------------------------------------------*/
    unsigned char usb_buf[65];
+
    memset(usb_buf, 0x00, sizeof(usb_buf));

    usb_buf[0] = 0x00;
-    usb_buf[1] = 0xC0;
+    usb_buf[1] = 0xc0;
    usb_buf[2] = 0x81;
    usb_buf[3] = 0x01;
    usb_buf[4] = 0x00;
@@ -252,306 +129,146 @@ void AuraTUFKeyboardController::UpdateSingleLed
    /*-----------------------------------------------------*\
    | Convert LED index                                     |
    \*-----------------------------------------------------*/
-    usb_buf[5] = led;
+    usb_buf[5] = floor(led/6)*8 + led%6;
    usb_buf[6] = red;
    usb_buf[7] = green;
    usb_buf[8] = blue;

-    ClearResponses();
    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }

 void AuraTUFKeyboardController::UpdateLeds
    (
-    std::vector<led_color>    colors
+    std::vector<RGBColor>    colors
    )
 {
-    int packets = ceil((float) colors.size() / 15);
-
-    for(int i = 0; i < packets; i++)
+    /*-----------------------------------------------------*\
+    | Loop over every column (optimisation needed)          |
+    \*-----------------------------------------------------*/
+    for(unsigned int i = 0; i < 192; i += 16)
    {
-        unsigned char usb_buf[65];
+        unsigned char usb_buf[69];
+
        memset(usb_buf, 0x00, sizeof(usb_buf));

-        int remaining = colors.size() - i * 15;
-
-        int leds = (remaining > 0x0F) ? 0x0F : remaining;
-
        usb_buf[0] = 0x00;
-        usb_buf[1] = 0xC0;
+        usb_buf[1] = 0xc0;
        usb_buf[2] = 0x81;
-        usb_buf[3] = leds;
+        usb_buf[3] = (138 - i / 16 * 12);
        usb_buf[4] = 0x00;

-        for(int j = 0; j < leds; j++)
+        for(unsigned int n = 0; n < 6; n++)
        {
-            usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
-            usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
-            usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
+            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
        }

-        ClearResponses();
-        hid_write(dev, usb_buf, 65);
-        AwaitResponse(20);
+        for(unsigned int n = 6; n < 8; n++)
+        {
+            usb_buf[n * 4 + 5] = i + n;
+            usb_buf[n * 4 + 6] = 0;
+            usb_buf[n * 4 + 7] = 0;
+            usb_buf[n * 4 + 8] = 0;
+        }
+
+        if(i != 176)
+        {
+            for(unsigned int n = 8; n < 14; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
+                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
+            }
+
+            for(unsigned int n = 14; n < 16; n++)
+            {
+                usb_buf[n * 4 + 5] = i + n;
+                usb_buf[n * 4 + 6] = 0;
+                usb_buf[n * 4 + 7] = 0;
+                usb_buf[n * 4 + 8] = 0;
+            }
+        }
+
+        hid_write(dev, usb_buf, 69);
    }
 }

-void AuraTUFKeyboardController::UpdateK1Wave
-    (
-    std::vector<RGBColor>   colors,
-    unsigned char           direction,
-    unsigned char           speed,
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = 0x03;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = 0x00;
-    usb_buf[0x08]   = direction;
-    usb_buf[0x09]   = 0x00;
-
-    usb_buf[10] = 5;
-    usb_buf[11] = RGBGetRValue(colors[4]);
-    usb_buf[12] = RGBGetGValue(colors[4]);
-    usb_buf[13] = RGBGetBValue(colors[4]);
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-
-    for(unsigned int i = 0; i < 4; i ++)
-    {
-        usb_buf[10 + i * 4] = i + 1;
-        usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
-        usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
-        usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
 void AuraTUFKeyboardController::UpdateDevice
    (
    unsigned char           mode,
    std::vector<RGBColor>   colors,
-    unsigned char           direction,
+    unsigned char           dir,
    unsigned char           color_mode,
    unsigned char           speed,
    unsigned char           brightness
    )
 {
-    if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
-    {
-        return UpdateK1Wave(colors, direction, speed, brightness);
-    }
-
    unsigned char usb_buf[65];
+
    memset(usb_buf, 0x00, sizeof(usb_buf));

    usb_buf[0x00]   = 0x00;
    usb_buf[0x01]   = 0x51;
    usb_buf[0x02]   = 0x2C;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = brightness;
+    usb_buf[0x07]   = color_mode;
+    usb_buf[0x08]   = dir;
+    usb_buf[0x09]   = 0x02;

-    if(device_pid != AURA_ROG_CLAYMORE_PID)
+    if(mode == 4 || mode == 5)
    {
-        usb_buf[0x03]   = mode;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = speed;
-        usb_buf[0x06]   = brightness;
-        usb_buf[0x07]   = color_mode;
-        usb_buf[0x08]   = direction;
+        /*-----------------------------------------------------*\
+        | If mode is Rainbow or Ripple                          |
+        \*-----------------------------------------------------*/
+        usb_buf[0x0A]   = colors.size();

-        if(is_per_led_keyboard)
+        /*-----------------------------------------------------*\
+        | Loop over every color given                           |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
        {
-            usb_buf[0x09]   = 0x02;
-
-            if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
+            if(colors[i / 4])
            {
-                usb_buf[0x0A]   = colors.size();
-
-                /*-----------------------------------------------------*\
-                | Loop over every color given                           |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i < colors.size(); i ++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
-                        usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
-                        usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
-                        usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
-                    }
-                }
-            }
-            else
-            {
-                /*-----------------------------------------------------*\
-                | Loop over Color1, Color2 and Background if there      |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i != colors.size(); i++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
-                        usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
-                        usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
-                    }
-                }
-                    
-            }
-        }
-        else
-        {
-            /*-----------------------------------------------------------------*\
-            | Only handles K5 Rainbow.                                          |
-            | K1 is filtered out earlier and is executed in `UpdateK1Wave()`    |
-            \*-----------------------------------------------------------------*/
-            if(mode == AURA_KEYBOARD_MODE_WAVE)
-            {
-                usb_buf[0x09]   = 0x05;
-
-                for(unsigned int i = 0; i < 5; i ++)
-                {
-                    usb_buf[10 + i * 4] = i + 1;
-                    usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
-                    usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
-                    usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
-                }
-            }
-            else
-            {
-                /*-----------------------------------------------------*\
-                | Loop over Color1, Color2 and Background if there      |
-                \*-----------------------------------------------------*/
-                for(unsigned int i = 0; i != colors.size(); i++)
-                {
-                    if(colors[i])
-                    {
-                        usb_buf[ 9 + i * 3] = RGBGetRValue(colors[i]);
-                        usb_buf[10 + i * 3] = RGBGetGValue(colors[i]);
-                        usb_buf[11 + i * 3] = RGBGetBValue(colors[i]);
-                    }
-                }
+                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
+                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
+                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
+                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
            }
        }
    }
    else
    {
-        usb_buf[0x03]   = 0x00;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = mode;
-        usb_buf[0x06]   = speed;
-
-        bool random     = (color_mode == 1);
-        bool pattern    = (color_mode == 2);
-
-        usb_buf[0x07]   = random * 128 + pattern * 32 + direction;
-        usb_buf[0x08]   = 0xFF; // "byteExt1" unknown usage
-        usb_buf[0x09]   = 0xFF; // "byteExt2" unknown usage
-        usb_buf[0x0A]   = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
-
-        if(mode == 7)
+        /*-----------------------------------------------------*\
+        | Loop over Color1, Color2 and Background if there      |
+        \*-----------------------------------------------------*/
+        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
        {
-            UpdateQuicksandColors(colors);
-        }
-        else
-        {
-            if(mode == 4 && color_mode == 0)
+            if(colors[i / 3])
            {
-                usb_buf[11] = 0xFF;
-                usb_buf[12] = 0xFF;
-                usb_buf[13] = 0xFF;
-            }
-
-            for(unsigned int i = 0; i < colors.size(); i ++)
-            {
-                if(colors[i])
-                {
-                    usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
-                    usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
-                    usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
-                }
+                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
+                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
+                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
            }
        }
-
-        for(int i = 1; i < 5; i++)
-        {
-            usb_buf[5 + i * 12] = 0xFF;
-        }
+            
    }

-    ClearResponses();
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
 }

-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateQuicksandColors
-    (
-    std::vector<RGBColor>   colors
-    )
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x91;
-
-    for(unsigned int i = 0; i < 6; i++)
-    {
-        if(colors[i])
-        {
-            usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
-            usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
-            usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
-        }
-    }
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-/*---------------------------------------------------------*\
-| only needed for Claymore                                  |
-\*---------------------------------------------------------*/
-void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-
-    ClearResponses();
-    hid_write(dev, usb_buf, 65);
-    AwaitResponse(20);
-}
-
-void AuraTUFKeyboardController::AwaitResponse(int ms)
+void AuraTUFKeyboardController::AwaitResponse()
 {
    unsigned char usb_buf_out[65];
-    hid_read_timeout(dev, usb_buf_out, 65, ms);
+    hid_read(dev, usb_buf_out, 65);
 }

 void AuraTUFKeyboardController::ClearResponses()
@@ -560,7 +277,7 @@ void AuraTUFKeyboardController::ClearResponses()
    unsigned char usb_buf_flush[65];
    while(result > 0)
    {
-        result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
+      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
    }
 }

@@ -16,6 +16,14 @@

 #pragma once

+enum
+{
+    AURA_KEYBOARD_ZONE_LOGO         = 0,
+    AURA_KEYBOARD_ZONE_SCROLL       = 1,
+    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
+    AURA_KEYBOARD_ZONE_ALL          = 3,
+};
+
 enum
 {
    AURA_KEYBOARD_MODE_STATIC       =  0,
@@ -33,41 +41,22 @@ enum

 enum
 {
-    AURA_ROG_STRIX_FLARE_PID                     = 0x1875,
-    AURA_ROG_STRIX_FLARE_PNK_LTD_PID             = 0x18CF,
-    AURA_ROG_STRIX_FLARE_COD_BO4_PID             = 0x18AF,
-    AURA_ROG_FALCHION_WIRED_PID                  = 0x193C,
-    AURA_ROG_FALCHION_WIRELESS_PID               = 0x193E,
-    AURA_ROG_STRIX_SCOPE_PID                     = 0x18F8,
-    AURA_ROG_STRIX_SCOPE_RX_PID                  = 0x1951,
-    AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID  = 0x1AAE,
-    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID          = 0x19FC,
-    AURA_TUF_K1_GAMING_PID                       = 0x1945,
-    AURA_TUF_K3_GAMING_PID                       = 0x194B,
-    AURA_TUF_K5_GAMING_PID                       = 0x1899,
-    AURA_TUF_K7_GAMING_PID                       = 0x18AA,
-    AURA_ROG_CLAYMORE_PID                        = 0x184D,
+    AURA_TUF_K7_GAMING_PID          = 0x18AA,
+    AURA_TUF_K3_GAMING_PID          = 0x194B,
 };

-struct led_color
-{
-    unsigned int    value;
-    RGBColor        color;
-};

 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
    ~AuraTUFKeyboardController();

    std::string GetDeviceLocation();
    std::string GetSerialString();
    std::string GetVersion();
    int         GetLayout();
-    int         GetNumpadLocation();
    void        SaveMode();
-    void        AllowRemoteControl(unsigned char type);

    void UpdateSingleLed
        (
@@ -79,37 +68,25 @@ public:

    void UpdateLeds
        (
-        std::vector<led_color>    colors
-        );
-
-    void UpdateK1Wave
-        (
-        std::vector<RGBColor>   colors,
-        unsigned char           direction,
-        unsigned char           speed,
-        unsigned char           brightness
+        std::vector<RGBColor>    colors
        );

    void UpdateDevice
        (
        unsigned char           mode,
        std::vector<RGBColor>   colors,
-        unsigned char           direction,
+        unsigned char           dir,
        unsigned char           color_mode,
        unsigned char           speed,
        unsigned char           brightness
        );
-    void UpdateQuicksandColors(std::vector<RGBColor> colors);
-    void UpdateMode(unsigned char mode);
-    void AwaitResponse(int ms);
+    void AwaitResponse();
    void ClearResponses();

    uint16_t                    device_pid;
-    bool                        is_per_led_keyboard;

 private:
    hid_device*                 dev;
    std::string                 location;
-    unsigned short              rev_version;
 };

@@ -26,7 +26,6 @@ AuraUSBController::~AuraUSBController()
 {
    hid_close(dev);
 }
-
 unsigned int AuraUSBController::GetChannelCount()
 {
    return(device_info.size());
@@ -105,7 +104,7 @@ void AuraUSBController::GetConfigTable()
        }
    }
    else
-    {
+    {       
        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
        delete this;
    }
@@ -6,7 +6,6 @@
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "AsusAuraMousematController.h"
-#include "AsusROGAllyController.h"
 #include "AsusAuraStrixEvolveController.h"
 #include "AsusAuraMonitorController.h"
 #include "AsusAuraRyuoAIOController.h"
@@ -15,10 +14,8 @@
 #include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraTUFKeyboard.h"
-#include "RGBController_AsusAuraMainboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include "RGBController_AsusAuraMousemat.h"
-#include "RGBController_AsusROGAlly.h"
 #include "RGBController_ROGStrixLC_Controller.h"
 #include "RGBController_AsusAuraStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
@@ -27,82 +24,74 @@
 #include <hidapi/hidapi.h>
 #include "dependencies/dmiinfo.h"

-#define AURA_USB_VID                                  0x0B05
+#define AURA_USB_VID                            0x0B05

 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
-#define AURA_ADDRESSABLE_1_PID                        0x1867
-#define AURA_ADDRESSABLE_2_PID                        0x1872
-#define AURA_ADDRESSABLE_3_PID                        0x18A3
-#define AURA_ADDRESSABLE_4_PID                        0x18A5
-#define AURA_MOTHERBOARD_1_PID                        0x18F3
-#define AURA_MOTHERBOARD_2_PID                        0x1939
-#define AURA_MOTHERBOARD_3_PID                        0x19AF
+#define AURA_ADDRESSABLE_1_PID                  0x1867
+#define AURA_ADDRESSABLE_2_PID                  0x1872
+#define AURA_ADDRESSABLE_3_PID                  0x18A3
+#define AURA_ADDRESSABLE_4_PID                  0x18A5
+#define AURA_MOTHERBOARD_1_PID                  0x18F3
+#define AURA_MOTHERBOARD_2_PID                  0x1939
+#define AURA_MOTHERBOARD_3_PID                  0x19AF

 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_FALCHION_WIRED_PID                   0x193C
-#define AURA_ROG_FALCHION_WIRELESS_PID                0x193E
-#define AURA_ROG_STRIX_FLARE_PID                      0x1875
-#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID              0x18CF
-#define AURA_ROG_STRIX_FLARE_COD_BO4_PID              0x18AF
-#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID           0x19FC
-#define AURA_ROG_STRIX_SCOPE_PID                      0x18F8
-#define AURA_ROG_STRIX_SCOPE_RX_PID                   0x1951
-#define AURA_ROG_STRIX_SCOPE_TKL_PID                  0x190C
-#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID        0x1A05
-#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID          0x1954
-#define AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID   0x1AAE
-#define AURA_ROG_CLAYMORE_PID                         0x184D
-#define AURA_TUF_K1_GAMING_PID                        0x1945
-#define AURA_TUF_K3_GAMING_PID                        0x194B
-#define AURA_TUF_K5_GAMING_PID                        0x1899
-#define AURA_TUF_K7_GAMING_PID                        0x18AA
+#define AURA_ROG_FALCHION_WIRED_PID             0x193C
+#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
+#define AURA_ROG_STRIX_FLARE_PID                0x1875
+#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
+#define AURA_ROG_STRIX_SCOPE_PID                0x18F8
+#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
+#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
+#define AURA_TUF_K7_GAMING_PID                  0x18AA
+#define AURA_TUF_K3_GAMING_PID                  0x194B

 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_STRIX_EVOLVE_PID                     0x185B
+#define AURA_ROG_STRIX_EVOLVE_PID               0x185B

 /*-----------------------------------------------------------------*\
 | MOUSEMATS                                                         |
 \*-----------------------------------------------------------------*/
-#define AURA_ROG_BALTEUS_PID                          0x1891
-#define AURA_ROG_BALTEUS_QI_PID                       0x1890
+#define AURA_ROG_BALTEUS_PID                    0x1891
+#define AURA_ROG_BALTEUS_QI_PID                 0x1890

 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_STRIX_XG27AQ_PID                     0x198C
-#define AURA_ROG_STRIX_XG27AQM_PID                    0x19BB
-#define AURA_ROG_STRIX_XG279Q_PID                     0x1919
-#define AURA_ROG_STRIX_XG27W_PID                      0x1933
-#define AURA_ROG_PG32UQ_PID                           0x19B9
+#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
+#define AURA_ROG_PG32UQ_PID                     0x19B9

 /*-----------------------------------------------------------------*\
 | HEADSETSTANDS                                                     |
 \*-----------------------------------------------------------------*/

-#define AURA_ROG_THRONE_PID                           0x18D9
-#define AURA_ROG_THRONE_QI_PID                        0x18C5
-#define AURA_ROG_THRONE_QI_GUNDAM_PID                 0x1994
+#define AURA_ROG_THRONE_PID                     0x18D9
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
+#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994

 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
 \*-----------------------------------------------------------------*/
-#define AURA_TERMINAL_PID                             0x1889
-#define ROG_STRIX_LC120_PID                           0x879E
-#define AURA_RYUO_AIO_PID                             0x1887
-#define ASUS_ROG_ALLY_PID                             0x1ABE
+#define AURA_TERMINAL_PID                       0x1889
+#define ROG_STRIX_LC120_PID                     0x879E
+#define AURA_RYUO_AIO_PID                       0x1887

 AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
 {
    switch(pid)
    {
+        case AURA_ROG_STRIX_FLARE_PID:
+        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
+            return FLARE_LAYOUT;
+
        case AURA_ROG_STRIX_SCOPE_PID:
            return SCOPE_LAYOUT;

@@ -110,10 +99,12 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
            return SCOPE_RX_LAYOUT;

        case AURA_ROG_STRIX_SCOPE_TKL_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID:
-        case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
            return SCOPE_TKL_LAYOUT;

+        case AURA_ROG_FALCHION_WIRED_PID:
+        case AURA_ROG_FALCHION_WIRELESS_PID:
+            return FALCHION_LAYOUT;
+
        default:
            return FLARE_LAYOUT;
    }
@@ -156,7 +147,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
        {
            DMIInfo dmi;
            AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraMainboard*   rgb_controller   = new RGBController_AuraMainboard(controller);
+            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
            rgb_controller->name                            = "ASUS " + dmi.getMainboard();
            ResourceManager::get()->RegisterRGBController(rgb_controller);
        }
@@ -188,8 +179,7 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid);
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
        RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
        rgb_controller->name                                = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -267,7 +257,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
        RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
        rgb_controller->name                                = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
@@ -287,19 +277,6 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
    }
 }

-void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        ROGAllyController*         controller           = new ROGAllyController(dev, info->path);
-        RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
-        rgb_controller->name                            = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 /*-----------------------------------------------------------------*\
 |  MOTHERBOARDS                                                     |
 \*-----------------------------------------------------------------*/
@@ -314,23 +291,15 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAs
 /*-----------------------------------------------------------------*\
 |  KEYBOARDS                                                        |
 \*-----------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",                    DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID,       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore",                           DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_CLAYMORE_PID,                        1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",                   DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,                  1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",                DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,               1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate",             DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID,          1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K1_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K5_GAMING_PID,                       2,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                        DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                     1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",                     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,                  1,  0xFF00);
 REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                       1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope II 96 Wireless USB",     DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID,  1,  0xFF00);
+REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                          DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                       1,  0xFF00);

 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
@@ -342,22 +311,16 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",          DetectAs
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,           1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                     0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,        0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",     DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,         0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,                0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID,                   0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID,                    0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X Dock",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_PID,                   0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                              DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                           2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",                   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,                  0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",                DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,               0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    2,  0xFF01);
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",                       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                    0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",                    DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,                 0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam",             DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID,          0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk",       DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID,            0,  0xFF01);
@@ -383,9 +346,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                         DetectAs
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
 REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                    0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM",                      DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID,                   0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q",                       DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID,                    0xFFA0, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W",                        DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID,                     0xFFA0, 1);
 REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_PG32UQ_PID,                          0xFFA0, 1);

 /*-----------------------------------------------------------------*\
@@ -397,4 +357,3 @@ REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAs
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);
-REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally",                              DetectAsusROGAlly,              AURA_USB_VID, ASUS_ROG_ALLY_PID,                            2,  0xFF31, 0x0076);
@@ -1,127 +0,0 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.cpp                |
-|                                           |
-|  Driver for ASUS ROG Ally lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "AsusROGAllyController.h"
-#include <cstring>
-
-ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-ROGAllyController::~ROGAllyController()
-{
-    hid_close(dev);
-}
-
-std::string ROGAllyController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string ROGAllyController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string ROGAllyController::GetVersion()
-{
-    return("");
-}
-
-void ROGAllyController::UpdateLeds
-    (
-    std::vector<RGBColor>    colors
-    )
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xD1;
-    usb_buf[0x02]   = 0x08;
-    usb_buf[0x03]   = 0x0C;
-
-    for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        usb_buf[color_idx * 3 + 4]  = RGBGetRValue(colors[color_idx]);
-        usb_buf[color_idx * 3 + 5]  = RGBGetGValue(colors[color_idx]);
-        usb_buf[color_idx * 3 + 6]  = RGBGetBValue(colors[color_idx]);
-    }
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
-void ROGAllyController::UpdateDevice
-    (
-    unsigned char           mode,
-    std::vector<RGBColor>   colors,
-    unsigned char           speed,
-    unsigned char           /*brightness*/,
-    unsigned char           direction
-    )
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB3;
-    usb_buf[0x02]   = 0x00;
-    usb_buf[0x03]   = mode;
-    if(colors.size() > 0)
-    {
-        usb_buf[0x04]   = RGBGetRValue(colors[0]);
-        usb_buf[0x05]   = RGBGetGValue(colors[0]);
-        usb_buf[0x06]   = RGBGetBValue(colors[0]);
-    }
-    usb_buf[0x07]   = speed;
-    usb_buf[0x08]   = direction;
-    if(colors.size() > 1)
-    {
-        usb_buf[0x0A]   = RGBGetRValue(colors[1]);
-        usb_buf[0x0B]   = RGBGetGValue(colors[1]);
-        usb_buf[0x0C]   = RGBGetBValue(colors[1]);
-    }
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB5;
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
-void ROGAllyController::SaveMode()
-{
-    unsigned char usb_buf[64];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x5A;
-    usb_buf[0x01]   = 0xB4;
-
-    hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
-}
-
@@ -1,67 +0,0 @@
-/*-----------------------------------------*\
-|  AsusROGAllyController.h                  |
-|                                           |
-|  Definitions and types for ASUS ROG Ally  |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/12/2023   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    ROG_ALLY_MODE_STATIC           = 0,
-    ROG_ALLY_MODE_BREATHING        = 1,
-    ROG_ALLY_MODE_COLOR_CYCLE      = 2,
-    ROG_ALLY_MODE_RAINBOW          = 3,
-    ROG_ALLY_MODE_STROBING         = 10,
-    ROG_ALLY_MODE_DIRECT           = 0xFF,
-};
-
-enum
-{
-    ROG_ALLY_SPEED_MIN              = 0xE1,
-    ROG_ALLY_SPEED_MED              = 0xEB,
-    ROG_ALLY_SPEED_MAX              = 0xF5
-};
-
-enum
-{
-    ROG_ALLY_DIRECTION_RIGHT        = 0x00,
-    ROG_ALLY_DIRECTION_LEFT         = 0x01
-};
-
-class ROGAllyController
-{
-public:
-    ROGAllyController(hid_device* dev_handle, const char* path);
-    virtual ~ROGAllyController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void UpdateLeds
-        (
-            std::vector<RGBColor>    colors
-            );
-
-    void UpdateDevice
-        (
-            unsigned char           mode,
-            std::vector<RGBColor>   colors,
-            unsigned char           speed,
-            unsigned char           brightness,
-            unsigned char           direction
-            );
-
-    void SaveMode();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -177,6 +177,12 @@ void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AuraHeadsetStand::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
 void RGBController_AuraHeadsetStand::DeviceUpdateMode()
 {
    unsigned char red = 0;
@@ -35,6 +35,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

@@ -44,7 +44,7 @@ static unsigned int falchion_matrix_map[5][16] =
      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };

-static const std::vector<aura_keyboard_led> default_led_names =
+static const std::vector<led_type> default_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -153,7 +153,7 @@ static const std::vector<aura_keyboard_led> default_led_names =
    { KEY_EN_NUMPAD_ENTER,      0xB4    },
 };

-static const std::vector<aura_keyboard_led> default_tkl_led_names =
+static const std::vector<led_type> default_tkl_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -270,7 +270,7 @@ static const std::vector<aura_keyboard_led> default_tkl_led_names =
    { "Underglow 26",           0xCE    },
 };

-static const std::vector<aura_keyboard_led> default_65pct_led_names =
+static const std::vector<led_type> default_65pct_led_names =
 {
    /* Key Label                Index  */
    { KEY_EN_ESCAPE,            0x00    },
@@ -395,7 +395,7 @@ void RGBController_AuraKeyboard::SetupZones()
    | Set up zones                                              |
    \*---------------------------------------------------------*/
    std::vector<led_zone> led_zones;
-    std::vector<aura_keyboard_led> led_names;
+    std::vector<led_type> led_names;

    switch(layout)
    {
@@ -405,7 +405,7 @@ void RGBController_AuraKeyboard::SetupZones()
        \*-----------------------------------------------------*/
        case SCOPE_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -413,8 +413,8 @@ void RGBController_AuraKeyboard::SetupZones()

        case SCOPE_RX_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
-            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -423,9 +423,9 @@ void RGBController_AuraKeyboard::SetupZones()

        case SCOPE_TKL_LAYOUT:
            led_names = default_tkl_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
-            led_zones.push_back({"Logo",                ZONE_TYPE_LINEAR, 2, NULL});
-            led_zones.push_back({"Underglow",           ZONE_TYPE_LINEAR, 26, NULL});
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_LINEAR, 2});
+            led_zones.push_back({"Underglow",   ZONE_TYPE_LINEAR, 26});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -433,9 +433,9 @@ void RGBController_AuraKeyboard::SetupZones()

        case FLARE_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
-            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
-            led_zones.push_back({"Underglow",           ZONE_TYPE_SINGLE, 2, NULL});
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
+            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
+            led_zones.push_back({"Underglow",   ZONE_TYPE_SINGLE, 2});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x0D});
            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x15});
@@ -447,7 +447,7 @@ void RGBController_AuraKeyboard::SetupZones()

        case FALCHION_LAYOUT:
            led_names = default_65pct_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
+            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
            break;
    }

@@ -527,6 +527,11 @@ void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AuraKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraKeyboard::DeviceUpdateMode()
 {

@@ -24,7 +24,7 @@ typedef struct
 {
    const char*         name;
    unsigned char       idx;
-} aura_keyboard_led;
+} led_type;

 typedef struct
 {
@@ -48,6 +48,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();

 private:
@@ -1,78 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.cpp      |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.cpp   |
-|  code                                     |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMainboard.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura USB Mainboard
-    @category Motherboard
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMotherboards
-    @comment The Asus Aura USB Mainboard controller applies to most
-        AMD and Intel mainboards from the x570 chipset onwards.
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
-    RGBController_AuraUSB(controller_ptr)
-{
-    name        = "ASUS Aura USB Mainboard";
-    description = "ASUS Aura USB Mainboard Device";
-
-    /*-------------------------------------------------------*\
-    | Add manual save flag to all modes except direct mode    |
-    \*-------------------------------------------------------*/
-    for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-    {
-        mode Mode = modes[mode_idx];
-        if(Mode.value != AURA_MODE_DIRECT)
-        {
-            Mode.flags |= MODE_FLAG_MANUAL_SAVE;
-            modes[mode_idx] = Mode;
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
-
-        /*---------------------------------------------------*\
-        | Shutdown effect only works with onboard lighting    |
-        \*---------------------------------------------------*/
-        if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
-        {
-            ((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
-        }
-    }
-}
-
-void RGBController_AuraMainboard::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    DeviceUpdateShutdownEffect();
-    ((AuraMainboardController*) controller)->SendCommit();
-}
@@ -1,25 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMainboard.h        |
-|                                           |
-|  RGB controller for Asus Aura USB         |
-|  mainboards                               |
-|                                           |
-|  rytypete 8/30/2023                       |
-|  based on RGBController_AsusAuraUSB.h     |
-|  code                                     |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController_AsusAuraUSB.h"
-#include "AsusAuraMainboardController.h"
-
-class RGBController_AuraMainboard : public RGBController_AuraUSB
-{
-public:
-    RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
-
-    void        DeviceSaveMode();
-
-private:
-    void        DeviceUpdateShutdownEffect();
-};
@@ -112,6 +112,12 @@ void RGBController_AuraMonitor::UpdateSingleLED(int led)
    controller->ApplyChanges();
 }

+void RGBController_AuraMonitor::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
 void RGBController_AuraMonitor::DeviceUpdateMode()
 {
    /*---------------------------------------------------------*\
@@ -25,6 +25,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

@@ -9,13 +9,11 @@

 #include "RGBController_AsusAuraMouse.h"

-static std::string aura_mouse_zone_names[5]
+static std::string aura_mouse_zone_names[3]
 {
    "Logo",
    "Scroll Wheel",
-    "Underglow",
-    "All",
-    "Dock"
+    "Underglow"
 };

 /**------------------------------------------------------------------*\
@@ -31,9 +29,9 @@ static std::string aura_mouse_zone_names[5]

 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller              = controller_ptr;

-    pid = controller->device_pid;
+    uint16_t pid            = controller->device_pid;

    name                    = "ASUS Aura Mouse";
    vendor                  = "ASUS";
@@ -170,6 +168,8 @@ RGBController_AuraMouse::~RGBController_AuraMouse()

 void RGBController_AuraMouse::SetupZones()
 {
+    uint16_t pid                = controller->device_pid;
+
    for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
    {
        zone mouse_zone;
@@ -207,9 +207,9 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
    }
 }

-void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateLEDs();
+    UpdateSingleLED(zone);
 }

 void RGBController_AuraMouse::UpdateSingleLED(int led)
@@ -221,6 +221,11 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }

+void RGBController_AuraMouse::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraMouse::DeviceUpdateMode()
 {
    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
@@ -240,22 +245,7 @@ void RGBController_AuraMouse::DeviceUpdateMode()
            blu = RGBGetBValue(modes[active_mode].colors[0]);
        }

-
-        if(pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)
-        {
-            controller->SendUpdate(AURA_MOUSE_ZONE_DOCK, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
-        else if(pid == AURA_ROG_STRIX_IMPACT_PID)
-        {
-            /*-----------------------------------------------------------------*\
-            | The ROG Impact doesn't accept AURA_MOUSE_ZONE_ALL                 |
-            \*-----------------------------------------------------------------*/
-            controller->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
-        else
-        {
-            controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-        }
+        controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
    }
 }

@@ -25,10 +25,10 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

 private:
    AuraMouseController*  controller;
-    uint16_t              pid;
 };
@@ -22,15 +22,15 @@

 RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;

-    name                        = "ASUS Aura Mousemat";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_MOUSEMAT;
-    description                 = "ASUS Aura Mousemat Device";
-    version                     = controller->GetVersion();
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
+    name        = "ASUS Aura Mousemat";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "ASUS Aura Mousemat Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();

    mode Direct;
    Direct.name                 = "Direct";
@@ -230,6 +230,11 @@ void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AuraMousemat::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraMousemat::DeviceUpdateMode()
 {
    if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)
@@ -43,6 +43,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

@@ -169,7 +169,7 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
    SetupColors();
 }

-void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_AsusAuraRyuoAIO::ResizeZone(int zone, int new_size)
 {
    /*---------------------------------------------------------*\
    | This device does not support resizing zones               |
@@ -194,6 +194,11 @@ void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
    UpdateZoneLEDs(GetLED_Zone(led));
 }

+void RGBController_AsusAuraRyuoAIO::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()
 {
    RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
@@ -27,8 +27,8 @@ public:
    void UpdateZoneLEDs(int zone);
    void UpdateSingleLED(int led);

+    void SetCustomMode();
    void DeviceUpdateMode();
-
 private:
    int  GetDeviceMode();
    int  GetLED_Zone(int led_idx);
@@ -129,6 +129,11 @@ void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
    DeviceUpdateLEDs();
 }

+void RGBController_AuraStrixEvolve::SetCustomMode()
+{
+    active_mode = 0;
+}
+
 void RGBController_AuraStrixEvolve::DeviceUpdateMode()
 {
    unsigned char red = RGBGetRValue(colors[0]);
@@ -32,6 +32,7 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

@@ -24,366 +24,178 @@

 RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
 {
-    controller = controller_ptr;
+    controller  = controller_ptr;

-    pid = controller->device_pid;
+    name        = "ASUS Aura Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Aura Keyboard Device";
+    version     = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();

-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        name        = "ASUS Aura Keyboard";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);

-        unsigned char AURA_KEYBOARD_SPEED_MIN     = 0;
-        unsigned char AURA_KEYBOARD_SPEED_MAX     = 0;
-        unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
+    mode Static;
+    Static.name                 = "Static";
+    Static.value                = AURA_KEYBOARD_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);

-        switch(pid)
-        {
-            case AURA_TUF_K1_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 0;
-                AURA_KEYBOARD_SPEED_MAX          = 2;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 1;
-                break;
-            case AURA_ROG_STRIX_FLARE_PID:
-            case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-            case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            case AURA_TUF_K3_GAMING_PID:
-            case AURA_TUF_K7_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 15;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
-                break;
-            case AURA_ROG_FALCHION_WIRED_PID:
-            case AURA_ROG_FALCHION_WIRELESS_PID:
-            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            case AURA_ROG_STRIX_SCOPE_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_PID:
-            case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            case AURA_TUF_K5_GAMING_PID:
-                AURA_KEYBOARD_SPEED_MIN          = 255;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 30;
-                break;
-            default:
-                AURA_KEYBOARD_SPEED_MIN          = 15;
-                AURA_KEYBOARD_SPEED_MAX          = 0;
-                AURA_KEYBOARD_SPEED_DEFAULT      = 8;
-        }
+    mode Breathing;
+    Breathing.name              = "Breathing";
+    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);

-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
+    mode Color_Cycle;
+    Color_Cycle.name            = "Spectrum Cycle";
+    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
+    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
+    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
+    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
+    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Color_Cycle.color_mode      = MODE_COLORS_NONE;
+    modes.push_back(Color_Cycle);

-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
+    mode Wave;
+    Wave.name                   = "Rainbow Wave";
+    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
+    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
+    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
+    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
+    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Wave.direction              = MODE_DIRECTION_LEFT;
+    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Wave.colors_min             = 1;
+    Wave.colors_max             = 7;
+    Wave.colors.resize(7);
+    modes.push_back(Wave);

-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
+    mode Ripple;
+    Ripple.name                 = "Ripple";
+    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
+    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
+    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
+    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    Ripple.colors_min           = 1;
+    Ripple.colors_max           = 8;
+    Ripple.colors.resize(7);
+    modes.push_back(Ripple);

-        Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-        Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-        Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(1);
-        modes.push_back(Breathing);
+    mode Reactive;
+    Reactive.name               = "Reactive";
+    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
+    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
+    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min         = 1;
+    Reactive.colors_max         = 2;
+    Reactive.colors.resize(1);
+    modes.push_back(Reactive);

-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-        Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-        Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
+    mode Starry_Night;
+    Starry_Night.name           = "Starry Night";
+    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
+    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
+    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min     = 1;
+    Starry_Night.colors_max     = 3;
+    Starry_Night.colors.resize(1);
+    modes.push_back(Starry_Night);

-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
-        
-        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-        Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    mode Quicksand;
+    Quicksand.name              = "Quicksand";
+    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
+    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Quicksand.direction         = MODE_DIRECTION_DOWN;
+    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Quicksand.colors_min        = 6;
+    Quicksand.colors_max        = 6;
+    Quicksand.colors.resize(6);
+    modes.push_back(Quicksand);

-        if(!controller->is_per_led_keyboard)
-        {
-            Wave.colors_min             = 5;
-            Wave.colors_max             = 5;
-        }
-        else
-        {
-            Wave.colors_min             = 1;
-            Wave.colors_max             = 7;
-        }
+    mode Current;
+    Current.name                = "Current";
+    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
+    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
+    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
+    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
+    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Current.colors_min          = 1;
+    Current.colors_max          = 3;
+    Current.colors.resize(1);
+    modes.push_back(Current);

-        Wave.colors.resize(Wave.colors_max);
-        modes.push_back(Wave);
-
-        if(controller->is_per_led_keyboard)
-        {
-            mode Reactive;
-            Reactive.name               = "Reactive";
-            Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-            Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-            Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-            Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-            Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-            Reactive.colors_min         = 1;
-            Reactive.colors_max         = 2;
-            Reactive.colors.resize(1);
-            modes.push_back(Reactive);
-
-            mode Ripple;
-            Ripple.name                 = "Ripple";
-            Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-            Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-            Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-            Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-            Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-            Ripple.colors_min           = 1;
-            Ripple.colors_max           = 8;
-            Ripple.colors.resize(7);
-            modes.push_back(Ripple);
-
-            mode Starry_Night;
-            Starry_Night.name           = "Starry Night";
-            Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-            Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-            Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-            Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-            Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-            Starry_Night.colors_min     = 1;
-            Starry_Night.colors_max     = 3;
-            Starry_Night.colors.resize(1);
-            modes.push_back(Starry_Night);
-
-            mode Quicksand;
-            Quicksand.name              = "Quicksand";
-            Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-            Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Quicksand.direction         = MODE_DIRECTION_DOWN;
-            Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-            Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-            Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-            Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-            Quicksand.colors_min        = 6;
-            Quicksand.colors_max        = 6;
-            Quicksand.colors.resize(6);
-            modes.push_back(Quicksand);
-
-            mode Current;
-            Current.name                = "Current";
-            Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-            Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-            Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-            Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-            Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-            Current.colors_min          = 1;
-            Current.colors_max          = 3;
-            Current.colors.resize(1);
-            modes.push_back(Current);
-
-            mode Rain_Drop;
-            Rain_Drop.name              = "Rain Drop";
-            Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
-            Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-            Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-            Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-            Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-            Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-            Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-            Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-            Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-            Rain_Drop.colors_min        = 1;
-            Rain_Drop.colors_max        = 3;
-            Rain_Drop.colors.resize(1);
-            modes.push_back(Rain_Drop);
-        }
-    }
-    else
-    {
-
-        name        = "ASUS ROG Claymore";
-        vendor      = "ASUS";
-        type        = DEVICE_TYPE_KEYBOARD;
-        description = "ASUS Aura Keyboard Device";
-        version     = controller->GetVersion();
-        location    = controller->GetDeviceLocation();
-        serial      = controller->GetSerialString();
-
-        mode Direct;
-        Direct.name                 = "Direct";
-        Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode           = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-
-        mode Static;
-        Static.name                 = "Static";
-        Static.value                = AURA_KEYBOARD_MODE_STATIC;
-        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Static.colors_min           = 1;
-        Static.colors_max           = 1;
-        Static.colors.resize(1);
-        modes.push_back(Static);
-
-        mode Breathing;
-        Breathing.name              = "Breathing";
-        Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-        Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Breathing.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Breathing.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Breathing.speed             = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
-        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Breathing.colors_min        = 1;
-        Breathing.colors_max        = 2;
-        Breathing.colors.resize(2);
-        modes.push_back(Breathing);
-
-        mode Color_Cycle;
-        Color_Cycle.name            = "Spectrum Cycle";
-        Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-        Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Cycle.speed_min       = AURA_CLAYMORE_SPEED_MIN;
-        Color_Cycle.speed_max       = AURA_CLAYMORE_SPEED_MAX;
-        Color_Cycle.speed           = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
-        Color_Cycle.color_mode      = MODE_COLORS_NONE;
-        modes.push_back(Color_Cycle);
-
-        mode Reactive;
-        Reactive.name               = "Reactive";
-        Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Reactive.speed_min          = AURA_CLAYMORE_SPEED_MIN;
-        Reactive.speed_max          = AURA_CLAYMORE_SPEED_MAX;
-        Reactive.speed              = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
-        Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-        Reactive.colors_min         = 1;
-        Reactive.colors_max         = 2;
-        Reactive.colors.resize(2);
-        modes.push_back(Reactive);
-
-        mode Wave;
-        Wave.name                   = "Rainbow Wave";
-        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-        Wave.flags                  = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Wave.speed_min              = AURA_CLAYMORE_SPEED_MIN;
-        Wave.speed_max              = AURA_CLAYMORE_SPEED_MAX;
-        Wave.speed                  = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Wave.direction              = MODE_DIRECTION_LEFT;
-        Wave.color_mode             = MODE_COLORS_NONE;
-        modes.push_back(Wave);
-
-        mode Color_Wave;
-        Color_Wave.name             = "Color Wave";
-        Color_Wave.value            = AURA_KEYBOARD_MODE_WAVE;
-        Color_Wave.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-        Color_Wave.speed_min        = AURA_CLAYMORE_SPEED_MIN;
-        Color_Wave.speed_max        = AURA_CLAYMORE_SPEED_MAX;
-        Color_Wave.speed            = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
-        Color_Wave.direction        = MODE_DIRECTION_LEFT;
-        Color_Wave.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-        Color_Wave.colors_min       = 1;
-        Color_Wave.colors_max       = 2;
-        Color_Wave.colors.resize(2);
-        modes.push_back(Color_Wave);
-
-        mode Ripple;
-        Ripple.name                 = "Ripple";
-        Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Ripple.speed_min            = AURA_CLAYMORE_SPEED_MIN;
-        Ripple.speed_max            = AURA_CLAYMORE_SPEED_MAX;
-        Ripple.speed                = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
-        Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-        Ripple.colors_min           = 1;
-        Ripple.colors_max           = 2;
-        Ripple.colors.resize(2);
-        modes.push_back(Ripple);
-
-        mode Starry_Night;
-        Starry_Night.name           = "Starry Night";
-        Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-        Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Starry_Night.speed_min      = AURA_CLAYMORE_SPEED_MIN;
-        Starry_Night.speed_max      = AURA_CLAYMORE_SPEED_MAX;
-        Starry_Night.speed          = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
-        Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        Starry_Night.colors_min     = 1;
-        Starry_Night.colors_max     = 2;
-        Starry_Night.colors.resize(2);
-        modes.push_back(Starry_Night);
-
-        mode Quicksand;
-        Quicksand.name              = "Quicksand";
-        Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-        Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-        Quicksand.direction         = MODE_DIRECTION_DOWN;
-        Quicksand.speed_min         = AURA_CLAYMORE_SPEED_MIN;
-        Quicksand.speed_max         = AURA_CLAYMORE_SPEED_MAX;
-        Quicksand.speed             = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
-        Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-        Quicksand.colors_min        = 6;
-        Quicksand.colors_max        = 6;
-        Quicksand.colors.resize(6);
-        modes.push_back(Quicksand);
-    }
+    mode Rain_Drop;
+    Rain_Drop.name              = "Rain Drop";
+    Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
+    Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
+    Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
+    Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
+    Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
+    Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
+    Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Rain_Drop.colors_min        = 1;
+    Rain_Drop.colors_max        = 3;
+    Rain_Drop.colors.resize(1);
+    modes.push_back(Rain_Drop);

    SetupZones();
 }
@@ -395,68 +207,10 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()

 void RGBController_AuraTUFKeyboard::SetupZones()
 {
-    std::map<int,layout_info> * keyboard_ptr;
+    int layout = controller->GetLayout();

-    switch(pid)
+    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
    {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-        case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
-            keyboard_ptr = &AsusROGStrixFlareLayouts;
-            break;
-        case AURA_TUF_K3_GAMING_PID:
-        case AURA_TUF_K7_GAMING_PID:
-            keyboard_ptr = &AsusTUFK7Layouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_PID:
-            keyboard_ptr = &AsusROGStrixScopeLayouts;
-            break;
-        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
-            break;
-        case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
-            keyboard_ptr = &AsusROGStrixFlareIILayouts;
-            break;
-        case AURA_ROG_FALCHION_WIRED_PID:
-        case AURA_ROG_FALCHION_WIRELESS_PID:
-            keyboard_ptr = &AsusFalchionLayouts;
-            break;
-        case AURA_ROG_CLAYMORE_PID:
-            unsigned char numpad;
-            numpad = controller->GetNumpadLocation();
-            switch(numpad)
-            {
-                case 0:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-                    break;
-                case 2:
-                    keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
-                    break;
-                case 3:
-                    keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
-                    break;
-                default:
-                    keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
-            }
-            break;
-        case AURA_TUF_K1_GAMING_PID:
-        case AURA_TUF_K5_GAMING_PID:
-            keyboard_ptr = &AsusTufK1Layouts;
-            break;
-        default:
-            keyboard_ptr = &AsusTUFK7Layouts;
-    }
-
-    std::map<int,layout_info> & keyboard = *keyboard_ptr;
-
-    unsigned char layout = controller->GetLayout();
-
-    if(keyboard.find(layout % 100) == keyboard.end())
-    {
-        /*---------------------------------------------------------*\
-        | If Layout not found, take uk or us                        |
-        \*---------------------------------------------------------*/
        layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
    }
    else
@@ -464,32 +218,33 @@ void RGBController_AuraTUFKeyboard::SetupZones()
        layout = layout % 100;
    }

-    zone keyboard_zone;
-    keyboard_zone.name               = "Keyboard";
-    keyboard_zone.type               = ZONE_TYPE_MATRIX;
-    keyboard_zone.leds_min           = keyboard[layout].size;
-    keyboard_zone.leds_max           = keyboard[layout].size;
-    keyboard_zone.leds_count         = keyboard[layout].size;
-    keyboard_zone.matrix_map         = new matrix_map_type;
-    keyboard_zone.matrix_map->height = keyboard[layout].rows;
-    keyboard_zone.matrix_map->width  = keyboard[layout].cols;
-    keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
-    zones.push_back(keyboard_zone);
+    unsigned int total_led_count = 0;

-    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
+    int zone_size = 138;
+
+    zone keyboard;
+    keyboard.name               = "Keyboard";
+    keyboard.type               = ZONE_TYPE_MATRIX;
+    keyboard.leds_min           = zone_size;
+    keyboard.leds_max           = zone_size;
+    keyboard.leds_count         = zone_size;
+    keyboard.matrix_map         = new matrix_map_type;
+    keyboard.matrix_map->height = 6;
+    keyboard.matrix_map->width  = 23;
+    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
+    zones.push_back(keyboard);
+
+    total_led_count += zone_size;
+
+
+    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
    {
        led new_led;
-        new_led.name  = keyboard[layout].led_names[led_id].name;
-        new_led.value = keyboard[layout].led_names[led_id].id;
+        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
        leds.push_back(new_led);
    }

    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | sends the init packet for the default mode (direct)       |
-    \*---------------------------------------------------------*/
-    DeviceUpdateMode();
 }

 void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -499,133 +254,91 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
-    std::vector<led_color> led_color_list = {};
-
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        led_color_list.push_back({ leds[i].value, colors[i] });
-    }
-
-    controller->UpdateLeds(led_color_list);
+    DeviceUpdateMode();
 }

 void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
-    DeviceUpdateLEDs();
+    controller->UpdateLeds(colors);
 }

 void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
 {
-    if(!controller->is_per_led_keyboard)
-    {
-        return DeviceUpdateLEDs();
-    }
-
    unsigned char red   = RGBGetRValue(colors[led]);
    unsigned char green = RGBGetGValue(colors[led]);
    unsigned char blue  = RGBGetBValue(colors[led]);

-    controller->UpdateSingleLed(leds[led].value, red, green, blue);
+    controller->UpdateSingleLed(led, red, green, blue);
 }

-static const uint8_t direction_map[2][6] =
+void RGBController_AuraTUFKeyboard::SetCustomMode()
 {
-    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical
-    { 0,  4,  6,  2,  0xFF,  0xFF },    // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
-};
+    active_mode = 0;
+}

 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 {
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->AllowRemoteControl(1);
-    }
-
-    unsigned char color_mode    = 0;
-    unsigned char direction     = 0;
-    unsigned char brightness    = 0;
+    unsigned char color_mode;
+    std::vector<RGBColor> mode_colors;

    if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
    {
-        if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
-        return;
-    };
-
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        brightness = modes[active_mode].brightness * 25;
-
-        switch(modes[active_mode].value)
-        {
-            case AURA_KEYBOARD_MODE_BREATHING:
-            case AURA_KEYBOARD_MODE_REACTIVE:
-            case AURA_KEYBOARD_MODE_STARRY_NIGHT:
-            case AURA_KEYBOARD_MODE_CURRENT:
-            case AURA_KEYBOARD_MODE_RAIN_DROP:
-                if(!controller->is_per_led_keyboard && modes[active_mode].colors.size() > 1)
-                {
-                    color_mode = 1;
-                    break;
-                }
-
-                bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
-
-                if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
-                {
-                    color_mode = 16;
-                }
-                break;
-        }
-
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-        {
-            color_mode = 1;
-        }
-
-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
-        {
-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction  = direction_map[0][modes[active_mode].direction];
-        }
+        controller->UpdateLeds(colors);
    }
    else
    {
-        if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
+        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
+
+        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
        {
-            color_mode = 1;
+            if(modes[active_mode].colors[1] == 000)
+            {
+                color_mode = 0;
+            }
+            else
+            {
+                color_mode = 16;
+            }
+        }
+        else
+        {
+            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
        }

-        if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
-            if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
+        int direction = 0;

-            /*----------------------------------------------------------*\
-            | converting openrgb direction value to keyboard directions  |
-            \*----------------------------------------------------------*/
-            direction = direction_map[1][modes[active_mode].direction];
+        switch (modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                direction = 0;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                direction = 4;
+                break;
+            case MODE_DIRECTION_UP:
+                direction = 6;
+                break;
+            case MODE_DIRECTION_DOWN:
+                direction = 2;
+                break;
+            case MODE_DIRECTION_HORIZONTAL:
+                direction = 8;
+                break;
+            case MODE_DIRECTION_VERTICAL:
+                direction = 1;
+                break;
        }
-    }

+        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);

-    controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
-
-    if(pid == AURA_ROG_CLAYMORE_PID)
-    {
-        controller->UpdateMode(modes[active_mode].value);
-        controller->SaveMode();
-        controller->AllowRemoteControl(0);
+        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
    }
 }

 void RGBController_AuraTUFKeyboard::DeviceSaveMode()
 {
-    /*----------------------------------------------------------*\
-    | not available for Claymore                                 |
-    \*----------------------------------------------------------*/
-    if(pid != AURA_ROG_CLAYMORE_PID)
-    {
-        DeviceUpdateMode();
-        controller->SaveMode();
-    }
+    controller->ClearResponses();
+    DeviceUpdateMode();
+    controller->AwaitResponse();
+    controller->SaveMode();
 }
@@ -13,23 +13,12 @@

 enum
 {
+    AURA_KEYBOARD_SPEED_MIN          = 0,
+    AURA_KEYBOARD_SPEED_MAX          = 15,
+    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
    AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
    AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
-    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
-};
-
-enum
-{
-    AURA_CLAYMORE_SPEED_MIN                     = 254,
-    AURA_CLAYMORE_SPEED_MAX                     = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_STATIC          = 0,
-    AURA_CLAYMORE_SPEED_DEFAULT_BREATHING       = 107,
-    AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE     = 121,
-    AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE        = 56,
-    AURA_CLAYMORE_SPEED_DEFAULT_WAVE            = 50,
-    AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE          = 108,
-    AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT    = 54,
-    AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND       = 103
+    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
 };

 class RGBController_AuraTUFKeyboard : public RGBController
@@ -46,10 +35,10 @@ public:
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);

+    void        SetCustomMode();
    void        DeviceUpdateMode();
    void        DeviceSaveMode();

 private:
    AuraTUFKeyboardController*  controller;
-    uint16_t                    pid;
 };
@@ -16,9 +16,9 @@
    @save :x:
    @direct :white_check_mark:
    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
+    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
    @comment The Asus Aura USB controller applies to most AMD and
-        Intel mainboards from the x470 and z390 chipset generations.
+        Intel mainboards from the x470 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/

 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
@@ -249,6 +249,11 @@ void RGBController_AuraUSB::UpdateSingleLED(int led)
    controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
 }

+void RGBController_AuraUSB::SetCustomMode()
+{
+
+}
+
 void RGBController_AuraUSB::DeviceUpdateMode()
 {
    initializedMode   = true;
--- a/Show More
+++ b/Show More