Use read byte data for ENE detect

2022-10-02 23:01:28 -05:00
1289 changed files with 39855 additions and 108931 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
@@ -61,7 +60,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
  stage: build
  script:
  - export $(dpkg-architecture)
@@ -87,7 +86,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Linux 64 AppImage":
  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
  stage: build
  script:
  - export $(dpkg-architecture)
@@ -109,10 +108,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,7 +118,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

  rules:
@@ -138,10 +136,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,7 +146,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

  rules:
@@ -167,10 +164,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,7 +174,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

  rules:
@@ -196,10 +192,9 @@ 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
+  - rm -v ../openrgb-dbgsym*.deb
  - mv -v ../openrgb*.deb ./

  artifacts:
@@ -207,7 +202,7 @@ before_script:
    paths:
    - openrgb*.deb
    exclude:
-    - openrgb-dbgsym*.*deb
+    - openrgb-dbgsym*.deb
    expire_in: 30 days

  rules:
@@ -225,7 +220,6 @@ before_script:
  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
@@ -254,7 +248,6 @@ before_script:
  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
@@ -284,7 +277,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
@@ -317,9 +309,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
@@ -355,6 +346,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 +363,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 +380,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,6 +397,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 Bullseye)"
@@ -419,6 +414,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 Bookworm)"
@@ -435,6 +431,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 Bookworm)"
@@ -451,6 +448,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)"
@@ -467,6 +465,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 Bookworm)"
@@ -482,6 +481,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 +497,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 +529,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 +547,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,8 +575,6 @@ 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:
@@ -606,9 +609,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 +627,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 +655,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

 #-----------------------------------------------------------------------#
@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/
@@ -10,7 +10,6 @@ Please put "Initial commit for" name of the product, including manufacturer abov
 <!-- For admin purposes: Please leave this section as is -->

 # Checklist for Accepting a Merge Request for a New Device
- [ ] The source branch of the merge request is not protected (`master` is protected by default when creating a fork, so it is recommended to not use it as your source).
 - [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
 - [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
 - [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).
@@ -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"
-    ]
-}
@@ -1,20 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.cpp                                     |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+#include "AutoStart-FreeBSD.h"
+#include "LogManager.h"
+#include "filesystem.h"

 #include <fstream>
 #include <iostream>
 #include <limits.h>
 #include <unistd.h>
 #include <sstream>
-#include "AutoStart-FreeBSD.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| FreeBSD AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/

 AutoStart::AutoStart(std::string name)
 {
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.h                                       |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once

 #include <string>
@@ -1,21 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.cpp                                       |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <unistd.h>
-#include <linux/limits.h>
 #include "AutoStart-Linux.h"
 #include "LogManager.h"
 #include "filesystem.h"

+#include <fstream>
+#include <iostream>
+#include <unistd.h>
+#include <linux/limits.h>
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
 AutoStart::AutoStart(std::string name)
 {
    InitAutoStart(name);
@@ -125,7 +121,7 @@ std::string AutoStart::GetExePath()
    char exepath[ PATH_MAX ];

    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
-
+    
    return(std::string(exepath, (count > 0) ? count : 0));
 }

@@ -162,7 +158,7 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
    }

    fileContents << std::endl;
-
+    
    return(fileContents.str());
 }

@@ -201,7 +197,7 @@ void AutoStart::InitAutoStart(std::string name)
        std::error_code ec;

        bool success = true;
-
+        
        if(!filesystem::exists(autostart_dir))
        {
            success = filesystem::create_directories(autostart_dir, ec);
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.h                                         |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once

 #include <string>
@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.cpp                                       |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"

 #include <fstream>
 #include <sstream>
 #include <iostream>
 #include <unistd.h>
+
 #include <mach-o/dyld.h>
-#include "AutoStart-MacOS.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/

 AutoStart::AutoStart(std::string name)
 {
@@ -154,7 +152,7 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
    fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
    fileContents << "    <array>"                                                                                                   << std::endl;
    fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
-
+    
    if(autostart_info.args != "")
    {
        std::istringstream arg_parser(autostart_info.args);
@@ -165,12 +163,12 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
            fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
        }
    }
-
+    
    fileContents << "    </array>"                                                                                                  << std::endl;
    fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
    fileContents << "</dict>"                                                                                                       << std::endl;
    fileContents << "</plist>"                                                                                                      << std::endl;
-
+    
    return(fileContents.str());
 }

@@ -195,7 +193,7 @@ void AutoStart::InitAutoStart(std::string name)
        std::error_code ec;

        bool success = true;
-
+        
        if(!filesystem::exists(autostart_dir))
        {
            success = filesystem::create_directories(autostart_dir, ec);
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.h                                         |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once

 #include <string>
@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.cpp                                     |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <fstream>
-#include <iostream>
-#include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
 #include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+
 #include "windows.h"
+#include <shlobj.h>
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/

 AutoStart::AutoStart(std::string name)
 {
@@ -43,7 +41,7 @@ bool AutoStart::DisableAutoStart()
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
-
+            
            if(!success)
            {
                LOG_ERROR("An error occurred removing the auto start file.");
@@ -99,11 +97,11 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
            shellLink->SetArguments(argumentsw.c_str());
            shellLink->SetDescription(descriptionw.c_str());
            shellLink->SetIconLocation(iconw.c_str(), 0);
-
+            
            IPersistFile* persistFile;
-
+            
            result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
-
+            
            if(SUCCEEDED(result))
            {
                result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
@@ -153,7 +151,7 @@ std::string AutoStart::GetExePath()
    char exepath[MAX_PATH] = "";

    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
-
+    
    return(std::string(exepath, (count > 0) ? count : 0));
 }

@@ -199,8 +197,8 @@ std::wstring AutoStart::utf8_decode(const std::string& str)
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);

    std::wstring wstrTo(size_needed, 0);
-
+    
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-
+    
    return(wstrTo);
 }
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.h                                       |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once

 #include <string>
@@ -1,14 +1,10 @@
-/*---------------------------------------------------------*\
-| AutoStart.cpp                                             |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "AutoStart.h"

+/*-----------------------------------------------------*\
+| Common AutoStart Implementation                       |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
 std::string AutoStartInterface::GetAutoStartFile()
 {
    return(autostart_file);
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart.h                                               |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once

 #include <string>
@@ -11,7 +11,6 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 * Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * 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.
-* Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.

 ### Pipelines, Shared Runners and Quotas

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| Colors.h                                                  |
-|                                                           |
-|   List of named color constants                           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #ifndef COLORS_H
 #define COLORS_H

@@ -1,27 +1,15 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
 #include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "LogManager.h"
 #include "RGBController.h"

 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
 \*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
-#include "RGBController_BloodyB820R.h"

 /*-----------------------------------------------------*\
 | A4 Tech USB vendor ID                                 |
@@ -42,21 +30,5 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
    }
 }

-void DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
-        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-        rgb_controller->name                      = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody 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);
-REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -1,102 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "BloodyB820RController.h"
-
-/*-------------------------------------------------------------------------------------*\
-| The controller for this device should pass a packet of 64 bytes where the subsequent  |
-| two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control  |
-| or information bytes and colors bytes starts from index 6. Moreover, the first pack-  |
-| et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on   |
-| the second packet.                                                                    |
-\*-------------------------------------------------------------------------------------*/
-
-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
-{
-    dev                 = dev_handle;
-    location            = path;
-
-    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
-}
-
-BloodyB820RController::~BloodyB820RController()
-{
-    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
-    hid_close(dev);
-}
-
-std::string BloodyB820RController::GetSerial()
-{
-    const int szTemp    = HID_MAX_STR;
-    wchar_t   tmpName[szTemp];
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    std::wstring wName  = std::wstring(tmpName);
-    std::string serial  = std::string(wName.begin(), wName.end());
-
-    return(serial);
-}
-
-std::string BloodyB820RController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-void  BloodyB820RController::SendControlPacket(uint8_t data)
-{
-    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]    = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-
-    buffer[BLOODY_B820R_MODE_BYTE]              = 0;
-    buffer[BLOODY_B820R_DATA_BYTE]              = data;
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-}
-
-void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
-{
-
-    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
-    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
-    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
-    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
-    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
-    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
-
-    /*-----------------------------------------------------------------*\
-    | Set up Direct packet                                              |
-    |   packet_map is the index of the Key from full_matrix_map and     |
-    |   the value is the position in the direct packet buffer           |
-    \*-----------------------------------------------------------------*/
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor    color                       = colors[i];
-        uint8_t     offset                      = BLOODY_B820R_RGB_OFFSET;
-        uint8_t     buffer_idx                  = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
-        uint8_t*    buffers[2][3]               =
-                {
-                        {r1_buffer, g1_buffer, b1_buffer},
-                        {r2_buffer, g2_buffer, b2_buffer}
-                };
-
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
-    }
-
-    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
-}
@@ -1,53 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-#define HID_MAX_STR                     255
-
-#define BLOODY_B820R_RGB_BUFFER_SIZE    58
-#define BLOODY_B820R_RGB_OFFSET         6
-#define BLOODY_B820R_PACKET_SIZE        64
-#define BLOODY_B820R_KEYCOUNT           104
-#define BLOODY_B820R_MODE_BYTE          3
-#define BLOODY_B820R_DATA_BYTE          8
-#define BLOODY_B820R_GAIN_CONTROL       0x01
-#define BLOODY_B820R_RELEASE_CONTROL    0x00
-
-/*---------------------------------------------------------*\
-| Bloody B820R product ID                                   |
-\*---------------------------------------------------------*/
-#define BLOODY_B820R_PID                            0xFA10
-
-enum
-{
-    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
-};
-
-class BloodyB820RController
-{
-public:
-    BloodyB820RController(hid_device* dev_handle, const char* path);
-    ~BloodyB820RController();
-
-    std::string     GetSerial();
-    std::string     GetLocation();
-
-    void            SetLEDDirect(std::vector<RGBColor> colors);
-    void            SendControlPacket(uint8_t data);
-private:
-    std::string     location;
-    hid_device*     dev;
-};
@@ -1,253 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_BloodyB820R.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][21] =
-    {
-        {0,  NA, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, NA, NA,  NA,  NA,  13, 14,  15},
-        {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,  32,  33,  34, 35,  36},
-        {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,  53,  54,  55, 56,  57},
-        {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA,  NA,  71,  72, 73,  NA},
-        {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86,  NA,  87,  88, 89,  90},
-        {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
-    };
-
-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,
-        KEY_EN_F11,
-        KEY_EN_F12,
-        KEY_EN_PRINT_SCREEN,
-        KEY_EN_SCROLL_LOCK,
-        KEY_EN_PAUSE_BREAK,
-
-        KEY_EN_BACK_TICK,           //10
-        KEY_EN_1,
-        KEY_EN_2,
-        KEY_EN_3,
-        KEY_EN_4,
-        KEY_EN_5,
-        KEY_EN_6,
-        KEY_EN_7,
-        KEY_EN_8,
-        KEY_EN_9,
-        KEY_EN_0,
-        KEY_EN_MINUS,
-        KEY_EN_EQUALS,
-        KEY_EN_BACKSPACE,
-        KEY_EN_INSERT,
-        KEY_EN_HOME,
-        KEY_EN_PAGE_UP,
-        KEY_EN_NUMPAD_LOCK,
-        KEY_EN_NUMPAD_DIVIDE,
-        KEY_EN_NUMPAD_TIMES,
-        KEY_EN_NUMPAD_MINUS,
-
-        KEY_EN_TAB,                 //20
-        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,
-        KEY_EN_P,
-        KEY_EN_LEFT_BRACKET,
-        KEY_EN_RIGHT_BRACKET,
-        KEY_EN_ANSI_BACK_SLASH,
-        KEY_EN_DELETE,
-        KEY_EN_END,
-        KEY_EN_PAGE_DOWN,
-        KEY_EN_NUMPAD_7,
-        KEY_EN_NUMPAD_8,
-        KEY_EN_NUMPAD_9,
-        KEY_EN_NUMPAD_PLUS,
-
-        KEY_EN_CAPS_LOCK,           //30
-        KEY_EN_A,
-        KEY_EN_S,
-        KEY_EN_D,
-        KEY_EN_F,
-        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_NUMPAD_4,
-        KEY_EN_NUMPAD_5,
-        KEY_EN_NUMPAD_6,
-
-        KEY_EN_LEFT_SHIFT,          //40
-        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,
-        KEY_EN_RIGHT_SHIFT,
-        KEY_EN_UP_ARROW,
-        KEY_EN_NUMPAD_1,
-        KEY_EN_NUMPAD_2,
-        KEY_EN_NUMPAD_3,
-        KEY_EN_NUMPAD_ENTER,
-
-        KEY_EN_LEFT_CONTROL,        //50
-        KEY_EN_LEFT_WINDOWS,
-        KEY_EN_LEFT_ALT,
-        KEY_EN_SPACE,
-        KEY_EN_RIGHT_ALT,
-        KEY_EN_RIGHT_FUNCTION,
-        KEY_EN_MENU,
-        KEY_EN_RIGHT_CONTROL,
-        KEY_EN_LEFT_ARROW,
-        KEY_EN_DOWN_ARROW,
-        KEY_EN_RIGHT_ARROW,
-        KEY_EN_NUMPAD_0,
-        KEY_EN_NUMPAD_PERIOD
-    };
-
-/**------------------------------------------------------------------*\
-    @name A4Tech Bloody B820R
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors A4TechDetector
-    @comment The A4Tech Bloody B820R keyboard controller currently
-        supports the full size (ANSI layout).
-\*-------------------------------------------------------------------*/
-
-RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "Bloody B820R";
-    vendor                      = "A4Tech";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "A4Tech Bloody Keyboard";
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = BLOODY_B820R_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_BloodyB820R::~RGBController_BloodyB820R()
-{
-    delete controller;
-}
-
-void RGBController_BloodyB820R::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Create the Keyboard zone and add the matrix map   |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = ZONE_EN_KEYBOARD;
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = 6;
-    KB_zone.matrix_map->width   = 21;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
-    {
-        led new_led;
-        new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-
-void RGBController_BloodyB820R::DeviceUpdateLEDs()
-{
-    controller->SetLEDDirect(colors);
-}
-
-void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
-    {
-        colour.push_back(zones[zone].colors[i]);
-    }
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::UpdateSingleLED(int led)
-{
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateMode()
-{
-    /* This device does not support modes yet */
-}
@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "BloodyB820RController.h"
-
-class RGBController_BloodyB820R : public RGBController
-{
-public:
-    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
-    ~RGBController_BloodyB820R();
-
-    void    SetupZones();
-    void    ResizeZone(int zone, int new_size);
-
-    void    DeviceUpdateLEDs();
-    void    UpdateZoneLEDs(int zone);
-    void    UpdateSingleLED(int led);
-
-    void    DeviceUpdateMode();
-
-private:
-    BloodyB820RController* controller;
-};
@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.cpp                                            |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/

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

 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
@@ -28,7 +25,7 @@ BloodyMouseController::~BloodyMouseController()

 uint16_t BloodyMouseController::GetPid()
 {
-    return(pid);
+    return pid;
 }

 std::string BloodyMouseController::GetSerial()
@@ -47,7 +44,7 @@ std::string BloodyMouseController::GetSerial()
    std::wstring w_tmp  = std::wstring(tmp);
    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());

-    return(serial);
+    return serial;
 }

 std::string BloodyMouseController::GetLocation()
@@ -55,7 +52,7 @@ std::string BloodyMouseController::GetLocation()
    return("HID: " + location);
 }

-void BloodyMouseController::InitDevice()
+void  BloodyMouseController::InitDevice()
 {
    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };

@@ -67,7 +64,7 @@ void BloodyMouseController::InitDevice()
    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
 }

-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+void  BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
 {
    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };

@@ -1,32 +1,30 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.h                                              |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/

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

+#pragma once
+
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W90_MAX_PID                          0x3666

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
 \*-----------------------------------------------------*/
 #define BLOODY_MP_50RS_PID                          0xFA60

-#define HID_MAX_STR                     255
+#define HID_MAX_STR 255
 #define BLOODYMOUSE_WRITE_PACKET_SIZE   64

 #define BLOODYMOUSE_BRIGHTNESS_MIN      0
@@ -56,7 +54,6 @@ public:
    std::string     GetLocation();

    void            SetLedsDirect(std::vector<RGBColor> colors);
-
 private:
    uint16_t        pid;
    std::string     location;
@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.cpp                                        |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/

 #include "RGBController_BloodyMouse.h"

@@ -27,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
 {
    {
@@ -71,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();
@@ -103,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;
@@ -127,7 +109,7 @@ void RGBController_BloodyMouse::SetupZones()

        zone new_zone;
        new_zone.name           = mz.name;
-        new_zone.leds_min       = (unsigned int)mz.zone_leds.size();
+        new_zone.leds_min       = mz.zone_leds.size();
        new_zone.leds_max       = new_zone.leds_min;
        new_zone.leds_count     = new_zone.leds_min;
        new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.h                                          |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/

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

@@ -1,23 +1,23 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.cpp                              |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Driver for AMD Wraith Prism RGB lighting |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/

+#include "AMDWraithPrismController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
-#include "AMDWraithPrismController.h"

 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
-    dev                         = dev_handle;
-    location                    = path;
+    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;
@@ -33,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()
@@ -45,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];
@@ -61,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 = "";
@@ -190,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[] =
    {
@@ -213,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);
 }
@@ -249,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,
@@ -1,19 +1,16 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.h                                |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Definitions and types for AMD Wraith     |
+|  Prism lighting controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/

 #include <string>
 #include <hidapi/hidapi.h>
-#include "RGBController.h"
+
+#pragma once

 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
@@ -77,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
@@ -95,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;
@@ -116,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,
@@ -1,29 +1,11 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismControllerDetect.cpp                        |
-|                                                           |
-|   Detector for AMD Wraith Prism                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
+#include <hidapi/hidapi.h>

-/*---------------------------------------------------------*\
-| AMD Wraith Prism vendor ID                                |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_VID                        0x2516
-
-/*---------------------------------------------------------*\
-| AMD Wraith Prism product ID                               |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_PID                        0x0051
+#define AMD_WRAITH_PRISM_VID 0x2516
+#define AMD_WRAITH_PRISM_PID 0x0051

 /******************************************************************************************\
 *                                                                                          *
@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.cpp                          |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.cpp         |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/

 #include "RGBController_AMDWraithPrism.h"

@@ -27,37 +25,41 @@

 RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;

-    name                        = "AMD Wraith Prism";
-    vendor                      = "Cooler Master";
-    type                        = DEVICE_TYPE_COOLER;
-    description                 = "AMD Wraith Prism Device";
-    version                     = controller->GetFirmwareVersionString();
-    location                    = controller->GetLocationString();
+    name        = "AMD Wraith Prism";
+    vendor      = "Cooler Master";
+    type        = DEVICE_TYPE_COOLER;
+    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;
@@ -102,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();
@@ -137,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                                              |
    \*---------------------------------------------------------*/
@@ -168,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();
 }
@@ -214,95 +194,68 @@ 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();
-}
-
-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
+    UpdateZoneLEDs(led);
 }

 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;
@@ -310,15 +263,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);
            }
@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.h                            |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.h           |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/

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

@@ -1,212 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.cpp                                 |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <chrono>
-#include <cstring>
-#include <thread>
-#include "AOCKeyboardController.h"
-
-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,109 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.h                                   |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-/*-----------------------------------------*\
-| 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,47 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC keyboard                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "Detector.h"
-#include "AOCKeyboardController.h"
-#include "RGBController.h"
-#include "RGBController_AOCKeyboard.h"
-
-/*-----------------------------------------------------*\
-| AOC Keyboard IDs                                      |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_GK500_PID                               0x1178
-#define AOC_GK500_PID_2                             0x1229
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    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);
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2, 0xFF19, 0xFF19);
@@ -1,371 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.cpp                             |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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(unsigned int 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,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.h                               |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,132 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.cpp                                    |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "AOCMouseController.h"
-
-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,82 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.h                                      |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-/*-----------------------------------------*\
-| 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,45 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMouseControllerDetect.cpp                              |
-|                                                           |
-|   Detector for AOC mouse                                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "Detector.h"
-#include "AOCMouseController.h"
-#include "RGBController.h"
-#include "RGBController_AOCMouse.h"
-
-/*-----------------------------------------------------*\
-| AOC Mouse IDs                                         |
-\*-----------------------------------------------------*/
-#define AOC_VID                                     0x3938
-#define AOC_GM500_PID                               0x1179
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMouseControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mouse controller exists there.              *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
-{
-    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,218 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.cpp                                |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.h                                  |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,113 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.cpp                                 |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "AOCMousematController.h"
-
-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,81 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.h                                   |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-/*-----------------------------------------*\
-| 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,45 +0,0 @@
-/*---------------------------------------------------------*\
-| AOCMousematControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC mousemat                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,195 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.cpp                             |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.h                               |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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;
-};
@@ -1,29 +1,22 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.cpp                         |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.cpp        |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+\*-----------------------------------------*/

+#include "RGBController.h"
+#include "ASRockPolychromeUSBController.h"
 #include <cstring>
 #include <stdio.h>
-#include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-#include "ASRockPolychromeUSBController.h"
-#include "dmiinfo.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

@@ -36,7 +29,7 @@ const char* polychrome_USB_zone_names[] =
    "PCH",
    "IO Cover",
    "PCB",
-    "Addressable Header 3/Audio",
+    "Audio",
 };

 PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
@@ -57,7 +50,7 @@ PolychromeUSBController::~PolychromeUSBController()

 unsigned int PolychromeUSBController::GetChannelCount()
 {
-    return((unsigned int)device_info.size());
+    return(device_info.size());
 }

 std::string PolychromeUSBController::GetDeviceLocation()
@@ -79,7 +72,7 @@ std::string PolychromeUSBController::GetSerialString()
    {
        return("");
    }
-
+    
    std::wstring return_wstring = serial_string;
    std::string return_string(return_wstring.begin(), return_wstring.end());

@@ -89,64 +82,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. |
@@ -160,11 +108,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;

@@ -174,9 +117,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                               |
            \*-----------------------------------------*/
@@ -189,26 +133,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
@@ -216,13 +140,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];

@@ -237,20 +161,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;
@@ -265,126 +179,67 @@ void PolychromeUSBController::WriteZone

 void PolychromeUSBController::WriteAllZones
    (
-    const std::vector<PolychromeZoneInfo>&  /*zones_info*/,
+    const std::vector<PolychromeZoneInfo>&  zones_info,
    const std::vector<zone>&                zones
    )
 {
-    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[0x03] = 0x07;
+    usb_buf[0x04] = zones_info[0].mode;
+    usb_buf[0x04] = 0xE2;

-    std::size_t initial_led_offset = 9;
-    std::size_t message_byte_capacity = 54;           // 18 leds * 3 bytes
-
-    std::size_t led_byte_idx = 0;
-
-    while(led_byte_idx < combined_leds_rgb.size())
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
-        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);
+        usb_buf[0x05 + (3 * zone_idx)    ] = RGBGetRValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 1] = RGBGetGValue(zones[zone_idx].colors[0]);
+        usb_buf[0x05 + (3 * zone_idx) + 2] = RGBGetBValue(zones[zone_idx].colors[0]);
    }
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }

 void PolychromeUSBController::WriteRGSwap
    (
-    bool hdr0,
-    bool hdr1,
-    bool ahdr0,
    bool ahdr1,
-    bool pch,
-    bool io,
-    bool pcb,
-    bool chnl8
+    bool ahdr0,
+    bool hdr1,
+    bool hdr0
    )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>((((unsigned char)chnl8 << 7) | ((unsigned char)pcb << 6) | ((unsigned char)io << 5) | ((unsigned char)pch << 4) | ((unsigned char)ahdr1 << 3) | ((unsigned char)ahdr0 << 2) | ((unsigned char)hdr1 << 1) | (unsigned char)hdr0))};
-    WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
+    unsigned char 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_WRITE_HEADER;
+
+    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
+	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 64);
 }

 void PolychromeUSBController::WriteHeader
@@ -437,7 +292,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                                           |
@@ -449,28 +304,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] != 0xE2 ? usb_buf[0x04] : 0x0F;
+    zoneinfo.color  = ToRGBColor(r,g,b);  
    zoneinfo.speed  = usb_buf[0x08];
    zoneinfo.zone   = usb_buf[0x03];

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

    /*-----------------------------------------------------*\
@@ -508,7 +348,7 @@ void PolychromeUSBController::ReadConfigTables()

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

@@ -528,10 +368,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                                       |
@@ -547,15 +387,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;
 }
@@ -1,21 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.h                           |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.h          |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>

 #pragma once

-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
@@ -72,7 +69,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
@@ -94,7 +91,6 @@ struct PolychromeDeviceInfo
    unsigned char           effect_channel;
    unsigned char           num_leds;
 	unsigned char			zone_type;
-    bool        			rgswap;
    PolychromeDeviceType    device_type;
 };

@@ -135,33 +131,19 @@ 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 SetDeviceInfo();    
    void ReadConfigTables();
    void Commit();
 };
@@ -1,25 +1,13 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBControllerDetect.cpp                   |
-|                                                           |
-|   Detector for ASRock Polychrome USB motherboards         |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
-#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
 #include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <hidapi/hidapi.h>

 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -44,5 +32,5 @@ void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*
    }
 }

-REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip",  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
+REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
@@ -1,17 +1,14 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.cpp                     |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.cpp    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+\*-----------------------------------------*/

-#include <string.h>
 #include "RGBController_ASRockPolychromeUSB.h"
+#include <string.h>

 #define ASROCK_USB_MAX_ZONES        8
 #define ASROCK_ADDRESSABLE_MAX_LEDS 100
@@ -25,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)
@@ -183,6 +181,11 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
    modes.push_back(Direct);

    SetupZones();
+
+    /*-------------------------------------------------*\
+    | Initialize active mode                            |
+    \*-------------------------------------------------*/
+    active_mode = GetDeviceMode(1);
 }

 void RGBController_PolychromeUSB::SetupZones()
@@ -235,6 +238,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               |
@@ -246,37 +259,26 @@ 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()
@@ -295,7 +297,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
            set_mode = active_mode;
        }

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

@@ -336,12 +338,6 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)

 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)
@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.h                       |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.h      |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+\*-----------------------------------------*/

 #pragma once

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.cpp                           |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.cpp      |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/

 #include "ASRockASRRGBSMBusController.h"
 #include <cstring>
-#include "dmiinfo.h"
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"

 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -66,7 +64,7 @@ void ASRockASRRGBSMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, ui
 {
    uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
    uint8_t select_led_pkt[1]  = { led };
-
+    
    /*-----------------------------------------------------*\
    | Select LED                                            |
    \*-----------------------------------------------------*/
@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.h                             |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockASRRGBSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>

 #pragma once

-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t	polychrome_dev_id;

 #define ASROCK_ASR_CONTROLLER_NAME  "ASRock ASR RGB SMBus Controller"
@@ -64,7 +63,7 @@ public:
    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);
-
+    
    uint16_t                fw_version;

 private:
@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.h                               |
-|                                                           |
-|   RGBController for SMBus ASRock ASR RGB motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockASRRGBSMBusController.h"
-
-class RGBController_ASRockASRRGBSMBus : public RGBController
-{
-public:
-    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
-    ~RGBController_ASRockASRRGBSMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockASRRGBSMBusController* controller;
-};
@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/

-#include <cstring>
 #include "ASRockPolychromeV1SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"

 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.h      |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/

-#pragma once
-
-#include <string>
 #include "i2c_smbus.h"
 #include "RGBController.h"
+#include <string>
+
+#pragma once

 typedef uint8_t	polychrome_dev_id;

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV1SMBusController.h"
-
-class RGBController_ASRockPolychromeV1SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV1SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
-};
@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV2SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/

-#include <cstring>
 #include "ASRockPolychromeV2SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"

 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>

 #pragma once

-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t polychrome_dev_id;

 #define ASROCK_V2_CONTROLLER_NAME  "ASRock Polychrome v2 SMBus Controller"
@@ -133,7 +132,7 @@ public:

    uint8_t                 zone_led_count[6];
    uint16_t                fw_version;
-
+    
 private:
    std::string             device_name;
    uint8_t                 active_zone;
@@ -1,36 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV2SMBusController.h"
-
-class RGBController_ASRockPolychromeV2SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV2SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV2SMBusController* controller;
-};
@@ -1,18 +1,3 @@
-/*---------------------------------------------------------*\
-| ASRockSMBusControllerDetect.cpp                           |
-|                                                           |
-|   Detector for SMBus ASRock ASR RGB and Polychrome        |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
 #include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
@@ -24,6 +9,9 @@
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>

 /*******************************************************************************************\
 *                                                                                           *
@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.cpp                             |
-|                                                           |
-|   RGBController for SMBus ASRock ASR LED motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/

 #include "RGBController_ASRockASRRGBSMBus.h"

@@ -169,7 +167,7 @@ void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -1,31 +1,33 @@
-/*-----------------------------------------*\
-|  RGBController_PNYLovelaceGPU.h           |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  PNY GPU RGB  (Lovelace) Driver           |
-|                                           |
-|  yufan   10/1/2023                        |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "PNYLovelaceGPUController.h"
-
-class RGBController_PNYLovelaceGPU : public RGBController
-{
-public:
-    RGBController_PNYLovelaceGPU(PNYLovelaceGPUController* controller_ptr);
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    PNYLovelaceGPUController* controller;
-};
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.h    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockASRRGBSMBusController.h"
+
+class RGBController_ASRockASRRGBSMBus : public RGBController
+{
+public:
+    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
+    ~RGBController_ASRockASRRGBSMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockASRRGBSMBusController* controller;
+};
@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/

 #include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
@@ -108,7 +105,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    mode Music;
    Music.name                  = "Music";
    Music.value                 = POLYCHROME_V1_MODE_MUSIC;
-    Music.flags                 = MODE_FLAG_AUTOMATIC_SAVE;
+    Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
    Music.color_mode            = MODE_COLORS_NONE;
    modes.push_back(Music);

@@ -125,6 +122,7 @@ 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;
@@ -194,6 +192,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
    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    |
@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV1SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV1SMBusController.h"
+
+class RGBController_ASRockPolychromeV1SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV1SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
+};
@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV2SMBus.cpp|
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/

 #include "RGBController_ASRockPolychromeV2SMBus.h"

@@ -290,7 +287,7 @@ void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_s

 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -1,31 +1,33 @@
-/*-----------------------------------------*\
-|  RGBController_PalitGPU.h                 |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Palit GPU RGB Driver                     |
-|                                           |
-|  Manatsawin Hanmongkolchai  04/11/2023    |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "PalitGPUController.h"
-
-class RGBController_PalitGPU : public RGBController
-{
-public:
-    RGBController_PalitGPU(PalitGPUController* controller_ptr);
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    PalitGPUController* controller;
-};
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromev2SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV2SMBusController.h"
+
+class RGBController_ASRockPolychromeV2SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV2SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV2SMBusController* controller;
+};
@@ -1,14 +1,13 @@
-/*---------------------------------------------------------*\
-| AlienwareController.cpp                                   |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 21 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.cpp                  |
+|                                           |
+|  Driver for Alienware lighting controller |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/21/2021    |
+\*-----------------------------------------*/

+#include "RGBController.h"
+#include "AlienwareController.h"
 #include <cstring>
 #include <cstdint>
 #include <map>
@@ -16,9 +15,6 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "RGBController.h"
-#include "AlienwareController.h"
-#include "LogManager.h"

 typedef uint32_t alienware_platform_id;

@@ -28,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
 };

 /*---------------------------------------------------------*\
@@ -45,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)
@@ -120,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"                          |
@@ -170,7 +160,7 @@ AlienwareController::~AlienwareController()

 unsigned int AlienwareController::GetZoneCount()
 {
-    return((unsigned int)zones.size());
+    return(zones.size());
 }

 std::vector<const char*> AlienwareController::GetZoneNames()
@@ -275,7 +265,7 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
    /*-----------------------------------------------------*\
    | Set up message packet with leading 00, per hidapi     |
    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();

    usb_buf[0x00]       = 0x00;
    usb_buf[0x01]       = 0x03;
@@ -379,7 +369,7 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
    /*-----------------------------------------------------*\
    | Set up message packet with leading 00, per hidapi     |
    \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();

    usb_buf[0x00]       = 0x00;
    usb_buf[0x01]       = 0x03;
@@ -518,7 +508,7 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
    /*-----------------------------------------------------*\
    | Set up message packet with leading 00, per hidapi     |
    \*-----------------------------------------------------*/
-    uint16_t num_zones      = (uint16_t)zones.size();
+    uint16_t num_zones      = zones.size();

    usb_buf[0x00]           = 0x00;
    usb_buf[0x01]           = 0x03;
@@ -602,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)
@@ -1,27 +1,25 @@
-/*---------------------------------------------------------*\
-| AlienwareController.h                                     |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.h                    |
+|                                           |
+|  Driver for Dell Alienware RGB USB        |
+|  controller                               |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>

 #pragma once

-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Alienware Controller                                                           |
 \*----------------------------------------------------------------------------------------------*/

 #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               */
@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AlienwareControllerDetect.cpp                             |
-|                                                           |
-|   Detector for Dell Alienware RGB USB controller          |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AlienwareController.h"
 #include "RGBController.h"
@@ -20,7 +11,7 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID                      0x0550
+#define ALIENWARE_G_SERIES_PID                         0x0550

 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -1,17 +1,16 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.cpp                               |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware USB Driver                     |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_Alienware.h"

 #include <thread>
 #include <chrono>
-#include "RGBController_Alienware.h"

 /**------------------------------------------------------------------*\
    @name Alienware
@@ -214,7 +213,7 @@ void RGBController_Alienware::DeviceUpdateMode()
        /*-----------------------------------------------------*\
        | Setup state per zone                                  |
        \*-----------------------------------------------------*/
-        for(uint8_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
        {
            zone current_zone = zones[zone_idx];

@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.h                                 |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware RGB USB Driver                 |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/

 #pragma once

-#include <chrono>
 #include "RGBController.h"
 #include "AlienwareController.h"

+#include <chrono>
+
 class RGBController_Alienware : public RGBController
 {
 public:
@@ -1,448 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "AlienwareAW410KController.h"
-
-AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    SendCommit();
-}
-
-AlienwareAW410KController::~AlienwareAW410KController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareAW410KController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareAW410KController::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 AlienwareAW410KController::SendCommit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x0A]           = 0x10;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0C]           = 0x01;
-    usb_buf[0x0D]           = 0x02;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-}
-
-void AlienwareAW410KController::SendfeatureReport
-    (
-    unsigned char   first_byte,
-    unsigned char   second_byte,
-    unsigned char   third_byte,
-    unsigned char   forth_byte
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Feature report packet                          |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = first_byte;
-    usb_buf[0x02]           = second_byte;
-    usb_buf[0x03]           = third_byte;
-    usb_buf[0x04]           = forth_byte;
-
-    /*-----------------------------------------------------*\
-    | Send Feature report packet                            |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 10 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-}
-
-void AlienwareAW410KController::SendEdit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Edit packet                                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x01;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendInitialize()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = 0xAD;
-    usb_buf[0x06]           = 0x80;
-    usb_buf[0x07]           = 0x10;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SetDirect
-    (
-    unsigned char   /*zone*/,
-    unsigned char   r,
-    unsigned char   g,
-    unsigned char   b
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x01;
-    usb_buf[0x04]           = r;
-    usb_buf[0x05]           = g;
-    usb_buf[0x06]           = b;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendDirectOn
-    (
-    std::vector<SelectedButtons>     &frame_data
-    )
-{
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
-
-    /*-----------------------------------------------*\
-    | 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++)
-    {
-        SelectedButtons key;
-        key.idx     = 0x00;
-        key.red     = 0x00;
-        key.green   = 0x00;
-        key.blue    = 0x00;
-
-        frame_data.push_back(key);
-    }
-
-    unsigned char usb_buf[65];
-    unsigned int  frame_idx = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 65);
-
-    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
-    {
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0x0E;
-        usb_buf[0x02]           = 0x01;
-        usb_buf[0x03]           = 0x00;
-        usb_buf[0x04]           = ++frame_idx;
-        usb_buf[0x05]           = frame_data[packet_idx].idx;
-        usb_buf[0x06]           = 0x81;
-        usb_buf[0x07]           = 0x00;
-        usb_buf[0x08]           = 0xA5;
-        usb_buf[0x0A]           = 0x0A;
-        usb_buf[0x0B]           = frame_data[packet_idx].red;
-        usb_buf[0x0C]           = frame_data[packet_idx].green;
-        usb_buf[0x0D]           = frame_data[packet_idx].blue;
-        usb_buf[0x12]           = 0x01;
-
-        usb_buf[0x14]           = frame_data[++packet_idx].idx;
-        usb_buf[0x15]           = 0x81;
-        usb_buf[0x16]           = 0x00;
-        usb_buf[0x17]           = 0xA5;
-        usb_buf[0x19]           = 0x0A;
-        usb_buf[0x1A]           = frame_data[packet_idx].red;
-        usb_buf[0x1B]           = frame_data[packet_idx].green;
-        usb_buf[0x1C]           = frame_data[packet_idx].blue;
-        usb_buf[0x21]           = 0x01;
-
-        usb_buf[0x23]           = frame_data[++packet_idx].idx;
-        usb_buf[0x24]           = 0x81;
-        usb_buf[0x25]           = 0x00;
-        usb_buf[0x26]           = 0xA5;
-        usb_buf[0x28]           = 0x0A;
-        usb_buf[0x29]           = frame_data[packet_idx].red;
-        usb_buf[0x2A]           = frame_data[packet_idx].green;
-        usb_buf[0x2B]           = frame_data[packet_idx].blue;
-        usb_buf[0x30]           = 0x01;
-
-        usb_buf[0x32]           = frame_data[++packet_idx].idx;
-        usb_buf[0x33]           = 0x81;
-        usb_buf[0x34]           = 0x00;
-        usb_buf[0x35]           = 0xA5;
-        usb_buf[0x37]           = 0x0A;
-        usb_buf[0x38]           = frame_data[packet_idx].red;
-        usb_buf[0x39]           = frame_data[packet_idx].green;
-        usb_buf[0x3A]           = frame_data[packet_idx].blue;
-        usb_buf[0x3F]           = 0x01;
-
-        hid_write(dev, (unsigned char *)usb_buf, 65);
-    }
-}
-
-
-void AlienwareAW410KController::SetMode
-    (
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
-    SendCommit();
-}
-
-void AlienwareAW410KController::UpdateSingleLED
-    (
-    unsigned char   led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
-
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Single LED packet                              |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = led;
-    usb_buf[0x06]           = 0x81;
-    usb_buf[0x07]           = 0x00;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x09]           = 0x00;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x0B]           = red;
-    usb_buf[0x0C]           = green;
-    usb_buf[0x0D]           = blue;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
-}
-void AlienwareAW410KController::SendMode
-    (
-    unsigned char   /*zone*/,
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Mode Control packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red;
-    usb_buf[0x05]           = green;
-    usb_buf[0x06]           = blue;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = colorMode;
-    usb_buf[0x0F]           = direction;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AlienwareAW410KController::SetMorphMode
-    (
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   red1,
-    unsigned char   green1,
-    unsigned char   blue1,
-    unsigned char   red2,
-    unsigned char   green2,
-    unsigned char   blue2
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Morph Mode packet                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red1;
-    usb_buf[0x05]           = green1;
-    usb_buf[0x06]           = blue1;
-    usb_buf[0x07]           = red2;
-    usb_buf[0x08]           = green2;
-    usb_buf[0x09]           = blue2;
-    usb_buf[0x0E]           = 0x02;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
@@ -1,155 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.h                               |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi/hidapi.h>
-#include "RGBController.h"
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
-};
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
-    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
-    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
-};
-
-enum
-{
-    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
-    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
-    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
-    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
-    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
-    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
-    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
-    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
-    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
-    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
-    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
-    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
-};
-
-enum
-{
-    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
-    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
-    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
-    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
-    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
-    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
-};
-
-struct SelectedButtons
-{
-    unsigned char idx;
-    unsigned char red;
-    unsigned char green;
-    unsigned char blue;
-};
-
-class AlienwareAW410KController
-{
-public:
-    AlienwareAW410KController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW410KController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendInitialize();
-    void        SendCommit();
-    void        SendfeatureReport
-                    (
-                    unsigned char   first_byte,
-                    unsigned char   second_byte,
-                    unsigned char   third_byte,
-                    unsigned char   forth_byte
-                    );
-
-    void        SendEdit();
-
-    void        SetDirect
-                    (
-                    unsigned char   zone,
-                    unsigned char   r,
-                    unsigned char   g,
-                    unsigned char   b
-                    );
-
-    void    SendDirectOn
-                    (
-                    std::vector<SelectedButtons>     &frame_data
-                    );
-
-    void        SetMode
-                    (
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-    void        SetMorphMode
-                    (
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   red1,
-                    unsigned char   green1,
-                    unsigned char   blue1,
-                    unsigned char   red2,
-                    unsigned char   green2,
-                    unsigned char   blue2
-                    );
-
-    void        UpdateSingleLED
-                    (
-                    unsigned char   led,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void        SendMode
-                    (
-                    unsigned char   zone,
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-};
@@ -1,482 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW410K.cpp                         |
-|                                                           |
-|   RGBController for Alienware AW410K keyboard             |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <iterator>
-#include "RGBControllerKeyNames.h"
-#include "RGBController_AlienwareAW410K.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-int GetAW410K_WaveDirection(int input);
-
-static unsigned int matrix_map[6][24] =
-{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12, NA,  13,  14,  15,  NA,  NA,  16,  17,  18 },
-  {  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  NA, NA,  33,  34,  35,  NA,  36,  37,  38,  39 },
-  {  40,  NA,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53, NA,  54,  55,  56,  NA,  57,  58,  59,  60 },
-  {  61,  NA,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  NA,  73, NA,  NA,  NA,  NA,  NA,  74,  75,  76,  NA },
-  {  77,  NA,  NA,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  NA, NA,  NA,  89,  NA,  NA,  90,  91,  92,  93 },
-  {  94,  NA,  95,  96,  NA,  NA,  NA,  97,  NA,  NA,  NA,  98,  99, 100, 101, NA, 102, 103, 104,  NA, 105,  NA, 106,  NA }};
-
-static const char* zone_names[] =
-{
-    "AW410K",
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    107,
-};
-
-typedef struct
-{
-    const char *        name;
-    const unsigned char zone;
-    const unsigned char idx;
-} aw410k_led_type;
-
-static const aw410k_led_type led_names[] =
-{
-    /* Key Label                Zone,                                      Index  */
-    { KEY_EN_ESCAPE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB0    },
-    { KEY_EN_F1,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x98    },
-    { KEY_EN_F2,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x90    },
-    { KEY_EN_F3,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x88    },
-    { KEY_EN_F4,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x80    },
-    { KEY_EN_F5,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x70    },
-    { KEY_EN_F6,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x68    },
-    { KEY_EN_F7,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x60    },
-    { KEY_EN_F8,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x58    },
-    { KEY_EN_F9,                ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x50    },
-    { KEY_EN_F10,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x48    },
-    { KEY_EN_F11,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x40    },
-    { KEY_EN_F12,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x38    },
-    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x30    },
-    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x28    },
-    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x20    },
-    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x18    },
-    { KEY_EN_MEDIA_VOLUME_DOWN, ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x10    },
-    { KEY_EN_MEDIA_VOLUME_UP,   ALIENWARE_AW410K_ZONE_DIRECT_MEDIA,        0x08    },
-    { KEY_EN_BACK_TICK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB1    },
-    { KEY_EN_1,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA1    },
-    { KEY_EN_2,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x99    },
-    { KEY_EN_3,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x91    },
-    { KEY_EN_4,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x89    },
-    { KEY_EN_5,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x81    },
-    { KEY_EN_6,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x79    },
-    { KEY_EN_7,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x71    },
-    { KEY_EN_8,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x69    },
-    { KEY_EN_9,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x61    },
-    { KEY_EN_0,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x59    },
-    { KEY_EN_MINUS,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x51    },
-    { KEY_EN_EQUALS,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x49    },
-    { KEY_EN_BACKSPACE,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x39    },
-    { KEY_EN_INSERT,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x31    },
-    { KEY_EN_HOME,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x29    },
-    { KEY_EN_PAGE_UP,           ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x21    },
-    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x19    },
-    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x11    },
-    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x09    },
-    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x01    },
-    { KEY_EN_TAB,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB2    },
-    { KEY_EN_Q,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA2    },
-    { KEY_EN_W,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9A    },
-    { KEY_EN_E,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x92    },
-    { KEY_EN_R,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8A    },
-    { KEY_EN_T,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x82    },
-    { KEY_EN_Y,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7A    },
-    { KEY_EN_U,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x72    },
-    { KEY_EN_I,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6A    },
-    { KEY_EN_O,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x62    },
-    { KEY_EN_P,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5A    },
-    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x52    },
-    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4A    },
-    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x42    },
-    { KEY_EN_DELETE,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x32    },
-    { KEY_EN_END,               ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2A    },
-    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x22    },
-    { KEY_EN_NUMPAD_7,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1A    },
-    { KEY_EN_NUMPAD_8,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x12    },
-    { KEY_EN_NUMPAD_9,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0A    },
-    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x03    },
-    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB3    },
-    { KEY_EN_A,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA3    },
-    { KEY_EN_S,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9B    },
-    { KEY_EN_D,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x93    },
-    { KEY_EN_F,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8B    },
-    { KEY_EN_G,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x83    },
-    { KEY_EN_H,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7B    },
-    { KEY_EN_J,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x73    },
-    { KEY_EN_K,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6B    },
-    { KEY_EN_L,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x63    },
-    { KEY_EN_SEMICOLON,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5B    },
-    { KEY_EN_QUOTE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x53    },
-    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x43    },
-    { KEY_EN_NUMPAD_4,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1B    },
-    { KEY_EN_NUMPAD_5,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x13    },
-    { KEY_EN_NUMPAD_6,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0B    },
-    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB4    },
-    { KEY_EN_Z,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA4    },
-    { KEY_EN_X,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x9C    },
-    { KEY_EN_C,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x94    },
-    { KEY_EN_V,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x8C    },
-    { KEY_EN_B,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x84    },
-    { KEY_EN_N,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x7C    },
-    { KEY_EN_M,                 ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x74    },
-    { KEY_EN_COMMA,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x6C    },
-    { KEY_EN_PERIOD,            ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x64    },
-    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5C    },
-    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4C    },
-    { KEY_EN_UP_ARROW,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2C    },
-    { KEY_EN_NUMPAD_1,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1C    },
-    { KEY_EN_NUMPAD_2,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x14    },
-    { KEY_EN_NUMPAD_3,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0C    },
-    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x05    },
-    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xB5    },
-    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xAD    },
-    { KEY_EN_LEFT_ALT,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0xA5    },
-    { KEY_EN_SPACE,             ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x85    },
-    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x65    },
-    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x5D    },
-    { KEY_EN_MENU,              ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x55    },
-    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x4D    },
-    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x35    },
-    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x2D    },
-    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x25    },
-    { KEY_EN_NUMPAD_0,          ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x1D    },
-    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD,     0x0D    }
-};
-
-/**------------------------------------------------------------------*\
-    @name Alienware AW410 Keyboard
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAlienwareAW410KControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr)
-{
-    controller                      = controller_ptr;
-
-    name                            = "Alienware AW410K Keyboard Device";
-    vendor                          = "Alienware";
-    type                            = DEVICE_TYPE_KEYBOARD;
-    description                     = "Alienware AW410K Keyboard Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = ALIENWARE_AW410K_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                    = ALIENWARE_AW410K_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Pulse;
-    Pulse.name                      = "Pulse";
-    Pulse.value                     = ALIENWARE_AW410K_MODE_PULSE;
-    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Pulse.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    Pulse.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
-    Pulse.colors_min                = 1;
-    Pulse.colors_max                = 1;
-    Pulse.colors.resize(1);
-    modes.push_back(Pulse);
-
-    mode Morph;
-    Morph.name                      = "Morph";
-    Morph.value                     = ALIENWARE_AW410K_MODE_MORPH;
-    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Morph.speed_min                 = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Morph.speed_max                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    Morph.speed                     = ALIENWARE_AW410K_SPEED_NORMAL;
-    Morph.colors_min                = 2;
-    Morph.colors_max                = 2;
-    Morph.colors.resize(2);
-    modes.push_back(Morph);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = ALIENWARE_AW410K_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    Breathing.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    Breathing.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    Breathing.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode SingleWave;
-    SingleWave.name                  = "Single Wave";
-    SingleWave.value                 = ALIENWARE_AW410K_MODE_SINGLE_WAVE;
-    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    SingleWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    SingleWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    SingleWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    SingleWave.colors_min            = 1;
-    SingleWave.colors_max            = 1;
-    SingleWave.colors.resize(1);
-    modes.push_back(SingleWave);
-
-    mode RainbowWave;
-    RainbowWave.name                  = "Rainbow Wave";
-    RainbowWave.value                 = ALIENWARE_AW410K_MODE_RAINBOW_WAVE;
-    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    RainbowWave.speed_min             = ALIENWARE_AW410K_SPEED_SLOWEST;
-    RainbowWave.speed_max             = ALIENWARE_AW410K_SPEED_FASTEST;
-    RainbowWave.speed                 = ALIENWARE_AW410K_SPEED_NORMAL;
-    RainbowWave.colors_min            = 1;
-    RainbowWave.colors_max            = 1;
-    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RainbowWave.colors.resize(1);
-    modes.push_back(RainbowWave);
-
-    mode Off;
-    Off.name                          = "Off";
-    Off.value                         = ALIENWARE_AW410K_MODE_OFF;
-    Off.flags                         = 0;
-    Off.color_mode                    = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    SetupZones();
-    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
-}
-
-RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_AlienwareAW410K::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
-{
-    std::vector<SelectedButtons>   frame_buf_keys;
-    std::vector<RGBColor>       new_colors;
-
-    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
-
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-            SelectedButtons key;
-
-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
-
-            frame_buf_keys.push_back(key);
-    }
-
-    controller->SendInitialize();
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    controller->SendCommit();
-
-    if(frame_buf_keys.size() > 0)
-    {
-        controller->SendDirectOn(frame_buf_keys);
-    }
-
-    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
-}
-
-void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
-{
-    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
-}
-
-void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
-{
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
-}
-
-void RGBController_AlienwareAW410K::DeviceUpdateMode()
-{
-    if(active_mode == 0xFFFF)
-    {
-        UpdateLEDs();
-        return;
-    }
-
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    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]);
-    }
-
-    switch(modes[active_mode].value)
-    {
-        case ALIENWARE_AW410K_MODE_DIRECT:
-            /*-------------------------------------------------------------*\
-            | Load LEDs again in case of profile load etc.                  |
-            \*-------------------------------------------------------------*/
-            DeviceUpdateLEDs();
-            break;
-        case ALIENWARE_AW410K_MODE_MORPH:
-            /*-------------------------------------------------------------*\
-            | In case of morph it requires two colors (color1 and color2)   |
-            \*-------------------------------------------------------------*/
-            {
-                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
-                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
-                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
-
-                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
-            }
-            break;
-
-        case ALIENWARE_AW410K_MODE_SPECTRUM:
-            /*-------------------------------------------------------------*\
-            | Spectrum only set mode, speed and colorMode                   |
-            \*-------------------------------------------------------------*/
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            break;
-
-        case ALIENWARE_AW410K_MODE_SINGLE_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-                int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
-                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
-            }
-            break;
-
-        case ALIENWARE_AW410K_MODE_RAINBOW_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-            int waveDirection = GetAW410K_WaveDirection(modes[active_mode].direction);
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW410K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            }
-            break;
-
-
-        default:
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW410K_SINGLE_COLOR_MODE, red, grn, blu);
-            break;
-    }
-}
-
-int GetAW410K_WaveDirection(int input)
-{
-    switch(input)
-    {
-        case MODE_DIRECTION_LEFT:
-            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
-
-        case MODE_DIRECTION_RIGHT:
-            return(ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT);
-
-        case MODE_DIRECTION_UP:
-            return(ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP);
-
-        case MODE_DIRECTION_DOWN:
-            return(ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM);
-
-        default:
-            return(ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT);
-    }
-}
-
@@ -1,37 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW410K.h                           |
-|                                                           |
-|   RGBController for Alienware AW410K keyboard             |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW410KController.h"
-
-class RGBController_AlienwareAW410K : public RGBController
-{
-public:
-    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
-    ~RGBController_AlienwareAW410K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW410KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};
@@ -1,16 +1,14 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.cpp            |
+|                                           |
+|  Driver for Alienware AW510K              |
+|  keyboard light controller                |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AlienwareAW510KController.h"
+#include <cstring>

 AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
@@ -43,7 +41,7 @@ std::string AlienwareAW510KController::GetSerialString()

 void AlienwareAW510KController::SendCommit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -65,7 +63,7 @@ void AlienwareAW510KController::SendCommit()
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);

    /*-----------------------------------------------------*\
    | Delay 20 milliseconds                                 |
@@ -73,6 +71,7 @@ void AlienwareAW510KController::SendCommit()
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
 }

+
 void AlienwareAW510KController::SendfeatureReport
    (
    unsigned char   first_byte,
@@ -81,7 +80,7 @@ void AlienwareAW510KController::SendfeatureReport
    unsigned char   forth_byte
    )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -100,7 +99,7 @@ void AlienwareAW510KController::SendfeatureReport
    /*-----------------------------------------------------*\
    | Send Feature report packet                            |
    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);

    /*-----------------------------------------------------*\
    | Delay 10 milliseconds                                 |
@@ -110,7 +109,7 @@ void AlienwareAW510KController::SendfeatureReport

 void AlienwareAW510KController::SendEdit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -128,7 +127,7 @@ void AlienwareAW510KController::SendEdit()
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);

    /*-----------------------------------------------------*\
    | Delay 2 milliseconds                                  |
@@ -138,7 +137,7 @@ void AlienwareAW510KController::SendEdit()

 void AlienwareAW510KController::SendInitialize()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -163,7 +162,7 @@ void AlienwareAW510KController::SendInitialize()
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);

    /*-----------------------------------------------------*\
    | Delay 2 milliseconds                                  |
@@ -217,7 +216,7 @@ void AlienwareAW510KController::SendDirectOn
    std::vector<SelectedKeys>     &frame_data
    )
 {
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);

    /*-----------------------------------------------*\
    | To Guarantee the data are always %4 =0 append   |
@@ -297,7 +296,7 @@ void AlienwareAW510KController::SendDirectOn
 void AlienwareAW510KController::SetMode
    (
    unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
    unsigned char   direction,
    unsigned char   colorMode,
    unsigned char   red,
@@ -319,7 +318,7 @@ void AlienwareAW510KController::UpdateSingleLED
 {
    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);

-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -349,7 +348,7 @@ void AlienwareAW510KController::UpdateSingleLED
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);

    /*-----------------------------------------------------*\
    | Delay 20 milliseconds                                 |
@@ -361,7 +360,7 @@ void AlienwareAW510KController::SendMode
    (
    unsigned char   /*zone*/,
    unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
    unsigned char   direction,
    unsigned char   colorMode,
    unsigned char   red,
@@ -369,7 +368,7 @@ void AlienwareAW510KController::SendMode
    unsigned char   blue
    )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -395,13 +394,13 @@ void AlienwareAW510KController::SendMode
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }

 void AlienwareAW510KController::SetMorphMode
    (
    unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
    unsigned char   red1,
    unsigned char   green1,
    unsigned char   blue1,
@@ -410,7 +409,7 @@ void AlienwareAW510KController::SetMorphMode
    unsigned char   blue2
    )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];

    /*-----------------------------------------------------*\
    | Zero out buffer                                       |
@@ -439,5 +438,5 @@ void AlienwareAW510KController::SetMorphMode
    /*-----------------------------------------------------*\
    | Send packet                                           |
    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.h                               |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.h              |
+|                                           |
+|  Definitions and types for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/

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

 #include <string>
 #include <hidapi/hidapi.h>
-#include "RGBController.h"
+
+#pragma once

 enum
 {
@@ -111,7 +110,7 @@ public:
    void        SetMode
                    (
                    unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                    unsigned char   direction,
                    unsigned char   colorMode,
                    unsigned char   red,
@@ -122,7 +121,7 @@ public:
    void        SetMorphMode
                    (
                    unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                    unsigned char   red1,
                    unsigned char   green1,
                    unsigned char   blue1,
@@ -147,7 +146,7 @@ private:
                    (
                    unsigned char   zone,
                    unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                    unsigned char   direction,
                    unsigned char   colorMode,
                    unsigned char   red,
@@ -1,36 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.h                           |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW510KController.h"
-
-class RGBController_AlienwareAW510K : public RGBController
-{
-public:
-    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
-    ~RGBController_AlienwareAW510K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW510KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};
@@ -1,30 +1,18 @@
-/*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
-|                                                           |
-|   Detector for Alienware Keyboard                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
-#include "AlienwareAW410KController.h"
 #include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
-#include "RGBController_AlienwareAW410K.h"
+#include <hidapi/hidapi.h>

 /*-----------------------------------------------------*\
 | Alienware vendor ID                                   |
 \*-----------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
+#define ALIENWARE_VID           0x04F2

 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
+#define ALIENWARE_AW510K_PID    0x1830

 /******************************************************************************************\
 *                                                                                          *
@@ -44,20 +32,7 @@ void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string&
        rgb_controller->name = name;
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
-}
-
-void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path);
-        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}/* DetectAlienwareKeyboardControllers() */
+}   /* DetectAlienwareKeyboardControllers() */


 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
-REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);
@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.cpp                         |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.cpp        |
+|                                           |
+|  Generic RGB Interface for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/

-#include <iterator>
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AlienwareAW510K.h"
+#include <iterator>

 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
@@ -47,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    },
@@ -1,25 +1,27 @@
 /*-----------------------------------------*\
-|  RGBController_RoccatSenseAimo.h          |
+|  RGBController_AlienwareAW510K.h          |
 |                                           |
-|  Generic RGB Interface for Roccat Sense   |
-|  Aimo controller                          |
+|  Generic RGB Interface for Alienware      |
+|  AW510K keyboard                          |
 |                                           |
-|  Mola19 08/09/2023                        |
+|  Mohamad Sallal - msallal      05/22/2021 |
 \*-----------------------------------------*/

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

-class RGBController_RoccatSenseAimo : public RGBController
+#include "RGBController.h"
+#include "AlienwareAW510KController.h"
+
+class RGBController_AlienwareAW510K : public RGBController
 {
 public:
-    RGBController_RoccatSenseAimo(RoccatSenseAimoController* controller_ptr);
-    ~RGBController_RoccatSenseAimo();
+    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
+    ~RGBController_AlienwareAW510K();

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

+    void        ResizeZone(int zone, int new_size);
+    
    void        DeviceUpdateLEDs();
    void        UpdateZoneLEDs(int zone);
    void        UpdateSingleLED(int led);
@@ -27,5 +29,6 @@ public:
    void        DeviceUpdateMode();

 private:
-    RoccatSenseAimoController* controller;
+    AlienwareAW510KController*  controller;
+    std::vector<RGBColor>       current_colors;
 };
@@ -1,35 +1,32 @@
-/*---------------------------------------------------------*\
-| AnnePro2Controller.cpp                                    |
-|                                                           |
-|   Driver for Obins Lab AnnePro2 keyboard                  |
-|                                                           |
-|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AnnePro2Controller.cpp                   |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/

 #include "AnnePro2Controller.h"

 using namespace std::chrono_literals;

-AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path)
+AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path) 
 {
    dev         = dev_handle;
    location    = path;
 }

-AnnePro2Controller::~AnnePro2Controller()
+AnnePro2Controller::~AnnePro2Controller() 
 {
    hid_close(dev);
 }

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

-std::string AnnePro2Controller::GetSerialString()
+std::string AnnePro2Controller::GetSerialString() 
 {
    wchar_t serial_string[128];
    int ret = hid_get_serial_number_string(dev, serial_string, 128);
@@ -45,7 +42,7 @@ std::string AnnePro2Controller::GetSerialString()
    return(return_string);
 }

-void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data)
+void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data) 
 {
    /*-------------------------------------------------------------*\
    | Reverse engineered by https://github.com/manualmanul/Annemone |
@@ -77,7 +74,7 @@ void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * f
    {
        const unsigned char e = (messages_to_send_amount << 4) + p;
        const unsigned char a = ((messages_to_send_amount - 1) == p) ? val_2 + real_command_info_length : max_message_length + real_command_info_length;
-
+        
        /*---------------------------------------------------------*\
        | Service data                                              |
        \*---------------------------------------------------------*/
@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| AnnePro2Controller.h                                      |
-|                                                           |
-|   Driver for Obins Lab AnnePro2 keyboard                  |
-|                                                           |
-|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AnnePro2Controller.h                     |
+|                                           |
+|  Driver for Obins Lab AnnePro2 keyboard   |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/

 #pragma once
+#include "RGBController.h"

 #include <string>
 #include <vector>
 #include <hidapi/hidapi.h>
-#include "RGBController.h"
+
+#pragma once

 class AnnePro2Controller
 {
@@ -34,4 +33,4 @@ public:
 private:
    hid_device*                 dev;
    std::string                 location;
-};
+};
@@ -1,34 +1,14 @@
-/*---------------------------------------------------------*\
-| AnnePro2ControllerDetect.cpp                              |
-|                                                           |
-|   Detector for Obins Lab AnnePro2 keyboard                |
-|                                                           |
-|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AnnePro2Controller.h"
 #include "RGBController.h"
 #include "RGBController_AnnePro2.h"
 #include <hidapi/hidapi.h>

-/*---------------------------------------------------------*\
-| Anne Pro 2 vendor IDs                                     |
-\*---------------------------------------------------------*/
-#define ANNE_PRO_2_VID_1                            0x04D9
-#define ANNE_PRO_2_VID_2                            0x3311
-
-/*---------------------------------------------------------*\
-| Anne Pro 2 product IDs                                    |
-\*---------------------------------------------------------*/
-#define ANNE_PRO_2_PID_1                            0x8008
-#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
+#define ANNE_PRO_2_VID 0x04D9
+#define ANNE_PRO_2_PID_1 0x8008
+#define ANNE_PRO_2_PID_2 0x8009
+#define ANNE_PRO_2_PID_3 0xA292
+#define ANNE_PRO_2_PID_4 0xA293

 /******************************************************************************************\
 *                                                                                          *
@@ -50,8 +30,7 @@ void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
    }
 }

-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_2, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_3, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_4, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_2, ANNE_PRO_2_PID_5, 1);
+REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
+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);
@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AnnePro2.cpp                                |
-|                                                           |
-|   RGBController for Obins Lab AnnePro2 keyboard           |
-|                                                           |
-|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.cpp               |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/

 #include "RGBControllerKeyNames.h"
 #include "RGBController_AnnePro2.h"
@@ -42,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       },
@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AnnePro2.h                                  |
-|                                                           |
-|   RGBController for Obins Lab AnnePro2 keyboard           |
-|                                                           |
-|   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AnnePro2.h                 |
+|                                           |
+|  Generic RGB Interface for Obins Lab      |
+|  AnnePro2 keyboard                        |
+|                                           |
+|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
+\*-----------------------------------------*/

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

@@ -1,158 +0,0 @@
-/*---------------------------------------------------------*\
-| ArcticController.cpp                                      |
-|                                                           |
-|   Driver for Arctic devices                               |
-|                                                           |
-|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "ArcticController.h"
-
-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,32 +0,0 @@
-/*---------------------------------------------------------*\
-| ArcticController.h                                        |
-|                                                           |
-|   Driver for Arctic devices                               |
-|                                                           |
-|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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,51 +0,0 @@
-/*---------------------------------------------------------*\
-| ArcticControllerDetect.cpp                                |
-|                                                           |
-|   Detector for Arctic devices                             |
-|                                                           |
-|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <vector>
-#include "Detector.h"
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "RGBController_Arctic.h"
-#include "find_usb_serial_port.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,134 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_Arctic.cpp                                  |
-|                                                           |
-|   RGBController for Arctic devices                        |
-|                                                           |
-|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <math.h>
-#include "RGBController_Arctic.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,44 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_Arctic.h                                    |
-|                                                           |
-|   RGBController for Arctic devices                        |
-|                                                           |
-|   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <chrono>
-#include <thread>
-#include "ArcticController.h"
-#include "RGBController.h"
-#include "serial_port.h"
-
-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;
-};
-
@@ -1,16 +1,14 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreController.cpp                                |
-|                                                           |
-|   Driver for ASUS ROG Aura Core                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraCoreController.cpp               | 
+|                                           |
+|  Driver for ASUS ROG Aura Core RGB        |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/13/2020   |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AsusAuraCoreController.h"
+#include <cstring>

 #define AURA_CORE_MAX_MESSAGE_SIZE  64

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreController.h                                  |
-|                                                           |
-|   Driver for ASUS ROG Aura Core                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraCoreController.h                 |
+|                                           |
+|  Definitions and types for ASUS ROG Aura  |
+|  Core RGB lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/13/2020   |
+\*-----------------------------------------*/

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

 #include <string>
 #include <hidapi/hidapi.h>
-#include "RGBController.h"
+
+#pragma once

 enum AuraCoreDeviceType
 {
@@ -120,4 +119,5 @@ private:
    void    Handshake();
    void    SendIdString();
    void    SendQuery();
+
 };
@@ -1,37 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraCore.h                              |
-|                                                           |
-|   RGBController for ASUS ROG Aura Core                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusAuraCoreController.h"
-
-class RGBController_AuraCore : public RGBController
-{
-public:
-    RGBController_AuraCore(AuraCoreController* controller_ptr);
-    ~RGBController_AuraCore();
-
-    void        SetupKeyboard();
-    void        SetupGA15DH();
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AuraCoreController* controller;
-};
@@ -1,15 +1,3 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreControllerDetect.cpp                          |
-|                                                           |
-|   Detector for ASUS ROG Aura Core                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|   Chris M (Dr_No)                             28 Jul 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AsusAuraCoreController.h"
 #include "RGBController.h"
@@ -67,4 +55,3 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreContro
 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);
@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreLaptopController.cpp                          |
-|                                                           |
-|   Driver for ASUS ROG Aura Core Laptop                    |
-|                                                           |
-|   Chris M (Dr_No)                             28 Jul 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  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  +
@@ -170,14 +167,14 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)

    for(size_t i = 0; i < key_set; i+=leds_per_packet)
    {
-        uint8_t leds_remaining  = key_set - (uint8_t)i;
+        uint8_t leds_remaining  = key_set - i;

        if(leds_remaining < leds_per_packet)
        {
            buffer[07]          = leds_remaining;
        }

-        buffer[06]              = (uint8_t)i;
+        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);
@@ -1,15 +1,11 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreLaptopController.h                            |
-|                                                           |
-|   Driver for ASUS ROG Aura Core Laptop                    |
-|                                                           |
-|   Chris M (Dr_No)                             28 Jul 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*---------------------------------------------------------------------*\
+|  AsusAuraCoreLaptopController.h                                       |
+|                                                                       |
+|  Driver for AsusAuraCoreLaptop USB Controller                         |
+|                                                                       |
+|  Chris M (Dr_No)          28 Jul 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/

 #include <string>
 #include <vector>
@@ -17,8 +13,11 @@
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
+#include "SettingsManager.h"
 #include "RGBControllerKeyNames.h"

+#pragma once
+
 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
 #define ASUSAURACORELAPTOP_TIMEOUT              250
@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraCore.cpp                            |
-|                                                           |
-|   RGBController for ASUS ROG Aura Core                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraCore.cpp           |
+|                                           |
+|  Generic RGB Interface for ROG Aura Core  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/17/2020   |
+\*-----------------------------------------*/

 #include "RGBController_AsusAuraCore.h"

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraCore.h             |
+|                                           |
+|  Generic RGB Interface for ROG Aura Core  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/17/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AsusAuraCoreController.h"
+
+class RGBController_AuraCore : public RGBController
+{
+public:
+    RGBController_AuraCore(AuraCoreController* controller_ptr);
+    ~RGBController_AuraCore();
+
+    void        SetupKeyboard();
+    void        SetupGA15DH();
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AuraCoreController* controller;
+};
--- a/Show More
+++ b/Show More