Remove led::value

* Add JSON string configuration field to RGBController to store device-specific configurations
    * This JSON string holds both configuration and schema
    * Add settings schema tracking to SettingsManager
    * Implement dynamic settings widget that generates a settings UI based on a JSON schema
    * Implement SettingsManager callback for notifying of settings changes and settings schema updates
    * Always enable Entire Device zone option and use it to enable Edit Device
    * Rename SaveSizes to SaveConfiguration in ProfileManager and Sizes.json to Configuration.json
    * Add zone flag for indicating that a zone's geometry may change, informing profile manager to ignore this check
    * Remove Theme setting and Theme Manager, as this didn't work on most setups anyways and Qt6 has proper Windows dark theming

.gitlab-ci.yml

@@ -14,9 +14,9 @@
 #   run only if manually started to save CI minutes if      #
 #   GitLab hosted runners                                   #
 # * For commits to the CalcProgrammer1/OpenRGB repository,  #
-#   automatically run all jobs on the default branch or     #
-#   tag builds, otherwise run them if the source is part    #
-#   of a merge request                                      #
+#   automatically run all jobs on the default branch,       #
+#   otherwise run them if the source is part of a merge     #
+#   request                                                 #
 #-----------------------------------------------------------#
 .downstream_rules:
   rules:
@@ -26,7 +26,7 @@
 
 .upstream_rules:
   rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG || $CI_PIPELINE_SOURCE == "merge_request_event")'
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_PIPELINE_SOURCE == "merge_request_event")'
     when: on_success
   - !reference [.downstream_rules, rules]
 
@@ -51,7 +51,7 @@ before_script:
 # Supported Devices Build Target                            #
 #-----------------------------------------------------------#
 "Supported Devices":
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
   tags:
   - linux
   - amd64
@@ -71,10 +71,10 @@ before_script:
     - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# OpenRGB Common AppImage Build Steps                       #
+# OpenRGB Common Appimage Build Steps                       #
 #-----------------------------------------------------------#
 .hidden_appimage_script: &appimage_script_steps
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:trixie-${TGT_ARCH}
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
   tags:
   - linux
   - ${TGT_ARCH}
@@ -87,6 +87,8 @@ before_script:
     name: "${CI_PROJECT_NAME}_Linux_${TGT_NAME}_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-${TGT_PATH}.AppImage
+    - 60-openrgb.rules
+    - README.md
     expire_in: 30 days
 
   rules:
@@ -288,13 +290,13 @@ before_script:
   <<: *debian_script_steps
 
 #-----------------------------------------------------------#
-# Linux (.rpm) Fedora 44 amd64 Build Target                 #
+# Linux (.rpm, F43) 64-bit Build Target                     #
 #-----------------------------------------------------------#
-"Linux amd64 .rpm (Fedora 44)":
-  image: fedora:44
+"Linux 64 F43 rpm":
+  image: fedora:43
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt6-qtbase-devel git wget -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git wget -y
   - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
   - unzip hidapi-hotplug.zip
   - dnf install ./*.rpm -y
@@ -310,7 +312,7 @@ before_script:
   - cd ${CI_PROJECT_DIR}
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_amd64_rpm_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.rpm
     expire_in: 30 days
@@ -318,44 +320,6 @@ before_script:
   rules:
     - !reference [.upstream_rules, rules]
 
-#-----------------------------------------------------------#
-# OpenRGB Common Flatpak Build Steps                        #
-#-----------------------------------------------------------#
-.hidden_flatpak_script: &flatpak_script_steps
-  image: ghcr.io/flathub-infra/flatpak-github-actions:kde-6.10
-  stage: build
-  tags:
-  - linux
-  - ${TGT_ARCH}
-  script:
-  - flatpak-builder --user --disable-rofiles-fuse --repo=build/repo build/flatpak-build flatpak/org.openrgb.OpenRGB.yaml
-  - flatpak build-bundle build/repo org.openrgb.OpenRGB.flatpak org.openrgb.OpenRGB
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_Flatpak_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - org.openrgb.OpenRGB.flatpak
-    expire_in: 30 days
-
-  rules:
-    - !reference [.upstream_rules, rules]
-
-#-----------------------------------------------------------#
-# Linux Flatpak amd64 Build Target                          #
-#-----------------------------------------------------------#
-"Linux amd64 Flatpak":
-  variables:
-    TGT_ARCH: "amd64"
-  <<: *flatpak_script_steps
-
-#-----------------------------------------------------------#
-# Linux Flatpak arm64 Build Target                          #
-#-----------------------------------------------------------#
-"Linux arm64 Flatpak":
-  variables:
-    TGT_ARCH: "arm64"
-  <<: *flatpak_script_steps
-
 #-----------------------------------------------------------#
 # Debian i386 Bookworm test                                 #
 #-----------------------------------------------------------#
@@ -423,10 +387,10 @@ before_script:
   - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# Fedora amd64 44 test                                      #
+# Fedora 64 v43 test                                        #
 #-----------------------------------------------------------#
-"Fedora 64 44":
-  image: fedora:44
+"Fedora 64 v43":
+  image: fedora:43
   stage: test
   script:
   - dnf install unzip wget -y
@@ -437,9 +401,9 @@ before_script:
   - openrgb --version
   - dnf5 -y remove openrgb
   dependencies:
-  - "Linux amd64 .rpm (Fedora 44)"
+  - "Linux 64 F43 rpm"
   needs:
-  - "Linux amd64 .rpm (Fedora 44)"
+  - "Linux 64 F43 rpm"
   rules:
   - !reference [.upstream_rules, rules]
 

AutoStart/AutoStart-Linux.cpp

@@ -119,21 +119,6 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | When running from an AppImage, the AppImage runtime   |
-    | sets the APPIMAGE environment variable to the path of |
-    | the AppImage file itself.  /proc/self/exe would       |
-    | instead point at the extracted binary inside the      |
-    | temporary squashfs mount, which disappears once the   |
-    | AppImage is closed, so prefer APPIMAGE when it is set |
-    \*-----------------------------------------------------*/
-    const char* appimage_path = getenv("APPIMAGE");
-
-    if(appimage_path != NULL)
-    {
-        return(std::string(appimage_path));
-    }
-
     /*-----------------------------------------------------*\
     | Create the OpenRGB executable path                    |
     \*-----------------------------------------------------*/
@@ -149,64 +134,6 @@ std::string AutoStart::GetExePath()
 | Private Methods                                           |
 \*---------------------------------------------------------*/
 
-/*---------------------------------------------------------*\
-| Escape a single argument for use in a .desktop Exec=      |
-| field, per the Desktop Entry Specification.               |
-|                                                           |
-| Reserved characters must be escaped by wrapping the whole |
-| argument in double quotes and backslash-escaping the      |
-| quote/backquote/backslash/dollar characters, and any      |
-| literal '%' must be doubled to '%%'.                      |
-\*---------------------------------------------------------*/
-static std::string DesktopExecEscape(const std::string& arg)
-{
-    static const std::string reserved = " \t\n\"'`\\><~|&;$*?#()%";
-
-    bool needs_quotes = false;
-    for(char c : arg)
-    {
-        if(reserved.find(c) != std::string::npos)
-        {
-            needs_quotes = true;
-            break;
-        }
-    }
-
-    std::string escaped;
-
-    if(needs_quotes)
-    {
-        escaped += '"';
-    }
-
-    for(char c : arg)
-    {
-        switch(c)
-        {
-            case '"':
-            case '`':
-            case '\\':
-            case '$':
-                escaped += '\\';
-                escaped += c;
-                break;
-            case '%':
-                escaped += "%%";
-                break;
-            default:
-                escaped += c;
-                break;
-        }
-    }
-
-    if(needs_quotes)
-    {
-        escaped += '"';
-    }
-
-    return(escaped);
-}
-
 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
     /*-----------------------------------------------------*\
@@ -227,17 +154,11 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     /*-----------------------------------------------------*\
     | Add the executable path and arguments                 |
     \*-----------------------------------------------------*/
-    fileContents << "Exec="              << DesktopExecEscape(autostart_info.path);
+    fileContents << "Exec="              << autostart_info.path;
 
     if (autostart_info.args != "")
     {
-        std::istringstream arg_parser(autostart_info.args);
-        std::string arg;
-
-        while(arg_parser >> arg)
-        {
-            fileContents << " " << DesktopExecEscape(arg);
-        }
+        fileContents << " " << autostart_info.args;
     }
 
     fileContents << std::endl;

AutoStart/AutoStart-MacOS.cpp

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

AutoStart/AutoStart-Windows.cpp

@@ -12,7 +12,6 @@
 #include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
-#include "StringUtils.h"
 #include "filesystem.h"
 #include "windows.h"
 
@@ -72,11 +71,11 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
         HRESULT         result;
         IShellLinkW*    shellLink                   = NULL;
 
-        std::wstring    exepathw                    = StringUtils::string_to_wstring(autostart_info.path);
-        std::wstring    argumentsw                  = StringUtils::string_to_wstring(autostart_info.args);
-        std::wstring    startupfilepathw            = StringUtils::string_to_wstring(autostart_file);
-        std::wstring    descriptionw                = StringUtils::string_to_wstring(autostart_info.desc);
-        std::wstring    iconw                       = StringUtils::string_to_wstring(autostart_info.path);
+        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
+        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
+        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
+        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
+        std::wstring    iconw                       = utf8_decode(autostart_info.path);
 
         result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
 
@@ -151,16 +150,11 @@ std::string AutoStart::GetExePath()
     /*-----------------------------------------------------*\
     | Create the OpenRGB executable path                    |
     \*-----------------------------------------------------*/
-    wchar_t exepath[MAX_PATH] = L"";
+    char exepath[MAX_PATH] = "";
 
-    DWORD count = GetModuleFileNameW(NULL, exepath, MAX_PATH);
+    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
 
-    if(count == 0)
-    {
-        return(std::string());
-    }
-
-    return(StringUtils::wstring_to_string(std::wstring(exepath, count)));
+    return(std::string(exepath, (count > 0) ? count : 0));
 }
 
 /*---------------------------------------------------------*\
@@ -170,39 +164,43 @@ std::string AutoStart::GetExePath()
 
 void AutoStart::InitAutoStart(std::string name)
 {
-    wchar_t startMenuPath[MAX_PATH];
+    char startMenuPath[MAX_PATH];
 
     autostart_name = name;
 
     /*-----------------------------------------------------*\
     | Get startup applications path                         |
     \*-----------------------------------------------------*/
-    HRESULT result = SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
+    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
 
     if(SUCCEEDED(result))
     {
-        std::string autostart_dir = StringUtils::wstring_to_string(startMenuPath);
-        autostart_dir += "\\Startup\\";
+        autostart_file = std::string(startMenuPath);
 
-        /*-------------------------------------------------*\
-        | Create the directory if it doesn't exist          |
-        \*-------------------------------------------------*/
-        std::error_code ec;
-
-        bool success = true;
-
-        if(!filesystem::exists(autostart_dir))
-        {
-            success = filesystem::create_directories(autostart_dir, ec);
-        }
-
-        if(success)
-        {
-            autostart_file = autostart_dir + autostart_name + ".lnk";
-        }
+        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
     }
     else
     {
         autostart_file.clear();
     }
 }
+
+/*---------------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String           |
+| (from wmi.cpp)                                            |
+\*---------------------------------------------------------*/
+std::wstring AutoStart::utf8_decode(const std::string& str)
+{
+    if(str.empty())
+    {
+        return std::wstring();
+    }
+
+    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
+
+    std::wstring wstrTo(size_needed, 0);
+
+    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
+
+    return(wstrTo);
+}

AutoStart/AutoStart-Windows.h

@@ -24,4 +24,5 @@ public:
 
 private:
     void            InitAutoStart(std::string name);
+    std::wstring    utf8_decode(const std::string& str);
 };

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------*\
+| A4TechDetector.cpp                                        |
+|                                                           |
+|   Detector for A4Tech Devices                             |
+|                                                           |
+|   Chris M (Dr_No)                             30 Jun 2022 |
+|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <hidapi.h>
+#include "BloodyB820RController.h"
+#include "BloodyMouseController.h"
+#include "DetectionManager.h"
+#include "RGBController_BloodyB820R.h"
+#include "RGBController_BloodyMouse.h"
+
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
+#define A4_TECH_VID                                 0x09DA
+
+DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
+        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
+        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);

Controllers/A4TechController/BloodyB820RController/BloodyB820RControllerDetect.cpp

@@ -1,40 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RControllerDetect.cpp                           |
-|                                                           |
-|   Detector for Bloody B820R Devices                       |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "BloodyB820RController.h"
-#include "DetectionManager.h"
-#include "RGBController_BloodyB820R.h"
-
-/*---------------------------------------------------------*\
-| A4 Tech USB vendor ID                                     |
-\*---------------------------------------------------------*/
-#define A4_TECH_VID                                 0x09DA
-
-DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
-        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_HID_DETECTOR_IPU("Bloody B820R", DetectBloodyB820R, A4_TECH_VID, BLOODY_B820R_PID, 2, 0xFF52, 0x0210);

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -205,7 +205,6 @@ void RGBController_BloodyB820R::SetupZones()
     {
         led new_led;
         new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
         leds.push_back(new_led);
     }
 

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -67,13 +67,13 @@ 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, std::vector<uint8_t> offsets)
 {
     uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
 
     for(uint8_t i = 0; i < colors.size(); i++)
     {
-        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
+        uint8_t offset                              = 3 * (offsets[i]) + BLOODYMOUSE_DATA_BYTE;
 
         buffer[offset]                              = RGBGetRValue(colors[i]);
         buffer[offset + 1]                          = RGBGetGValue(colors[i]);

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -58,7 +58,7 @@ public:
     std::string     GetLocation();
     std::string     GetName();
 
-    void            SetLedsDirect(std::vector<RGBColor> colors);
+    void            SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets);
 
 private:
     uint16_t        pid;

Controllers/A4TechController/BloodyMouseController/BloodyMouseControllerDetect.cpp

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

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -142,7 +142,7 @@ void RGBController_BloodyMouse::SetupZones()
         {
             led new_led;
 
-            new_led.value       = mz.zone_leds[lp_idx];
+            offsets.push_back(mz.zone_leds[lp_idx]);
 
             if(bool_single)
             {
@@ -163,14 +163,7 @@ void RGBController_BloodyMouse::SetupZones()
 
 void RGBController_BloodyMouse::DeviceUpdateLEDs()
 {
-    std::vector<RGBColor> colour;
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor c = colors[i] | (leds[i].value << 24);
-        colour.push_back(c);
-    }
-
-    controller->SetLedsDirect(colour);
+    controller->SetLedsDirect(colors, offsets);
 }
 
 void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -39,4 +39,5 @@ public:
 
 private:
     BloodyMouseController*  controller;
+    std::vector<uint8_t>    offsets;
 };

Controllers/AMBXController/AMBXController.cpp

@@ -186,7 +186,7 @@ void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
     std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }
 
-void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
+void AMBXController::SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count)
 {
     for(unsigned int i = 0; i < count; i++)
     {

Controllers/AMBXController/AMBXController.h

@@ -44,7 +44,7 @@ public:
 
     bool            IsInitialized();
     void            SetLEDColor(unsigned int led, RGBColor color);
-    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
+    void            SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count);
 
 private:
     libusb_context*          usb_context;

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -9,6 +9,15 @@
 
 #include "RGBController_AMBX.h"
 
+static const unsigned int led_values[] =
+{
+    AMBX_LIGHT_LEFT,
+    AMBX_LIGHT_RIGHT,
+    AMBX_LIGHT_WALL_LEFT,
+    AMBX_LIGHT_WALL_CENTER,
+    AMBX_LIGHT_WALL_RIGHT
+};
+
 /**------------------------------------------------------------------*\
     @name Philips amBX
     @category Accessory
@@ -71,27 +80,22 @@ void RGBController_AMBX::SetupZones()
     // Set up LEDs
     led left_light;
     left_light.name  = "Left";
-    left_light.value = AMBX_LIGHT_LEFT;
     leds.push_back(left_light);
 
     led right_light;
     right_light.name  = "Right";
-    right_light.value = AMBX_LIGHT_RIGHT;
     leds.push_back(right_light);
 
     led wall_left;
     wall_left.name  = "Wall Left";
-    wall_left.value = AMBX_LIGHT_WALL_LEFT;
     leds.push_back(wall_left);
 
     led wall_center;
     wall_center.name  = "Wall Center";
-    wall_center.value = AMBX_LIGHT_WALL_CENTER;
     leds.push_back(wall_center);
 
     led wall_right;
     wall_right.name  = "Wall Right";
-    wall_right.value = AMBX_LIGHT_WALL_RIGHT;
     leds.push_back(wall_right);
 
     SetupColors();
@@ -104,16 +108,7 @@ void RGBController_AMBX::DeviceUpdateLEDs()
         return;
     }
 
-    unsigned int led_values[5];
-    RGBColor led_colors[5];
-
-    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        led_values[led_idx] = leds[led_idx].value;
-        led_colors[led_idx] = colors[led_idx];
-    }
-
-    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
+    controller->SetLEDColors(led_values, colors.data(), static_cast<unsigned int>(colors.size()));
 }
 
 void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
@@ -138,17 +133,17 @@ void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
         start_idx += zones[z_idx].leds_count;
     }
 
-    unsigned int led_values[5];
-    RGBColor led_colors[5];
+    unsigned int tmp_values[5];
+    RGBColor     tmp_colors[5];
 
     for(unsigned int led_idx = 0; led_idx < zone_size; led_idx++)
     {
         unsigned int current_idx = start_idx + led_idx;
-        led_values[led_idx] = leds[current_idx].value;
-        led_colors[led_idx] = colors[current_idx];
+        tmp_values[led_idx] = led_values[current_idx];
+        tmp_colors[led_idx] = colors[current_idx];
     }
 
-    controller->SetLEDColors(led_values, led_colors, zone_size);
+    controller->SetLEDColors(tmp_values, tmp_colors, zone_size);
 }
 
 void RGBController_AMBX::DeviceUpdateSingleLED(int led)
@@ -158,7 +153,7 @@ void RGBController_AMBX::DeviceUpdateSingleLED(int led)
         return;
     }
 
-    unsigned int led_value = leds[led].value;
+    unsigned int led_value = led_values[led];
     RGBColor color = colors[led];
     controller->SetLEDColor(led_value, color);
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -11,6 +11,33 @@
 
 #include "RGBController_AMDWraithPrism.h"
 
+/*---------------------------------------------------------*\
+| LED maps                                                  |
+\*---------------------------------------------------------*/
+const unsigned char led_values[] =
+{
+    // Logo
+    0x00,
+    // Fan
+    0x01,
+    // Ring
+    0x08,
+    0x07,
+    0x06,
+    0x05,
+    0x04,
+    0x03,
+    0x02,
+    0x10,
+    0x0F,
+    0x0E,
+    0x0D,
+    0x0C,
+    0x0B,
+    0x0A,
+    0x09
+};
+
 /**------------------------------------------------------------------*\
     @name AMD Wraith Prism
     @category Cooler
@@ -139,14 +166,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[15] =  { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10,
-                                          0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
-
     /*-----------------------------------------------------*\
     | Set up zones                                          |
     \*-----------------------------------------------------*/
@@ -181,7 +200,6 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led logo_led;
         logo_led.name       = "Logo LED";
-        logo_led.value      = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
@@ -189,7 +207,6 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led fan_led;
         fan_led.name        = "Fan LED";
-        fan_led.value       = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
@@ -197,7 +214,6 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led ring_led;
         ring_led.name       = "Ring LED";
-        ring_led.value      = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 
@@ -218,7 +234,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
         {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
+            led_ids[leds_count]     = led_values[led_idx];
             color_buf[leds_count]   = colors[led_idx];
 
             leds_count++;
@@ -231,7 +247,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
         {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
+            led_ids[leds_count]     = led_values[led_idx + 2];
             color_buf[leds_count]   = colors[led_idx + 2];
 
             leds_count++;

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -286,7 +286,7 @@ void RGBController_AOCKeyboard::SetupZones()
         led new_led;
 
         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
         leds.push_back(new_led);
     }
 
@@ -303,7 +303,7 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            color_buf[leds[led_idx].value] = colors[led_idx];
+            color_buf[led_values[led_idx]] = colors[led_idx];
         }
 
         controller->SetCustom(&color_buf[0]);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -29,5 +29,6 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    AOCKeyboardController*  controller;
+    AOCKeyboardController*      controller;
+    std::vector<unsigned int>   led_values;
 };

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -269,9 +269,9 @@ void RGBController_PolychromeUSB::SetupZones()
             new_led.name = zones[channel_idx].name;
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
+            led_values.push_back(channel_idx);
         }
     }
 
@@ -296,7 +296,7 @@ void RGBController_PolychromeUSB::SetupZones()
      \*---------------------------------------------------------*/
      for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
      {
-         unsigned char led = (unsigned char)leds[led_idx].value;
+         unsigned char led = (unsigned char)led_values[led_idx];
 
          colors[led_idx] = zones_info[led].color;
      }
@@ -334,14 +334,9 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
     }
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        if(zones[zone_idx].leds_count == 0)
-        {
-            continue;
-        }
-
         unsigned char set_mode = zones_info[zone_idx].mode;
 
-        if(set_mode>modes.size())
+        if (set_mode>modes.size())
         {
             set_mode = active_mode;
         }
@@ -352,11 +347,6 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
 
 void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
-    if(zones[zone].leds_count == 0)
-    {
-        return;
-    }
-
     unsigned char set_mode=zones_info[zone].mode;
 
     if(set_mode > modes.size())
@@ -364,25 +354,20 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
         set_mode = active_mode;
     }
 
-    controller->WriteZone((unsigned char)zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
+    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
 {
-    unsigned int  channel  = leds[led].value;
+    unsigned int  channel  = led_values[led];
     unsigned char set_mode = zones_info[channel].mode;
 
-    if(zones[channel].leds_count == 0)
-    {
-        return;
-    }
-
     if(set_mode > modes.size())
     {
         set_mode = active_mode;
     }
 
-    controller->WriteZone((unsigned char)channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
+    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
 }
 
 unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -33,6 +33,7 @@ public:
 
 private:
     PolychromeUSBController*        controller;
+    std::vector<unsigned int>       led_values;
     std::vector<PolychromeZoneInfo> zones_info;
 
     unsigned char GetDeviceMode(unsigned char zone);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -158,6 +158,11 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     \*---------------------------------------------------------*/
     leds.push_back(*new_led);
 
+    /*---------------------------------------------------------*\
+    | Initialize led_values vector                              |
+    \*---------------------------------------------------------*/
+    led_values.push_back(0);
+
     SetupColors();
 }
 
@@ -184,9 +189,9 @@ void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
+    if(led_values[led] != 0)
     {
-        led = leds[led].value;
+        led = led_values[led];
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -30,4 +30,5 @@ public:
 
 private:
     ASRockASRRGBSMBusController* controller;
+    std::vector<unsigned int>    led_values;
 };

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.cpp

@@ -1,199 +0,0 @@
-/*---------------------------------------------------------*\
-| ASRockGPUSMBusController.cpp                              |
-|                                                           |
-|   Driver for ASRock GPU RGB controllers                   |
-|                                                           |
-|   Based on SignalRGB ASRock GPU.js plugin                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "ASRockGPUSMBusController.h"
-#include "LogManager.h"
-#include <chrono>
-#include <cstdio>
-#include <cstring>
-#include <thread>
-
-using namespace std::chrono_literals;
-
-ASRockGPUSMBusController::ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name)
-{
-    this->bus          = bus;
-    this->dev          = dev;
-    this->device_name  = name;
-    this->num_channels = 0;
-
-    memset(enabled_channels, 0, sizeof(enabled_channels));
-    memset(led_counts, 0, sizeof(led_counts));
-}
-
-ASRockGPUSMBusController::~ASRockGPUSMBusController()
-{
-}
-
-std::string ASRockGPUSMBusController::GetDeviceLocation()
-{
-    std::string return_string(bus->info.device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string ASRockGPUSMBusController::GetDeviceName()
-{
-    return(device_name);
-}
-
-bool ASRockGPUSMBusController::WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len)
-{
-    /*-----------------------------------------------------*\
-    | SignalRGB packet format                              |
-    | [command, 0, subcommand, data...]                    |
-    | Uses pure I2C rather than SMBus                      |
-    \*-----------------------------------------------------*/
-    uint8_t packet[12];
-    memset(packet, 0, sizeof(packet));
-
-    packet[0] = command;
-    packet[1] = 0x00;
-    packet[2] = subcommand;
-
-    if(data != nullptr && len > 0)
-    {
-        uint8_t copy_len = (len > 9) ? 9 : len;
-        memcpy(&packet[3], data, copy_len);
-    }
-
-    int size   = 12;
-    int result = bus->i2c_write_block(dev, size, packet);
-
-    if(result < 0)
-    {
-        LOG_DEBUG("[ASRock GPU] Write block failed: %d", result);
-        return(false);
-    }
-
-    return(true);
-}
-
-bool ASRockGPUSMBusController::ReadBlock(uint8_t* response, uint8_t len)
-{
-    memset(response, 0, len);
-    int size   = len;
-    int result = bus->i2c_read_block(dev, &size, response);
-
-    if(result < 0)
-    {
-        LOG_DEBUG("[ASRock GPU] Read block failed: %d", result);
-        return(false);
-    }
-
-    return(true);
-}
-
-bool ASRockGPUSMBusController::DetectChannels()
-{
-    /*-----------------------------------------------------*\
-    | Get enabled channels                                 |
-    | Command 0x14, subcommand 0x01                        |
-    \*-----------------------------------------------------*/
-    if(!WriteBlock(0x14, 0x01, nullptr, 0))
-    {
-        LOG_WARNING("[ASRock GPU] Failed to request enabled channels");
-        return(false);
-    }
-
-    std::this_thread::sleep_for(20ms);
-
-    uint8_t response[I2C_SMBUS_BLOCK_MAX];
-    if(!ReadBlock(response, sizeof(response)))
-    {
-        LOG_WARNING("[ASRock GPU] Failed to read enabled channels");
-        return(false);
-    }
-
-    LOG_TRACE("[ASRock GPU] Enabled channels response: %02X %02X %02X %02X %02X %02X", response[0], response[1], response[2], response[3], response[4], response[5]);
-
-    /*-----------------------------------------------------*\
-    | Response format                                      |
-    | Bytes 4-5 contain the channel bitmap                 |
-    \*-----------------------------------------------------*/
-    uint16_t channel_bits = response[4] | (response[5] << 8);
-    LOG_TRACE("[ASRock GPU] Channel bits: 0x%04X", channel_bits);
-
-    /*-----------------------------------------------------*\
-    | Get LED counts                                       |
-    | Command 0x14, subcommand 0x02                        |
-    \*-----------------------------------------------------*/
-    if(!WriteBlock(0x14, 0x02, nullptr, 0))
-    {
-        LOG_WARNING("[ASRock GPU] Failed to request LED counts");
-        return(false);
-    }
-
-    std::this_thread::sleep_for(20ms);
-
-    if(!ReadBlock(response, sizeof(response)))
-    {
-        LOG_WARNING("[ASRock GPU] Failed to read LED counts");
-        return(false);
-    }
-
-    num_channels = 0;
-    for(int i = 0; i < 16; i++)
-    {
-        if(channel_bits & (1 << i))
-        {
-            enabled_channels[num_channels] = i;
-            led_counts[num_channels]       = response[4 + i];
-
-            const char* name = "Unknown";
-            if(i == ASROCK_GPU_CHANNEL_ARGB_HEADER)
-            {
-                name = "ARGB Header";
-            }
-            else if(i == ASROCK_GPU_CHANNEL_TOP_SIDE)
-            {
-                name = "Top Side";
-            }
-            else if(i == ASROCK_GPU_CHANNEL_FAN)
-            {
-                name = "Fan";
-            }
-
-            LOG_DEBUG("[ASRock GPU] Channel %d (%s) active with %d LEDs", i, name, response[4 + i]);
-            num_channels++;
-        }
-    }
-
-    LOG_DEBUG("[ASRock GPU] Found %d active channels", num_channels);
-    return(num_channels > 0);
-}
-
-void ASRockGPUSMBusController::SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue)
-{
-    /*-----------------------------------------------------*\
-    | SignalRGB color packet                               |
-    | Command 0x10, subcommand is the channel index        |
-    \*-----------------------------------------------------*/
-    uint8_t data[8] =
-    {
-        0x01,  // Mode: direct/static
-        red,
-        green,
-        blue,
-        0x80,  // Brightness
-        0xFF,  // Effect speed
-        0x00,  // Effect direction
-        0x1A   // Unknown constant
-    };
-
-    if(!WriteBlock(0x10, channel_idx, data, sizeof(data)))
-    {
-        LOG_WARNING("[ASRock GPU] Failed to set color for channel %d", channel_idx);
-    }
-}

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusController.h

@@ -1,55 +0,0 @@
-/*---------------------------------------------------------*\
-| ASRockGPUSMBusController.h                                |
-|                                                           |
-|   Driver for ASRock GPU RGB controllers                   |
-|                                                           |
-|   Based on SignalRGB ASRock GPU.js plugin                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-
-typedef uint8_t asrock_gpu_dev_id;
-
-#define ASROCK_GPU_CONTROLLER_NAME   "ASRock GPU SMBus Controller"
-#define ASROCK_GPU_SMBUS_ADDRESS     0x36
-
-/*-----------------------------------------------------*\
-| ASRock GPU Channel Names (from SignalRGB)             |
-\*-----------------------------------------------------*/
-enum
-{
-    ASROCK_GPU_CHANNEL_ARGB_HEADER  = 3,
-    ASROCK_GPU_CHANNEL_TOP_SIDE     = 6,
-    ASROCK_GPU_CHANNEL_FAN          = 7,
-};
-
-class ASRockGPUSMBusController
-{
-public:
-    ASRockGPUSMBusController(i2c_smbus_interface* bus, asrock_gpu_dev_id dev, std::string name);
-    ~ASRockGPUSMBusController();
-
-    std::string GetDeviceLocation();
-    std::string GetDeviceName();
-
-    void        SetChannelColor(uint8_t channel_idx, uint8_t red, uint8_t green, uint8_t blue);
-    bool        DetectChannels();
-
-    uint8_t     enabled_channels[16];
-    uint8_t     led_counts[16];
-    uint8_t     num_channels;
-
-private:
-    i2c_smbus_interface* bus;
-    asrock_gpu_dev_id    dev;
-    std::string          device_name;
-
-    bool        WriteBlock(uint8_t command, uint8_t subcommand, const uint8_t* data, uint8_t len);
-    bool        ReadBlock(uint8_t* response, uint8_t len);
-};

Controllers/ASRockSMBusController/ASRockGPUSMBusController/ASRockGPUSMBusControllerDetect.cpp

@@ -1,45 +0,0 @@
-/*---------------------------------------------------------*\
-| ASRockGPUSMBusControllerDetect.cpp                        |
-|                                                           |
-|   Detector for ASRock GPU RGB controllers                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "DetectionManager.h"
-#include "ASRockGPUSMBusController.h"
-#include "LogManager.h"
-#include "RGBController_ASRockGPUSMBus.h"
-#include "i2c_amd_gpu.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-
-DetectedControllers DetectASRockGPUSMBusControllers(i2c_smbus_interface* bus, uint8_t address, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-
-    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
-    {
-        return(detected_controllers);
-    }
-
-    LOG_DEBUG("[ASRock GPU] Checking GPU I2C bus for RGB controller at 0x%02X", address);
-
-    ASRockGPUSMBusController* controller = new ASRockGPUSMBusController(bus, address, name);
-
-    if(controller->DetectChannels())
-    {
-        detected_controllers.push_back(new RGBController_ASRockGPUSMBus(controller));
-    }
-    else
-    {
-        LOG_WARNING("[ASRock GPU] No active channels found, device not registered");
-        delete controller;
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9070 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI48_DEV, ASROCK_SUB_VEN, 0x5403, ASROCK_GPU_SMBUS_ADDRESS);
-REGISTER_I2C_PCI_DETECTOR("ASRock Radeon RX 9060 XT Steel Legend", DetectASRockGPUSMBusControllers, AMD_GPU_VEN, AMD_NAVI44_DEV, ASROCK_SUB_VEN, 0x5407, ASROCK_GPU_SMBUS_ADDRESS);

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.cpp

@@ -1,138 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockGPUSMBus.cpp                          |
-|                                                           |
-|   RGBController for ASRock GPU RGB controllers            |
-|                                                           |
-|   Based on SignalRGB ASRock GPU.js plugin                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_ASRockGPUSMBus.h"
-
-/**------------------------------------------------------------------*\
-    @name ASRock GPU SMBus
-    @category GPU
-    @type I2C
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectASRockGPUSMBusControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_ASRockGPUSMBus::RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    type        = DEVICE_TYPE_GPU;
-    description = "ASRock GPU RGB Controller";
-    location    = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_ASRockGPUSMBus::~RGBController_ASRockGPUSMBus()
-{
-    delete controller;
-}
-
-void RGBController_ASRockGPUSMBus::SetupZones()
-{
-    /*-----------------------------------------------------*\
-    | Set up zones - one zone per channel                   |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < controller->num_channels; i++)
-    {
-        uint8_t channel_idx = controller->enabled_channels[i];
-        
-        zone new_zone;
-        new_zone.type = ZONE_TYPE_SINGLE;
-        new_zone.leds_min = 1;
-        new_zone.leds_max = 1;
-        new_zone.leds_count = 1;
-        
-        /*-----------------------------------------------------*\
-        | Channel names from SignalRGB                          |
-        \*-----------------------------------------------------*/
-        if(channel_idx == ASROCK_GPU_CHANNEL_ARGB_HEADER)
-        {
-            new_zone.name = "ARGB Header";
-        }
-        else if(channel_idx == ASROCK_GPU_CHANNEL_TOP_SIDE)
-        {
-            new_zone.name = "Top Side";
-        }
-        else if(channel_idx == ASROCK_GPU_CHANNEL_FAN)
-        {
-            new_zone.name = "Fan";
-        }
-        else
-        {
-            new_zone.name = "Channel " + std::to_string(channel_idx);
-        }
-        
-        zones.push_back(new_zone);
-        
-        /*-----------------------------------------------------*\
-        | Set up LED for this zone                              |
-        \*-----------------------------------------------------*/
-        led new_led;
-        new_led.name = new_zone.name;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_ASRockGPUSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*-----------------------------------------------------*\
-    | This device does not support resizing zones           |
-    \*-----------------------------------------------------*/
-}
-
-void RGBController_ASRockGPUSMBus::DeviceUpdateLEDs()
-{
-    for(unsigned int i = 0; i < controller->num_channels; i++)
-    {
-        uint8_t channel_idx = controller->enabled_channels[i];
-        RGBColor color = colors[i];
-        
-        controller->SetChannelColor(channel_idx, 
-                                    RGBGetRValue(color),
-                                    RGBGetGValue(color),
-                                    RGBGetBValue(color));
-    }
-}
-
-void RGBController_ASRockGPUSMBus::UpdateZoneLEDs(int zone)
-{
-    uint8_t channel_idx = controller->enabled_channels[zone];
-    RGBColor color = colors[zone];
-    
-    controller->SetChannelColor(channel_idx,
-                                RGBGetRValue(color),
-                                RGBGetGValue(color),
-                                RGBGetBValue(color));
-}
-
-void RGBController_ASRockGPUSMBus::UpdateSingleLED(int led)
-{
-    UpdateZoneLEDs(led);
-}
-
-void RGBController_ASRockGPUSMBus::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/ASRockSMBusController/ASRockGPUSMBusController/RGBController_ASRockGPUSMBus.h

@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockGPUSMBus.h                            |
-|                                                           |
-|   RGBController for ASRock GPU RGB controllers            |
-|                                                           |
-|   Based on SignalRGB ASRock GPU.js plugin                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockGPUSMBusController.h"
-
-class RGBController_ASRockGPUSMBus : public RGBController
-{
-public:
-    RGBController_ASRockGPUSMBus(ASRockGPUSMBusController* controller_ptr);
-    ~RGBController_ASRockGPUSMBus();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockGPUSMBusController* controller;
-};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -285,13 +285,13 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
             led*    new_led         = new led();
 
             new_led->name           = polychrome_v1_zone_names[zone_idx];
-            new_led->value          = zone_idx;
 
             /*---------------------------------------------------------*\
             | Push new LED to LEDs vector                               |
             \*---------------------------------------------------------*/
             leds.push_back(*new_led);
             zoneIndexMap.push_back(zone_idx);
+            led_values.push_back(zone_idx);
         }
     }
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -32,7 +32,9 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
+    ASRockPolychromeV1SMBusController*  controller;
+    std::vector<unsigned int>           led_values;
+    std::vector<uint8_t>                zoneIndexMap;
+
+    uint8_t                             getModeIndex(uint8_t mode_value);
 };

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -238,6 +238,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
         }
     }
 
+    unsigned int led_count = 0;
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
@@ -255,11 +256,14 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_led->name           = polychrome_v2_zone_names[zone_idx];
 
                 new_led->name.append(" " + std::to_string(led_idx + 1));
-                new_led->value = 0;
 
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
-                    new_led->value              = 0x19;
+                    led_values.push_back(0x19);
+                }
+                else
+                {
+                    led_values.push_back(0);
                 }
 
                 /*---------------------------------------------------------*\
@@ -267,6 +271,8 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 \*---------------------------------------------------------*/
                 leds.push_back(*new_led);
 
+                led_count++;
+
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
                     break;
@@ -308,9 +314,9 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
+    if(led_values[led] != 0)
     {
-        led = leds[led].value;
+        led = led_values[led];
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -32,5 +32,6 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV2SMBusController* controller;
+    ASRockPolychromeV2SMBusController*  controller;
+    std::vector<unsigned int>           led_values;
 };

Controllers/AcerNitroHidKeyboardController/AcerHidKeyboardControllerDetect.cpp

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidKeyboard.cpp                    |
-|                                                           |
-|   Detector for Acer Nitro HID Keyboard                    |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include "DetectionManager.h"
-#include "AcerNitroHidKeyboardController.h"
-#include "RGBController_AcerNitroHidKeyboard.h"
-#include "RGBController_AcerNitroHidLed.h"
-
-/*---------------------------------------------------------*\
-| HID vendor and product IDs for ENEK EC in Acer Nitro      |
-\*---------------------------------------------------------*/
-
-#define ACER_ENEC_VID           0x0CF2
-#define ACER_ENEC_PID           0x5130
-#define ACER_ENEC_USAGE_PAGE    0xFF5A
-#define ACER_ENEC_USAGE         0x01
-
-DetectedControllers DetectAcerHIDControllers(hid_device_info* info, const std::string&)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-    if(dev)
-    {
-        /*-------------------------------------------------*\
-        | Controller is shared between keyboard and onboard |
-        | led                                               |
-        \*-------------------------------------------------*/
-        std::shared_ptr<AcerNitroHidKeyboardController> controller  = std::make_shared<AcerNitroHidKeyboardController>(dev, info->path);
-        RGBController_AcerNitroHidKeyboard* rgb_kb_controller       = new RGBController_AcerNitroHidKeyboard(controller);
-        RGBController_AcerNitroHidLed* rgb_led_controller           = new RGBController_AcerNitroHidLed(controller);
-
-        detected_controllers.push_back(rgb_kb_controller);
-        detected_controllers.push_back(rgb_led_controller);
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_HID_DETECTOR_PU("AcerNitroHidKeyboardController", DetectAcerHIDControllers, ACER_ENEC_VID, ACER_ENEC_PID, ACER_ENEC_USAGE_PAGE, ACER_ENEC_USAGE);

Controllers/AcerNitroHidKeyboardController/AcerNitroHidKeyboardController.cpp

@@ -1,80 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidKeyboard.cpp                    |
-|                                                           |
-|   Driver for Acer Nitro Keyboard                          |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "AcerNitroHidKeyboardController.h"
-
-AcerNitroHidKeyboardController::AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path)
-{
-    this->location  = path;
-    this->dev       = dev_handle;
-
-    device_name     = "Acer Nitro HID Keyboard";    
-}
-
-AcerNitroHidKeyboardController::~AcerNitroHidKeyboardController()
-{
-    if(dev)
-    {
-        hid_close(dev);
-    }
-}
-
-std::string AcerNitroHidKeyboardController::GetLocation() const
-{
-    return("HID: " + location);
-}
-
-std::string AcerNitroHidKeyboardController::GetDeviceName() const
-{
-    return(device_name);
-}
-
-void AcerNitroHidKeyboardController::SetLEDs(const std::vector<RGBColor>& colors, unsigned char brightness, unsigned char device_id)
-{
-    std::lock_guard<std::mutex> guard(device_mutex);
-
-    for(unsigned int led_idx = 0; (led_idx < colors.size()) && (led_idx < ACER_HID_NUM_ZONES); led_idx++)
-    {
-        /*-------------------------------------------------*\
-        | Convert colors to RGB format                      |
-        \*-------------------------------------------------*/
-        unsigned char r = RGBGetRValue(colors[led_idx]);
-        unsigned char g = RGBGetGValue(colors[led_idx]);        
-        unsigned char b = RGBGetBValue(colors[led_idx]);
-
-        /*-------------------------------------------------*\
-        | Send packet                                       |
-        \*-------------------------------------------------*/
-        unsigned char zone_select                   = (unsigned char)(1<<led_idx);
-        unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, ACER_HID_MODE_STATIC, brightness, 0, 1, r, g, b, zone_select, 0};
-        hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
-    }
-}
-
-void AcerNitroHidKeyboardController::SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id)
-{
-    std::lock_guard<std::mutex> guard(device_mutex);
-
-    /*-----------------------------------------------------*\
-    | Convert color to RGB format                           |
-    \*-----------------------------------------------------*/
-    unsigned char r = RGBGetRValue(color);
-    unsigned char g = RGBGetGValue(color);        
-    unsigned char b = RGBGetBValue(color);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    | Zone select = All zones                               |
-    \*-----------------------------------------------------*/
-    unsigned char zone_select                   = 0x0F;
-    unsigned char packet[ACER_HID_PACKET_SIZE]  = {0xA4, device_id, mode, brightness, speed, direction, r, g, b, zone_select, 0};
-    hid_send_feature_report(dev, packet, ACER_HID_PACKET_SIZE);
-}

Controllers/AcerNitroHidKeyboardController/AcerNitroHidKeyboardController.h

@@ -1,56 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidKeyboard.cpp                    |
-|                                                           |
-|   Driver for Acer Nitro Keyboard                          |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-enum
-{
-    ACER_HID_MODE_DIRECT    = 1,
-    ACER_HID_MODE_STATIC    = 2,
-    ACER_HID_MODE_BREATHING = 4,
-    ACER_HID_MODE_NEON      = 5,
-    ACER_HID_MODE_OPMODE    = 6,
-    ACER_HID_MODE_WAVE      = 7,
-    ACER_HID_MODE_SHIFTING  = 8,
-    ACER_HID_MODE_ZOOM      = 9,
-    ACER_HID_MODE_METEOR    = 10,
-    ACER_HID_MODE_TWINKLING = 11,
-};
-
-#define ACER_HID_NAME_BUFFER_SIZE 255
-#define ACER_HID_NUM_ZONES 4
-#define ACER_HID_PACKET_SIZE 11
-
-#include <mutex>
-#include <string>
-#include <vector>
-#include <hidapi.h>
-#include "RGBControllerInterface.h"
-
-class AcerNitroHidKeyboardController
-{
-public:
-    AcerNitroHidKeyboardController(hid_device *dev_handle, const char *path);
-    ~AcerNitroHidKeyboardController();
-
-    std::string GetDeviceName() const;
-    std::string GetSerial() const;
-    std::string GetLocation() const;
-
-    void SetLEDs(const std::vector<RGBColor> &colors, unsigned char brightness, unsigned char device_id);
-    void SetAllLEDs(const RGBColor &color, unsigned char brightness, unsigned char speed, unsigned char direction, unsigned char mode, unsigned char device_id);
-
-private:
-    hid_device *dev;
-    std::string device_name;
-    std::string location;
-    std::mutex device_mutex;
-};

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidKeyboard.cpp

@@ -1,231 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidKeyboard.cpp                    |
-|                                                           |
-|   RGBController for Acer Nitro HID Keyboard               |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AcerNitroHidKeyboard.h"
-
-/**------------------------------------------------------------------*\
-    @name Acer Nitro HID Keyboard
-    @category Laptop
-    @type HID
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAcerHIDControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AcerNitroHidKeyboard::RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller)
-{
-    this->controller            = controller;
-    device_id                   = 0x21;
-
-    name                        = "Acer Nitro HID Keyboard";
-    vendor                      = "Acer";
-    type                        = DEVICE_TYPE_LAPTOP;
-    description                 = "Acer Nitro HID Keyboard Device";
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ACER_HID_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    Direct.brightness_min       = 0;
-    Direct.brightness_max       = 100;
-    Direct.brightness           = 100;
-
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ACER_HID_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min       = 0;
-    Static.brightness_max       = 100;
-    Static.brightness           = 100;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    Static.speed                = 0;
-
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ACER_HID_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.brightness_min    = 0;
-    Breathing.brightness_max    = 100;
-    Breathing.brightness        = 100;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 1;
-    Breathing.speed_min         = 1;
-    Breathing.speed_max         = 9;
-    Breathing.speed             = 4;
-    Breathing.colors.resize(1);
-
-    modes.push_back(Breathing);
-
-    mode Neon;
-    Neon.name                   = "Neon";
-    Neon.value                  = ACER_HID_MODE_NEON;
-    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Neon.color_mode             = MODE_COLORS_NONE;
-    Neon.brightness_min         = 0;
-    Neon.brightness_max         = 100;
-    Neon.brightness             = 100;
-    Neon.speed_min              = 1;
-    Neon.speed_max              = 9;
-    Neon.speed                  = 4;
-
-    modes.push_back(Neon);
-
-    mode Wave;
-    Wave.name                   = "Wave";
-    Wave.value                  = ACER_HID_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Wave.color_mode             = MODE_COLORS_NONE;
-    Wave.brightness_min         = 0;
-    Wave.brightness_max         = 100;
-    Wave.brightness             = 100;
-    Wave.speed_min              = 1;
-    Wave.speed_max              = 9;
-    Wave.speed                  = 4;
-    Wave.direction              = 0;
-
-    modes.push_back(Wave);
-
-    mode Shifting;
-    Shifting.name               = "Shifting";
-    Shifting.value              = ACER_HID_MODE_SHIFTING;
-    Shifting.flags              = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Shifting.color_mode         = MODE_COLORS_NONE;
-    Shifting.brightness_min     = 0;
-    Shifting.brightness_max     = 100;
-    Shifting.brightness         = 100;
-    Shifting.speed_min          = 1;
-    Shifting.speed_max          = 9;
-    Shifting.speed              = 4;
-
-    modes.push_back(Shifting);
-
-    mode Zoom;
-    Zoom.name                   = "Zoom";
-    Zoom.value                  = ACER_HID_MODE_ZOOM;
-    Zoom.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Zoom.color_mode             = MODE_COLORS_NONE;
-    Zoom.brightness_min         = 0;
-    Zoom.brightness_max         = 100;
-    Zoom.brightness             = 100;
-    Zoom.speed_min              = 1;
-    Zoom.speed_max              = 9;
-    Zoom.speed                  = 4;
-
-    modes.push_back(Zoom);
-
-    mode Meteor;
-    Meteor.name                 = "Meteor";
-    Meteor.value                = ACER_HID_MODE_METEOR;
-    Meteor.flags                = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Meteor.color_mode           = MODE_COLORS_NONE;
-    Meteor.brightness_min       = 0;
-    Meteor.brightness_max       = 100;
-    Meteor.brightness           = 100;
-    Meteor.speed_min            = 1;
-    Meteor.speed_max            = 9;
-    Meteor.speed                = 4;
-
-    modes.push_back(Meteor);
-
-    mode Twinkling;
-    Twinkling.name              = "Twinkling";
-    Twinkling.value             = ACER_HID_MODE_TWINKLING;
-    Twinkling.flags             = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Twinkling.color_mode        = MODE_COLORS_NONE;
-    Twinkling.brightness_min    = 0;
-    Twinkling.brightness_max    = 100;
-    Twinkling.brightness        = 100;
-    Twinkling.colors_min        = 1;
-    Twinkling.colors_max        = 1;
-    Twinkling.speed_min         = 1;
-    Twinkling.speed_max         = 9;
-    Twinkling.speed             = 4;
-
-    modes.push_back(Twinkling);
-
-    SetupZones();
-}
-
-RGBController_AcerNitroHidKeyboard::~RGBController_AcerNitroHidKeyboard()
-{
-    Shutdown();
-}
-
-void RGBController_AcerNitroHidKeyboard::SetupZones()
-{
-    zone* new_zone          = new zone;
-
-    new_zone->name          = "Keyboard Backlight Zone";
-    new_zone->type          = ZONE_TYPE_LINEAR;
-    new_zone->leds_min      = 4;
-    new_zone->leds_max      = 4;
-    new_zone->leds_count    = 4;
-
-    zones.push_back(*new_zone);
-
-    for(std::size_t zone_idx = 0; zone_idx < ACER_HID_NUM_ZONES; zone_idx++)
-    {
-        led* new_led        = new led();
-        new_led->name       = "Keyboard Backlight Zone ";
-        new_led->name.append(std::to_string(zone_idx + 1));
-        new_led->value      = (unsigned int)leds.size();
-
-        leds.push_back(*new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AcerNitroHidKeyboard::DeviceUpdateLEDs()
-{
-    mode& current_mode = modes[active_mode];
-    if(current_mode.value == ACER_HID_MODE_DIRECT)
-    {
-        controller->SetLEDs(colors, current_mode.brightness, device_id);
-    }
-    else
-    {
-        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
-        unsigned char direction = 1;
-        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
-        {
-            direction           = 2;
-        }
-        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
-    }
-}
-
-void RGBController_AcerNitroHidKeyboard::DeviceUpdateZoneLEDs(int)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AcerNitroHidKeyboard::DeviceUpdateSingleLED(int)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AcerNitroHidKeyboard::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidKeyboard.h

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidKeyboard.cpp                    |
-|                                                           |
-|   RGBController for Acer Nitro HID Keyboard               |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AcerNitroHidKeyboardController.h"
-
-class RGBController_AcerNitroHidKeyboard : public RGBController
-{
-public:
-    RGBController_AcerNitroHidKeyboard(std::shared_ptr<AcerNitroHidKeyboardController> controller);
-    ~RGBController_AcerNitroHidKeyboard();
-
-    void SetupZones();
-
-    void DeviceUpdateLEDs();
-    void DeviceUpdateZoneLEDs(int zone);
-    void DeviceUpdateSingleLED(int led);
-    void DeviceUpdateMode();
-
-private:
-    std::shared_ptr<AcerNitroHidKeyboardController> controller;
-    unsigned int device_id;
-};

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidLed.cpp

@@ -1,152 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidLed.cpp                         |
-|                                                           |
-|   RGBController for Acer Nitro HID LED                    |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AcerNitroHidLed.h"
-
-/**------------------------------------------------------------------*\
-    @name Acer Nitro HID Led
-    @category Laptop
-    @type HID
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAcerHIDControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AcerNitroHidLed::RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller)
-{
-    this->controller            = controller;
-    device_id                   = 0x65;
-
-    name                        = "Acer Nitro HID LED Device";
-    vendor                      = "Acer";
-    type                        = DEVICE_TYPE_LIGHT;
-    description                 = "Acer Nitro HID LED Device";
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ACER_HID_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS ;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    Direct.brightness_min       = 0;
-    Direct.brightness_max       = 100;
-    Direct.brightness           = 100;
-
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ACER_HID_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min       = 0;
-    Static.brightness_max       = 100;
-    Static.brightness           = 100;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    Static.speed                = 0;
-
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ACER_HID_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR  | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.brightness_min    = 0;
-    Breathing.brightness_max    = 100;
-    Breathing.brightness        = 100;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 1;
-    Breathing.speed_min         = 1;
-    Breathing.speed_max         = 5;
-    Breathing.speed             = 4;
-    Breathing.colors.resize(1);
-
-    modes.push_back(Breathing);
-
-    mode Neon;
-    Neon.name                   = "Neon";
-    Neon.value                  = ACER_HID_MODE_NEON;
-    Neon.flags                  = MODE_FLAG_REQUIRES_ENTIRE_DEVICE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Neon.color_mode             = MODE_COLORS_NONE;
-    Neon.brightness_min         = 0;
-    Neon.brightness_max         = 100;
-    Neon.brightness             = 100;
-    Neon.speed_min              = 1;
-    Neon.speed_max              = 5;
-    Neon.speed                  = 4;
-
-    modes.push_back(Neon);
-
-    SetupZones();
-}
-
-RGBController_AcerNitroHidLed::~RGBController_AcerNitroHidLed()
-{
-    Shutdown();
-}
-
-void RGBController_AcerNitroHidLed::SetupZones()
-{
-    zone* new_zone          = new zone;
-
-    new_zone->name          = "LED";
-    new_zone->type          = ZONE_TYPE_LINEAR;
-    new_zone->leds_min      = 1;
-    new_zone->leds_max      = 1;
-    new_zone->leds_count    = 1;
-    zones.push_back(*new_zone);
-
-    led* new_led            = new led();
-    new_led->name           = "LED";
-    new_led->value          = (unsigned int)leds.size();
-    leds.push_back(*new_led);
-
-    SetupColors();
-}
-
-void RGBController_AcerNitroHidLed::DeviceUpdateLEDs()
-{
-    mode& current_mode = modes[active_mode];
-    if(current_mode.value == ACER_HID_MODE_DIRECT)
-    {
-        controller->SetLEDs(colors, current_mode.brightness, device_id);
-    }
-    else
-    {
-        RGBColor color          = current_mode.colors.size()==0? (RGBColor)0 :  current_mode.colors[0];
-        unsigned char direction = 1;
-        if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && modes[active_mode].direction)
-        {
-            direction           = 2;
-        }
-        controller->SetAllLEDs(color, current_mode.brightness, current_mode.speed, direction, current_mode.value, device_id);
-    }
-}
-
-void RGBController_AcerNitroHidLed::DeviceUpdateZoneLEDs(int)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AcerNitroHidLed::DeviceUpdateSingleLED(int)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AcerNitroHidLed::DeviceUpdateMode()
-{
-    DeviceUpdateLEDs();
-}

Controllers/AcerNitroHidKeyboardController/RGBController_AcerNitroHidLed.h

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AcerNitroHidLed.cpp                         |
-|                                                           |
-|   RGBController for Acer Nitro HID LED                    |
-|                                                           |
-|   Marek Pokropiński                           Jul 27 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AcerNitroHidKeyboardController.h"
-#include "RGBController_AcerNitroHidKeyboard.h"
-
-class RGBController_AcerNitroHidLed : public RGBController
-{
-public:
-    RGBController_AcerNitroHidLed(std::shared_ptr<AcerNitroHidKeyboardController> controller);
-    ~RGBController_AcerNitroHidLed();
-
-    void SetupZones();
-
-    void DeviceUpdateLEDs();
-    void DeviceUpdateZoneLEDs(int zone);
-    void DeviceUpdateSingleLED(int led);
-
-    void DeviceUpdateMode();
-
-private:
-    std::shared_ptr<AcerNitroHidKeyboardController> controller;
-    unsigned int device_id;
-};

Controllers/AlienwareController/AlienwareController.cpp

@@ -266,53 +266,42 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
         return(true);
     }
 
-    bool result = true;
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
 
     /*-----------------------------------------------------*\
-    | Split the zone list into packet-sized chunks so it    |
-    | never overflows usb_buf                               |
+    | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = (uint16_t)zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
+    usb_buf[0x03]       = static_cast<uint8_t>(percent);
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
     {
-        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-        /*-------------------------------------------------*\
-        | Zero out buffer                                   |
-        \*-------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-------------------------------------------------*\
-        | Set up message packet with leading 00, per hidapi |
-        \*-------------------------------------------------*/
-        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
-
-        usb_buf[0x00]       = 0x00;
-        usb_buf[0x01]       = 0x03;
-        usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
-        usb_buf[0x03]       = static_cast<uint8_t>(percent);
-        usb_buf[0x04]       = num_zones >> 8;
-        usb_buf[0x05]       = num_zones & 0xFF;
-
-        for(size_t i = 0; i < num_zones; i++)
-        {
-            usb_buf[0x06+i] = zones[offset + i];
-        }
-
-        /*-------------------------------------------------*\
-        | Send packet                                       |
-        \*-------------------------------------------------*/
-        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-        HidapiAlienwareReport response = GetResponse();
-
-        /*-------------------------------------------------*\
-        | For this command, error is if the output equals   |
-        | the input                                         |
-        \*-------------------------------------------------*/
-        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+        usb_buf[0x06+i] = zones[i];
     }
 
-    return(result);
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
 }
 
 bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
@@ -381,53 +370,42 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
         return(false);
     }
 
-    bool result = true;
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
 
     /*-----------------------------------------------------*\
-    | Split the zone list into packet-sized chunks so it    |
-    | never overflows usb_buf                               |
+    | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones  = (uint16_t)zones.size();
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
+    usb_buf[0x03]       = 1; // loop?
+    usb_buf[0x04]       = num_zones >> 8;
+    usb_buf[0x05]       = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
     {
-        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-        /*-------------------------------------------------*\
-        | Zero out buffer                                   |
-        \*-------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-------------------------------------------------*\
-        | Set up message packet with leading 00, per hidapi |
-        \*-------------------------------------------------*/
-        uint16_t num_zones  = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
-
-        usb_buf[0x00]       = 0x00;
-        usb_buf[0x01]       = 0x03;
-        usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
-        usb_buf[0x03]       = 1; // loop?
-        usb_buf[0x04]       = num_zones >> 8;
-        usb_buf[0x05]       = num_zones & 0xFF;
-
-        for(size_t i = 0; i < num_zones; i++)
-        {
-            usb_buf[0x06+i] = zones[offset + i];
-        }
-
-        /*-------------------------------------------------*\
-        | Send packet                                       |
-        \*-------------------------------------------------*/
-        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-        HidapiAlienwareReport response = GetResponse();
-
-        /*-------------------------------------------------*\
-        | For this command, error is if the output equals   |
-        | the input                                         |
-        \*-------------------------------------------------*/
-        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+        usb_buf[0x06+i] = zones[i];
     }
 
-    return(result);
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
 }
 
 bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
@@ -531,55 +509,44 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
         return(true);
     }
 
-    bool result = true;
+    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
 
     /*-----------------------------------------------------*\
-    | Split the zone list into packet-sized chunks so it    |
-    | never overflows usb_buf                               |
+    | Zero out buffer                                       |
     \*-----------------------------------------------------*/
-    for(size_t offset = 0; offset < zones.size(); offset += ALIENWARE_MAX_ZONES_PER_PACKET)
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00, per hidapi     |
+    \*-----------------------------------------------------*/
+    uint16_t num_zones      = (uint16_t)zones.size();
+
+    usb_buf[0x00]           = 0x00;
+    usb_buf[0x01]           = 0x03;
+    usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
+    usb_buf[0x03]           = RGBGetRValue(color);
+    usb_buf[0x04]           = RGBGetGValue(color);
+    usb_buf[0x05]           = RGBGetBValue(color);
+    usb_buf[0x06]           = num_zones >> 8;
+    usb_buf[0x07]           = num_zones & 0xFF;
+
+    for(size_t i = 0; i < num_zones; i++)
     {
-        unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-        /*-------------------------------------------------*\
-        | Zero out buffer                                   |
-        \*-------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-------------------------------------------------*\
-        | Set up message packet with leading 00, per hidapi |
-        \*-------------------------------------------------*/
-        uint16_t num_zones      = (uint16_t)std::min<size_t>(ALIENWARE_MAX_ZONES_PER_PACKET, zones.size() - offset);
-
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0x03;
-        usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
-        usb_buf[0x03]           = RGBGetRValue(color);
-        usb_buf[0x04]           = RGBGetGValue(color);
-        usb_buf[0x05]           = RGBGetBValue(color);
-        usb_buf[0x06]           = num_zones >> 8;
-        usb_buf[0x07]           = num_zones & 0xFF;
-
-        for(size_t i = 0; i < num_zones; i++)
-        {
-            usb_buf[0x08 + i]   = zones[offset + i];
-        }
-
-        /*-------------------------------------------------*\
-        | Send packet                                       |
-        \*-------------------------------------------------*/
-        SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-        HidapiAlienwareReport response = GetResponse();
-
-        /*-------------------------------------------------*\
-        | For this command, error is if the output equals   |
-        | the input                                         |
-        \*-------------------------------------------------*/
-        result &= (response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE);
+        usb_buf[0x08 + i]   = zones[i];
     }
 
-    return(result);
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
+
+    HidapiAlienwareReport response = GetResponse();
+
+    /*-----------------------------------------------------*\
+    | For this command, error is if the output equals the   |
+    | input                                                 |
+    \*-----------------------------------------------------*/
+    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
 }
 
 bool AlienwareController::Reset()

Controllers/AlienwareController/AlienwareController.h

@@ -22,14 +22,6 @@
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
 #define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
-
-/*---------------------------------------------------------*\
-| Max zone IDs that fit in one report after the command     |
-| header.  Selections larger than this must be split across |
-| multiple packets; writing them into a single report       |
-| overflows usb_buf (e.g. desktops with ~100 zones).        |
-\*---------------------------------------------------------*/
-#define ALIENWARE_MAX_ZONES_PER_PACKET      25
 enum
 {
     ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -313,7 +313,7 @@ void RGBController_AlienwareAW410K::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
+        led_values.push_back(led_names[led_idx].idx);
         leds.push_back(new_led);
     }
 
@@ -329,14 +329,14 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
 
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-            SelectedButtons key;
+        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]);
+        key.idx     = led_values[led_idx];
+        key.red     = RGBGetRValue(colors[led_idx]);
+        key.green   = RGBGetGValue(colors[led_idx]);
+        key.blue    = RGBGetBValue(colors[led_idx]);
 
-            frame_buf_keys.push_back(key);
+        frame_buf_keys.push_back(key);
     }
 
     controller->SendInitialize();
@@ -358,7 +358,7 @@ void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW410K::DeviceUpdateMode()

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -32,4 +32,5 @@ public:
 private:
     AlienwareAW410KController*  controller;
     std::vector<RGBColor>       current_colors;
+    std::vector<unsigned char>  led_values;
 };

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KControllerDetect.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -312,7 +312,7 @@ void RGBController_AlienwareAW510K::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
+        led_values.push_back(led_names[led_idx].idx);
         leds.push_back(new_led);
     }
 
@@ -328,7 +328,7 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
 
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        if (current_colors[led_idx]==new_colors[led_idx])
+        if(current_colors[led_idx] == new_colors[led_idx])
         {
             /*-------------------------------------------------*\
             | Don't send if key color is not changed            |
@@ -336,28 +336,14 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
             continue;
         }
 
-        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
-        {
-            SelectedKeys key;
+        SelectedKeys 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]);
+        key.idx     = led_values[led_idx];
+        key.red     = RGBGetRValue(colors[led_idx]);
+        key.green   = RGBGetGValue(colors[led_idx]);
+        key.blue    = RGBGetBValue(colors[led_idx]);
 
-            frame_buf_keys.push_back(key);
-        }
-        else
-        {
-            SelectedKeys 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);
-        }
+        frame_buf_keys.push_back(key);
     }
 
     controller->SendInitialize();
@@ -379,7 +365,7 @@ void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW510K::DeviceUpdateMode()

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -31,4 +31,5 @@ public:
 private:
     AlienwareAW510KController*  controller;
     std::vector<RGBColor>       current_colors;
+    std::vector<unsigned char>  led_values;
 };

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,7 +1,7 @@
 /*---------------------------------------------------------*\
-| AlienwareAW410KControllerDetect.cpp                       |
+| AlienwareKeyboardControllerDetect.cpp                     |
 |                                                           |
-|   Detector for Alienware AW410K Keyboard                  |
+|   Detector for Alienware Keyboard                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -10,17 +10,38 @@
 #include <hidapi.h>
 #include "DetectionManager.h"
 #include "AlienwareAW410KController.h"
+#include "AlienwareAW510KController.h"
 #include "RGBController_AlienwareAW410K.h"
+#include "RGBController_AlienwareAW510K.h"
 
 /*---------------------------------------------------------*\
 | Alienware vendor ID                                       |
 \*---------------------------------------------------------*/
-#define ALIENWARE_VID                               0x04F2
+#define ALIENWARE_VID                           0x04F2
 
 /*---------------------------------------------------------*\
 | Keyboard product IDs                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_AW410K_PID                        0x1968
+#define ALIENWARE_AW510K_PID                    0x1830
+#define ALIENWARE_AW410K_PID                    0x1968
+
+DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
+        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
 
 DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
@@ -40,4 +61,5 @@ DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, cons
     return(detected_controllers);
 }
 
+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);

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController.cpp

@@ -40,11 +40,11 @@ std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
 
 void AlienwareAW3423DWFController::PerformLogin()
 {
-    unsigned char init_packet[192] = {0x00};
-    init_packet[0] = 0x40;
-    init_packet[1] = 0xE1;
-    init_packet[2] = 0x01;
-    SendControlPacket(init_packet, 192);
+    unsigned char init_packet[64] =
+    {
+        0x40, 0xE1, 0x01
+    };
+    SendControlPacket(init_packet, 4);
 
     std::vector<unsigned char> response = GetReportResponse();
 

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController/AlienwareAW3423DWFControllerDetect.cpp

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

Controllers/AlienwareMonitorController/AlienwareMonitorControllerDetect.cpp

@@ -10,8 +10,10 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
+#include "AlienwareAW3423DWFController.h"
 #include "AlienwareMonitorController.h"
 #include "DetectionManager.h"
+#include "RGBController_AlienwareAW3423DWF.h"
 #include "RGBController_AlienwareMonitor.h"
 
 /*---------------------------------------------------------*\
@@ -22,10 +24,29 @@
 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
 \*---------------------------------------------------------*/
+#define ALIENWARE_AW3423DWF_PID                     0x100E
 #define ALIENWARE_AW3225QF_PID                      0x1013
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA
 
+DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
+        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
 DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
@@ -44,4 +65,5 @@ DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, con
     return(detected_controllers);
 }
 
+REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
 REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -11,6 +11,13 @@
 
 #include "RGBController_AlienwareAW3423DWF.h"
 
+static const unsigned char led_values[] =
+{
+    0x01,
+    0x02,
+    0x08
+};
+
 /**------------------------------------------------------------------*\
     @name AW3423DWF
     @category Accessory
@@ -63,7 +70,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led Logo_LED;
     Logo_LED.name           = "Logo";
-    Logo_LED.value          = 0x01;
     leds.push_back(Logo_LED);
 
     zone Number;
@@ -76,7 +82,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led Number_LED;
     Number_LED.name         = "Number";
-    Number_LED.value        = 0x02;
     leds.push_back(Number_LED);
 
     zone PowerButton;
@@ -89,7 +94,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
 
     led PowerButton_LED;
     PowerButton_LED.name    = "Power Button";
-    PowerButton_LED.value   = 0x08;
     leds.push_back(PowerButton_LED);
 
     SetupColors();
@@ -128,7 +132,7 @@ void RGBController_AlienwareAW3423DWF::DeviceUpdateSingleLED(int led)
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);
     unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(leds[led].value, red, grn, blu);
+    controller->SendColor(led_values[led], red, grn, blu);
 }
 
 void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -11,6 +11,13 @@
 
 #include "RGBController_AlienwareMonitor.h"
 
+static const unsigned char led_values[] =
+{
+    0x01,
+    0x02,
+    0x08
+};
+
 /**------------------------------------------------------------------*\
     @name Alienware Monitor
     @category Accessory
@@ -63,7 +70,6 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led Logo_LED;
     Logo_LED.name           = "Logo";
-    Logo_LED.value          = 0x01;
     leds.push_back(Logo_LED);
 
     zone Number;
@@ -76,7 +82,6 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led Number_LED;
     Number_LED.name         = "Number";
-    Number_LED.value        = 0x02;
     leds.push_back(Number_LED);
 
     zone PowerButton;
@@ -89,7 +94,6 @@ void RGBController_AlienwareMonitor::SetupZones()
 
     led PowerButton_LED;
     PowerButton_LED.name    = "Power Button";
-    PowerButton_LED.value   = 0x08;
     leds.push_back(PowerButton_LED);
 
     SetupColors();
@@ -128,7 +132,7 @@ void RGBController_AlienwareMonitor::DeviceUpdateSingleLED(int led)
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);
     unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(leds[led].value, red, grn, blu);
+    controller->SendColor(led_values[led], red, grn, blu);
 }
 
 void RGBController_AlienwareMonitor::DeviceUpdateMode()

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -38,76 +38,69 @@ static const unsigned int zone_sizes[] =
     LED_COUNT,
 };
 
-typedef struct
+static const char* led_names[] =
 {
-    const char *        name;
-    const unsigned char idx;
-} annepro2_led_type;
-
-static const annepro2_led_type led_names[] =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0       },
-    { KEY_EN_1,                 1       },
-    { KEY_EN_2,                 2       },
-    { KEY_EN_3,                 3       },
-    { KEY_EN_4,                 4       },
-    { KEY_EN_5,                 5       },
-    { KEY_EN_6,                 6       },
-    { KEY_EN_7,                 7       },
-    { KEY_EN_8,                 8       },
-    { KEY_EN_9,                 9       },
-    { KEY_EN_0,                 10      },
-    { KEY_EN_MINUS,             11      },
-    { KEY_EN_EQUALS,            12      },
-    { KEY_EN_BACKSPACE,         13      },
-    { KEY_EN_TAB,               14      },
-    { KEY_EN_Q,                 15      },
-    { KEY_EN_W,                 16      },
-    { KEY_EN_E,                 17      },
-    { KEY_EN_R,                 18      },
-    { KEY_EN_T,                 19      },
-    { KEY_EN_Y,                 20      },
-    { KEY_EN_U,                 21      },
-    { KEY_EN_I,                 22      },
-    { KEY_EN_O,                 23      },
-    { KEY_EN_P,                 24      },
-    { KEY_EN_LEFT_BRACKET,      25      },
-    { KEY_EN_RIGHT_BRACKET,     26      },
-    { KEY_EN_ANSI_BACK_SLASH,   27      },
-    { KEY_EN_CAPS_LOCK,         28      },
-    { KEY_EN_A,                 29      },
-    { KEY_EN_S,                 30      },
-    { KEY_EN_D,                 31      },
-    { KEY_EN_F,                 32      },
-    { KEY_EN_G,                 33      },
-    { KEY_EN_H,                 34      },
-    { KEY_EN_J,                 35      },
-    { KEY_EN_K,                 36      },
-    { KEY_EN_L,                 37      },
-    { KEY_EN_SEMICOLON,         38      },
-    { KEY_EN_QUOTE,             39      },
-    { KEY_EN_ANSI_ENTER,        40      },
-    { KEY_EN_LEFT_SHIFT,        41      },
-    { KEY_EN_Z,                 42      },
-    { KEY_EN_X,                 43      },
-    { KEY_EN_C,                 44      },
-    { KEY_EN_V,                 45      },
-    { KEY_EN_B,                 46      },
-    { KEY_EN_N,                 47      },
-    { KEY_EN_M,                 48      },
-    { KEY_EN_COMMA,             49      },
-    { KEY_EN_PERIOD,            50      },
-    { KEY_EN_FORWARD_SLASH,     51      },
-    { KEY_EN_RIGHT_SHIFT,       52      },
-    { KEY_EN_LEFT_CONTROL,      53      },
-    { KEY_EN_LEFT_WINDOWS,      54      },
-    { KEY_EN_LEFT_ALT,          55      },
-    { KEY_EN_SPACE,             56      },
-    { KEY_EN_RIGHT_ALT,         57      },
-    { KEY_EN_RIGHT_FUNCTION,    58      },
-    { KEY_EN_MENU,              59      },
-    { KEY_EN_RIGHT_CONTROL,     60      },
+    KEY_EN_ESCAPE,
+    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_TAB,
+    KEY_EN_Q,
+    KEY_EN_W,
+    KEY_EN_E,
+    KEY_EN_R,
+    KEY_EN_T,
+    KEY_EN_Y,
+    KEY_EN_U,
+    KEY_EN_I,
+    KEY_EN_O,
+    KEY_EN_P,
+    KEY_EN_LEFT_BRACKET,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_ANSI_BACK_SLASH,
+    KEY_EN_CAPS_LOCK,
+    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_LEFT_SHIFT,
+    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_LEFT_CONTROL,
+    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,
 };
 
 /**------------------------------------------------------------------*\
@@ -177,8 +170,7 @@ void RGBController_AnnePro2::SetupZones()
     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;
+        new_led.name  = led_names[led_idx];
         leds.push_back(new_led);
     }
 
@@ -194,7 +186,7 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
     | TODO: Send packets with multiple LED frames               |
     \*---------------------------------------------------------*/
     std::size_t led_real_idx = 0;
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    for(std::size_t led_idx = 0; led_idx < colors.size(); led_idx++)
     {
         frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
         frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -21,13 +21,13 @@
 DetectedControllers DetectArcticControllers()
 {
     DetectedControllers         detected_controllers;
-    std::vector<std::string>    ports;
+    std::vector<std::string *>  ports;
 
     ports = find_usb_serial_port(CH341_VID, CH341_PID);
 
     for(unsigned int device = 0; device < ports.size(); device++)
     {
-        ArcticController *controller = new ArcticController(ports[device]);
+        ArcticController *controller = new ArcticController(*ports[device]);
 
         if(controller->IsPresent())
         {
@@ -38,10 +38,16 @@ DetectedControllers DetectArcticControllers()
         {
             delete controller;
         }
+
+        delete ports[device];
     }
 
     return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
-REGISTER_CUSTOM_UDEV_RULE(arctic, "Arctic RGB controller", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1a86\", ATTRS{idProduct}==\"7523\", TAG+=\"uaccess\", TAG+=\"Arctic_RGB_controller\"");
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1A86, 0x7523 )                  |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -75,7 +75,6 @@ void RGBController_Arctic::SetupZones()
 
         led Led;
         Led.name    = LedZone.name + " LED";
-        Led.value   = channel;
 
         zones.push_back(LedZone);
         leds.push_back(Led);

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -4,15 +4,18 @@
 |   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-or-later               |
 \*---------------------------------------------------------*/
 
-#include <hidapi.h>
-#include "AsusAuraCoreController.h"
 #include "DetectionManager.h"
+#include "AsusAuraCoreController.h"
+#include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
+#include "RGBController_AsusAuraCoreLaptop.h"
+#include <hidapi.h>
 
 #define AURA_CORE_VID                   0x0B05
 
@@ -41,6 +44,27 @@ DetectedControllers DetectAsusAuraCoreControllers(hid_device_info* info, const s
     return(detected_controllers);
 }
 
+DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
+        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
+
+        detected_controllers.push_back(rgb_controller);
+    }
+
+    return(detected_controllers);
+}
+
+
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1854);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1866);
 REGISTER_HID_DETECTOR   ("ASUS Aura Core",              DetectAsusAuraCoreControllers,          AURA_CORE_VID, 0x1869);
+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);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopControllerDetect.cpp

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------*\
-| AsusAuraCoreLaptopControllerDetect.cpp                    |
-|                                                           |
-|   Detector 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-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "AsusAuraCoreLaptopController.h"
-#include "DetectionManager.h"
-#include "RGBController_AsusAuraCoreLaptop.h"
-
-#define AURA_CORE_VID                   0x0B05
-
-DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
-        RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-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);

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp

@@ -940,25 +940,6 @@ static const aura_core_laptop_device g814jv_device =
     }
 };
 
-/*-------------------------------------------------------------*\
-|  ASUS ROG Strix G18 (G814JIR)                                 |
-|                                                               |
-|  G814JIR uses the same Aura Core keyboard and lightbar        |
-|  layout as the G814JV G18 profile.                            |
-\*-------------------------------------------------------------*/
-static const aura_core_laptop_device g814jir_device =
-{
-    "G814JIR",
-    {
-        &g814rw_keyboard_zone,
-        &g814jv_lightbar_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    }
-};
-
 /*-------------------------------------------------------------------------*\
 |  DEVICE MASTER LIST                                                       |
 \*-------------------------------------------------------------------------*/
@@ -973,7 +954,6 @@ const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
     &g713rw_device,
     &g733qr_device,
     &g814jv_device,
-    &g814jir_device,
 };
 
 const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -351,11 +351,14 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                     new_zone.leds_count             = new_kb.GetKeyCount();
                     for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                     {
-                        led new_led;
+                        led             new_led;
+                        unsigned int    new_led_value;
 
                         new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-                        max_led_value               = std::max(max_led_value, new_led.value);
+                        new_led_value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led_value);
+
+                        led_values.push_back(new_led_value);
                         leds.push_back(new_led);
                     }
                 }
@@ -385,24 +388,12 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[leds[led_idx].value] = &colors[led_idx];
+        buffer_map[led_values[led_idx]] = &colors[led_idx];
     }
 }
 
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
-    for(size_t i = 85; i < leds.size(); i++)
-    {
-        LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
-                  name.c_str(),
-                  leds[i].name.c_str(),
-                  i,
-                  leds[i].value,
-                  RGBGetRValue(colors[i]),
-                  RGBGetGValue(colors[i]),
-                  RGBGetBValue(colors[i]));
-    }
-
     controller->SetLedsDirect(buffer_map);
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -33,6 +33,7 @@ public:
 private:
     RGBColor                            null_color              = 0;
     std::vector<RGBColor *>             buffer_map;
+    std::vector<unsigned int>           led_values;
 
     AsusAuraCoreLaptopController*       controller;
 };

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -471,8 +471,8 @@ void RGBController_AuraKeyboard::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
 
+        led_values.push_back(led_names[led_idx].idx);
         leds.push_back(new_led);
     }
 
@@ -493,7 +493,7 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
     \*---------------------------------------------------------*/
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
+        frame_buf[(led_idx * 4) + 0] = led_values[led_idx];
         frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
         frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
         frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h

@@ -54,4 +54,5 @@ public:
 private:
     AuraKeyboardController*         controller;
     AuraKeyboardMappingLayoutType   layout;
+    std::vector<unsigned char>      led_values;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -207,8 +207,8 @@ void RGBController_AuraMouse::SetupZones()
         led mouse_led;
 
         mouse_led.name          = mouse_zone.name + " LED";
-        mouse_led.value         = *zone_it;
 
+        led_values.push_back(*zone_it);
         leds.push_back(mouse_led);
     }
 
@@ -247,7 +247,7 @@ void RGBController_AuraMouse::DeviceUpdateSingleLED(int led)
     uint8_t grn = RGBGetGValue(colors[led]);
     uint8_t blu = RGBGetBValue(colors[led]);
 
-    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
+    controller->SendUpdate(led_values[led], modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }
 
 void RGBController_AuraMouse::DeviceUpdateMode()

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h

@@ -31,5 +31,6 @@ public:
 
 private:
     AuraMouseController*  controller;
+    std::vector<uint8_t>  led_values;
     uint16_t              pid;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -141,7 +141,6 @@ void RGBController_AsusROGSpatha::SetupZones()
         led spatha_led;
 
         spatha_led.name          = zones_names[i];
-        spatha_led.value         = 1;
 
         leds.push_back(spatha_led);
     }

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -99,7 +99,6 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     led mouse_led;
 
     mouse_led.name          = "Underglow";
-    mouse_led.value         = 1;
 
     leds.push_back(mouse_led);
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -163,7 +163,6 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
 
             new_led.name = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
-            new_led.value = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -428,6 +428,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             break;
         case AURA_TUF_K3_GAMING_PID:
         case AURA_TUF_K7_GAMING_PID:
+        case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
             keyboard_ptr = &AsusTUFK7Layouts;
             break;
         case AURA_ROG_STRIX_SCOPE_PID:
@@ -484,7 +485,6 @@ void RGBController_AuraTUFKeyboard::SetupZones()
             keyboard_ptr = &AsusTufK1Layouts;
             break;
         case AURA_TUF_K3_GAMING_GEN_II_PID:
-        case AURA_TUF_K3_GENII_MIKU_EDITION_PID:
             keyboard_ptr = &AsusTUFK3GamingGen2Layouts;
             break;
         default:
@@ -520,7 +520,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     {
         led new_led;
         new_led.name  = keyboard[layout].led_names[led_id].name;
-        new_led.value = keyboard[layout].led_names[led_id].id;
+        led_values.push_back(keyboard[layout].led_names[led_id].id);
         leds.push_back(new_led);
     }
 
@@ -538,7 +538,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 
     for(size_t i = 0; i < colors.size(); i++)
     {
-        led_color_list.push_back({ leds[i].value, colors[i] });
+        led_color_list.push_back({ led_values[i], colors[i] });
     }
 
     controller->UpdateLeds(led_color_list);
@@ -560,7 +560,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateSingleLED(int led)
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(leds[led].value, red, green, blue);
+    controller->UpdateSingleLed(led_values[led], red, green, blue);
 }
 
 static const uint8_t direction_map[2][6] =

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

@@ -53,4 +53,5 @@ public:
 private:
     AuraTUFKeyboardController*  controller;
     uint16_t                    pid;
+    std::vector<uint8_t>        led_values;
 };

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -221,7 +221,7 @@ void RGBController_AuraUSB::SetupZones()
 
             new_led.name.append(std::to_string(led_idx));
 
-            new_led.value = (unsigned int)channel_idx;
+            new_led.value = channel_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -417,7 +417,7 @@ REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAs
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",                       DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR_PU("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID,                           0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_4_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",                       DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_5_PID);
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -164,7 +164,6 @@ void RGBController_AsusROGStrixLC::SetupZones()
 
             new_led.name    = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
-            new_led.value   = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.cpp

@@ -71,7 +71,6 @@ void RGBController_StrixClaw::SetupZones()
     led scroll_wheel_led;
 
     scroll_wheel_led.name          = "Scroll Wheel LED";
-    scroll_wheel_led.value         = 1;
 
     leds.push_back(scroll_wheel_led);
 
@@ -88,7 +87,6 @@ void RGBController_StrixClaw::SetupZones()
     led logo_led;
 
     logo_led.name          = "Logo LED";
-    logo_led.value         = 1;
 
     leds.push_back(logo_led);
 

Controllers/AsusMonitorController/AsusMonitorControllerDetect.cpp

@@ -22,12 +22,8 @@
 | Product ID                                                |
 \*---------------------------------------------------------*/
 #define ASUS_ROG_STRIX_XG27AQDMG_PID                   0x1BA3
-#define ASUS_ROG_STRIX_XG27ACDNG_PID                   0x1BC9
-#define ASUS_ROG_STRIX_XG27UCG_PID                     0x1BB4
+#define ASUS_ROG_SWIFT_XG27UCG_PID                     0x1BB4
 #define ASUS_ROG_SWIFT_PG32UCDM_PID                    0x1B2B
-#define ASUS_ROG_SWIFT_PG32UCDMR_PID                   0x1C9B
-#define ASUS_ROG_SWIFT_PG32UCDP_PID                    0x1BCA
-#define ASUS_ROG_AURA_MONITOR_LIGHT_BAR_PID            0x1AC8
 
 DetectedControllers DetectAsusMonitorControllers(hid_device_info* info, const std::string& name)
 {
@@ -48,13 +44,5 @@ DetectedControllers DetectAsusMonitorControllers(hid_device_info* info, const st
 }
 
 REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27AQDMG",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27AQDMG_PID,   1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27ACDNG",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27ACDNG_PID,   1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27UCG",     DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_STRIX_XG27UCG_PID,     1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDM",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDM_PID,    1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDMR",   DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDMR_PID,   1, 0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_IPU("Asus ROG SWIFT PG32UCDP",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDP_PID,    1, 0xFF72, 0x00A1);
-/*---------------------------------------------------------*\
-| ALB01 exposes the Aura HID collection on interface 2.     |
-\*---------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Asus ROG Aura Monitor Light Bar", DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_AURA_MONITOR_LIGHT_BAR_PID, 2, 0xFF72, 0x00A1);
-
+REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX XG27UCG",     DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_XG27UCG_PID,     1, 0xFF72, 0x00A1);
+REGISTER_HID_DETECTOR_IPU("Asus ROG STRIX PG32UCDM",    DetectAsusMonitorControllers, ASUS_VID, ASUS_ROG_SWIFT_PG32UCDM_PID,    1, 0xFF72, 0x00A1);

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Linux.cpp

@@ -36,5 +36,3 @@ DetectedControllers DetectAsusTUFLaptopLinuxControllers()
 }
 
 REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);
-
-REGISTER_CUSTOM_UDEV_RULE(asus_wmi, "ASUS TUF Laptops (asus-wmi)", "ACTION==\"add\", SUBSYSTEM==\"leds\", KERNEL==\"asus::kbd_backlight\", RUN+=\"/usr/bin/env chmod a+w /sys%p/kbd_rgb_mode\"\nACTION==\"add\", SUBSYSTEM==\"leds\", KERNEL==\"asus::kbd_backlight\", RUN+=\"/usr/bin/env chmod a+w /sys%p/brightness\"");

Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp

@@ -24,12 +24,12 @@
 DetectedControllers DetectBlinkyTapeControllers()
 {
     DetectedControllers         detected_controllers;
-    std::vector<std::string>    device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
+    std::vector<std::string *>  device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
 
     for(unsigned int device_idx = 0; device_idx < device_locations.size(); device_idx++)
     {
         BlinkyTapeController*     controller     = new BlinkyTapeController();
-        controller->Initialize(device_locations[device_idx]);
+        controller->Initialize(*device_locations[device_idx]);
 
         RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
 
@@ -40,4 +40,8 @@ DetectedControllers DetectBlinkyTapeControllers()
 }
 
 REGISTER_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers);
-REGISTER_CUSTOM_UDEV_RULE(blinky_tape, "BlinkyTape", "SUBSYSTEMS==\"serial|hidraw\", ATTRS{idVendor}==\"1d50\", ATTRS{idProduct}==\"605e\", TAG+=\"uaccess\", TAG+=\"BlinkyTape\"");
+/*---------------------------------------------------------------------------------------------------------*\
+| Entries for dynamic UDEV rules                                                                            |
+|                                                                                                           |
+| DUMMY_DEVICE_DETECTOR("BlinkyTape", DetectBlinkyTapeControllers, 0x1D50, 0x605E )                         |
+\*---------------------------------------------------------------------------------------------------------*/

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -1,25 +1,22 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardController.cpp                               |
 |                                                           |
-|   Driver for Clevo per-key RGB keyboard                   |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
+|   Protocol based on tuxedo-drivers ite_8291 module        |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <algorithm>
 #include <cstring>
 #include "ClevoKeyboardController.h"
 #include "StringUtils.h"
 
-ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info, clevo_keyboard_type kb_type)
+ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
 {
     dev      = dev_handle;
-    type     = kb_type;
     location = info.path;
     version  = info.release_number;
 }
@@ -29,31 +26,6 @@ ClevoKeyboardController::~ClevoKeyboardController()
     hid_close(dev);
 }
 
-clevo_keyboard_type ClevoKeyboardController::GetType()
-{
-    return type;
-}
-
-int ClevoKeyboardController::GetNumRows()
-{
-    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_NUM_ROWS : CLEVO_8291_NUM_ROWS;
-}
-
-int ClevoKeyboardController::GetNumCols()
-{
-    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_NUM_COLS : CLEVO_8291_NUM_COLS;
-}
-
-int ClevoKeyboardController::GetNumLEDs()
-{
-    return GetNumRows() * GetNumCols();
-}
-
-unsigned char ClevoKeyboardController::GetBrightnessMax()
-{
-    return(type == CLEVO_KB_ITE829X) ? CLEVO_829X_BRIGHTNESS_MAX : CLEVO_8291_BRIGHTNESS_MAX;
-}
-
 std::string ClevoKeyboardController::GetDeviceLocation()
 {
     return("HID: " + location);
@@ -79,355 +51,147 @@ std::string ClevoKeyboardController::GetFirmwareVersion()
     return(version_string);
 }
 
-/*---------------------------------------------------------*\
-| ITE 8291: 8-byte feature report, no report ID             |
-\*---------------------------------------------------------*/
-void ClevoKeyboardController::WriteControl8291(unsigned char* data)
+void ClevoKeyboardController::WriteControl(unsigned char* data)
 {
-    hid_send_feature_report(dev, data, CLEVO_8291_REPORT_SIZE);
+    hid_send_feature_report(dev, data, CLEVO_KEYBOARD_REPORT_SIZE);
 }
 
 void ClevoKeyboardController::WriteRowData(unsigned char* data)
 {
-    hid_write(dev, data, CLEVO_8291_ROW_DATA_SIZE);
-}
-
-/*---------------------------------------------------------*\
-| ITE 829x: 6-byte feature report with report ID 0xCC       |
-\*---------------------------------------------------------*/
-void ClevoKeyboardController::SendCommand829x(unsigned char cmd, unsigned char d0, unsigned char d1, unsigned char d2, unsigned char d3)
-{
-    unsigned char buf[CLEVO_829X_REPORT_SIZE];
-
-    buf[0] = CLEVO_829X_REPORT_ID;
-    buf[1] = cmd;
-    buf[2] = d0;
-    buf[3] = d1;
-    buf[4] = d2;
-    buf[5] = d3;
-
-    hid_send_feature_report(dev, buf, CLEVO_829X_REPORT_SIZE);
+    hid_write(dev, data, CLEVO_KEYBOARD_ROW_DATA_SIZE);
 }
 
 void ClevoKeyboardController::TurnOff()
 {
-    if(type == CLEVO_KB_ITE829X)
-    {
-        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS);
-        return;
-    }
+    /*---------------------------------------------------------*\
+    | Turn off: 08 01 00 00 00 00 00 00                         |
+    \*---------------------------------------------------------*/
+    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
 
-    unsigned char buf[CLEVO_8291_REPORT_SIZE];
-    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
-    buf[0] = CLEVO_8291_CMD_MODE;
-    buf[1] = CLEVO_8291_POWER_OFF;
-    WriteControl8291(buf);
+    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
+    buf[0] = 0x08;
+    buf[1] = 0x01;
+
+    WriteControl(buf);
 }
 
 void ClevoKeyboardController::SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour)
 {
-    if(type == CLEVO_KB_ITE829X)
-    {
-        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
-        return;
-    }
+    /*---------------------------------------------------------*\
+    | Set params: 08 [power] [mode] [speed] [brightness] 08     |
+    |             [behaviour] 00                                |
+    | power: 01=off, 02=on                                      |
+    \*---------------------------------------------------------*/
+    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
 
-    unsigned char buf[CLEVO_8291_REPORT_SIZE];
-    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
-    buf[0] = CLEVO_8291_CMD_MODE;
-    buf[1] = CLEVO_8291_POWER_ON;
+    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
+    buf[0] = 0x08;
+    buf[1] = 0x02;                                          // Power on
     buf[2] = mode;
     buf[3] = speed;
     buf[4] = brightness;
-    buf[5] = CLEVO_8291_MODE_FLAG;
+    buf[5] = 0x08;
     buf[6] = behaviour;
-    WriteControl8291(buf);
+
+    WriteControl(buf);
 }
 
-void ClevoKeyboardController::SetModeColor(unsigned char color_idx, RGBColor color)
+void ClevoKeyboardController::SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue)
 {
-    if(type == CLEVO_KB_ITE829X)
-    {
-        return;
-    }
+    /*---------------------------------------------------------*\
+    | Set color define: 14 00 [index] R G B 00 00               |
+    | index: 1-7 for built-in effects                           |
+    \*---------------------------------------------------------*/
+    unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
 
-    unsigned char buf[CLEVO_8291_REPORT_SIZE];
-    memset(buf, 0x00, CLEVO_8291_REPORT_SIZE);
-    buf[0] = CLEVO_8291_CMD_COLOR;
+    memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
+    buf[0] = 0x14;
+    buf[1] = 0x00;
     buf[2] = color_idx;
-    buf[3] = RGBGetRValue(color);
-    buf[4] = RGBGetGValue(color);
-    buf[5] = RGBGetBValue(color);
-    WriteControl8291(buf);
+    buf[3] = red;
+    buf[4] = green;
+    buf[5] = blue;
+
+    WriteControl(buf);
 }
 
-void ClevoKeyboardController::SetBrightnessSpeed829x(unsigned char brightness, unsigned char speed)
+void ClevoKeyboardController::SendColors(unsigned char* color_data, unsigned char brightness)
 {
-    if(brightness > CLEVO_829X_BRIGHTNESS_MAX)
-    {
-        brightness = CLEVO_829X_BRIGHTNESS_MAX;
-    }
-
-    if(brightness != current_brightness_829x || speed != current_speed_829x)
-    {
-        current_brightness_829x = brightness;
-        current_speed_829x      = speed;
-        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
-    }
-}
-
-void ClevoKeyboardController::SendColorSlot829x(unsigned char cmd, unsigned char slot, RGBColor color)
-{
-    SendCommand829x(cmd, slot, RGBGetRValue(color), RGBGetGValue(color), RGBGetBValue(color));
-}
-
-/*---------------------------------------------------------*\
-| ITE 829x: Save/Clear BIOS keyboard state                  |
-\*---------------------------------------------------------*/
-void ClevoKeyboardController::SaveToBios829x()
-{
-    SendCommand829x(CLEVO_829X_CMD_SAVE_BIOS, 0x01);
-}
-
-void ClevoKeyboardController::ClearBiosSave829x()
-{
-    SendCommand829x(CLEVO_829X_CMD_SAVE_BIOS, 0x00);
-}
-
-void ClevoKeyboardController::StopAnimation829x()
-{
-    SendCommand829x(CLEVO_829X_CMD_ANIM, CLEVO_829X_CMD_STOP_ANIM);
-}
-
-void ClevoKeyboardController::SetEffect829x(unsigned char mode_value, const std::vector<RGBColor>& colors, unsigned int direction, unsigned int color_mode)
-{
-    bool mode_changed = (mode_value != current_mode_829x);
-    current_mode_829x = mode_value;
-    bool use_custom_color = (color_mode != MODE_COLORS_RANDOM) && !colors.empty();
+    /*---------------------------------------------------------*\
+    | Per-key RGB mode (mode 0x33)                              |
+    | 1. Set params with mode 0x33 and brightness               |
+    | 2. For each row 0-5:                                      |
+    |    - Announce row: 16 00 [row] 00 00 00 00 00             |
+    |    - Send 65 bytes row data via output report             |
+    |                                                           |
+    | Row data format (65 bytes):                               |
+    |   [0x00 padding][0x00 padding]                            |
+    |   [B0..B20][G0..G20][R0..R20]                             |
+    \*---------------------------------------------------------*/
+    unsigned char ctrl_buf[CLEVO_KEYBOARD_REPORT_SIZE];
+    unsigned char row_buf[CLEVO_KEYBOARD_ROW_DATA_SIZE];
 
     /*---------------------------------------------------------*\
-    | Animation modes: send [CC, 00, mode_id] on mode change    |
+    | Clamp brightness                                          |
     \*---------------------------------------------------------*/
-    struct anim_entry { unsigned char mode; unsigned char anim_id; };
-    static const anim_entry anim_modes[] =
+    if(brightness > CLEVO_KEYBOARD_BRIGHTNESS_MAX)
     {
-        { CLEVO_829X_MODE_WAVE,          0x04 },
-        { CLEVO_829X_MODE_RANDOM,        0x09 },
-        { CLEVO_829X_MODE_SCAN,          0x0A },
-        { CLEVO_829X_MODE_SNAKE,         0x0B },
-        { CLEVO_829X_MODE_RAINBOW_CYCLE, 0x02 },
-        { CLEVO_829X_MODE_RAINBOW_GRAD,  0x04 },
-    };
-
-    const anim_entry* anim_it = std::find_if(std::begin(anim_modes), std::end(anim_modes),
-        [mode_value](const anim_entry& e) { return e.mode == mode_value; });
-
-    if(anim_it != std::end(anim_modes) && mode_changed)
-    {
-        SendCommand829x(CLEVO_829X_CMD_ANIM, anim_it->anim_id);
+        brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
     }
 
     /*---------------------------------------------------------*\
-    | Direction-based effects (Wave/Snake)                      |
-    | Slot = base + direction_index                             |
-    | Custom color: base = 0xA1, Preset: base = 0x71            |
+    | Set params for per-key mode                               |
     \*---------------------------------------------------------*/
-    /*---------------------------------------------------------*\
-    | Map OpenRGB direction enum to firmware slot index         |
-    \*---------------------------------------------------------*/
-    static const unsigned char dir_to_wave_idx[] =
-    {
-        6,  /* MODE_DIRECTION_LEFT       */
-        7,  /* MODE_DIRECTION_RIGHT      */
-        4,  /* MODE_DIRECTION_UP         */
-        5,  /* MODE_DIRECTION_DOWN       */
-        6,  /* MODE_DIRECTION_HORIZONTAL */
-        4,  /* MODE_DIRECTION_VERTICAL   */
-        0,  /* MODE_DIRECTION_UP_LEFT    */
-        1,  /* MODE_DIRECTION_UP_RIGHT   */
-        2,  /* MODE_DIRECTION_DOWN_LEFT  */
-        3,  /* MODE_DIRECTION_DOWN_RIGHT */
-    };
-
-    static const unsigned char dir_to_snake_idx[] =
-    {
-        0,  /* MODE_DIRECTION_LEFT       */
-        0,  /* MODE_DIRECTION_RIGHT      */
-        0,  /* MODE_DIRECTION_UP         */
-        0,  /* MODE_DIRECTION_DOWN       */
-        0,  /* MODE_DIRECTION_HORIZONTAL */
-        0,  /* MODE_DIRECTION_VERTICAL   */
-        0,  /* MODE_DIRECTION_UP_LEFT    */
-        1,  /* MODE_DIRECTION_UP_RIGHT   */
-        2,  /* MODE_DIRECTION_DOWN_LEFT  */
-        3,  /* MODE_DIRECTION_DOWN_RIGHT */
-    };
-
-    if((mode_value == CLEVO_829X_MODE_WAVE || mode_value == CLEVO_829X_MODE_RAINBOW_GRAD) && direction < sizeof(dir_to_wave_idx))
-    {
-        unsigned char base = use_custom_color ? CLEVO_829X_COLOR_SLOT_BASE : CLEVO_829X_PRESET_SLOT_BASE;
-        unsigned char idx  = dir_to_wave_idx[direction];
-        unsigned char slot = base + idx;
-
-        if(use_custom_color)
-        {
-            SendColorSlot829x(CLEVO_829X_CMD_WAVE_COLOR, slot, colors[0]);
-        }
-
-        if(!use_custom_color)
-        {
-            SendCommand829x(CLEVO_829X_CMD_WAVE_COLOR, slot);
-        }
-    }
-
-    if(mode_value == CLEVO_829X_MODE_SNAKE && direction < sizeof(dir_to_snake_idx))
-    {
-        unsigned char base = use_custom_color ? CLEVO_829X_COLOR_SLOT_BASE : CLEVO_829X_PRESET_SLOT_BASE;
-        unsigned char idx  = dir_to_snake_idx[direction];
-        unsigned char slot = base + idx;
-
-        if(use_custom_color)
-        {
-            SendColorSlot829x(CLEVO_829X_CMD_SNAKE_COLOR, slot, colors[0]);
-        }
-
-        if(!use_custom_color)
-        {
-            SendCommand829x(CLEVO_829X_CMD_SNAKE_COLOR, slot);
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Breathing/Flashing: random or custom color                |
-    \*---------------------------------------------------------*/
-    if(mode_value == CLEVO_829X_MODE_BREATH && use_custom_color)
-    {
-        SendColorSlot829x(0x0A, CLEVO_829X_COLOR_CUSTOM, colors[0]);
-    }
-
-    if(mode_value == CLEVO_829X_MODE_BREATH && !use_custom_color)
-    {
-        SendCommand829x(0x0A);
-    }
-
-    if(mode_value == CLEVO_829X_MODE_BLINK && use_custom_color)
-    {
-        SendColorSlot829x(0x0B, CLEVO_829X_COLOR_CUSTOM, colors[0]);
-    }
-
-    if(mode_value == CLEVO_829X_MODE_BLINK && !use_custom_color)
-    {
-        SendCommand829x(0x0B);
-    }
-
-    /*---------------------------------------------------------*\
-    | Random: custom color only (multicolor is the default)     |
-    \*---------------------------------------------------------*/
-    if(mode_value == CLEVO_829X_MODE_RANDOM && use_custom_color)
-    {
-        SendColorSlot829x(CLEVO_829X_CMD_RANDOM_COLOR, CLEVO_829X_COLOR_SLOT_BASE, colors[0]);
-    }
-
-    /*---------------------------------------------------------*\
-    | Scan: 2 custom color bands                                |
-    \*---------------------------------------------------------*/
-    if(mode_value == CLEVO_829X_MODE_SCAN)
-    {
-        for(size_t i = 0; i < colors.size() && i < 2; i++)
-        {
-            SendColorSlot829x(CLEVO_829X_CMD_SCAN_COLOR, CLEVO_829X_COLOR_SLOT_BASE + (unsigned char)i, colors[i]);
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Fn Highlight: per-key color on function keys              |
-    \*---------------------------------------------------------*/
-    if(mode_value == CLEVO_829X_MODE_FN_COLOR && !colors.empty())
-    {
-        static const unsigned char fn_keys[] =
-        {
-            0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x09,
-            0x0A, 0x0B, 0x0C, 0x21, 0x23, 0x31, 0x32, 0x33,
-            0x53, 0x73, 0xA2
-        };
-
-        SendCommand829x(CLEVO_829X_CMD_ANIM, CLEVO_829X_CMD_CLEAR);
-
-        for(unsigned char key : fn_keys)
-        {
-            SendCommand829x(CLEVO_829X_CMD_SET_LED, key,
-                RGBGetRValue(colors[0]),
-                RGBGetGValue(colors[0]),
-                RGBGetBValue(colors[0]));
-        }
-    }
-}
-
-void ClevoKeyboardController::SendColors(const unsigned char* color_data, unsigned char brightness, unsigned char speed)
-{
-    int num_rows = GetNumRows();
-    int num_cols = GetNumCols();
-
-    if(type == CLEVO_KB_ITE829X)
-    {
-        if(brightness > CLEVO_829X_BRIGHTNESS_MAX)
-        {
-            brightness = CLEVO_829X_BRIGHTNESS_MAX;
-        }
-
-        SendCommand829x(CLEVO_829X_CMD_BRIGHTNESS, brightness, speed);
-
-        for(int row = 0; row < num_rows; row++)
-        {
-            for(int col = 0; col < num_cols; col++)
-            {
-                int idx = (row * num_cols + col) * 3;
-
-                SendCommand829x(CLEVO_829X_CMD_SET_LED,
-                    CLEVO_829X_LED_ID(row, col),
-                    color_data[idx + 0],
-                    color_data[idx + 1],
-                    color_data[idx + 2]);
-            }
-        }
-
-        return;
-    }
-
-    /*---------------------------------------------------------*\
-    | ITE 8291: row-based color transfer                        |
-    \*---------------------------------------------------------*/
-    unsigned char ctrl_buf[CLEVO_8291_REPORT_SIZE];
-    unsigned char row_buf[CLEVO_8291_ROW_DATA_SIZE];
-
-    if(brightness > CLEVO_8291_BRIGHTNESS_MAX)
-    {
-        brightness = CLEVO_8291_BRIGHTNESS_MAX;
-    }
-
-    memset(ctrl_buf, 0x00, CLEVO_8291_REPORT_SIZE);
-    ctrl_buf[0] = CLEVO_8291_CMD_MODE;
-    ctrl_buf[1] = CLEVO_8291_POWER_ON;
-    ctrl_buf[2] = CLEVO_KEYBOARD_MODE_DIRECT;
+    memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
+    ctrl_buf[0] = 0x08;
+    ctrl_buf[1] = 0x02;                                     // Power on
+    ctrl_buf[2] = CLEVO_KEYBOARD_MODE_DIRECT;               // Per-key mode
+    ctrl_buf[3] = 0x00;                                     // Speed (unused)
     ctrl_buf[4] = brightness;
-    WriteControl8291(ctrl_buf);
+    ctrl_buf[5] = 0x00;
+    ctrl_buf[6] = 0x00;
 
-    for(int row = 0; row < num_rows; row++)
+    WriteControl(ctrl_buf);
+
+    /*---------------------------------------------------------*\
+    | Send each row                                             |
+    \*---------------------------------------------------------*/
+    for(int row = 0; row < CLEVO_KEYBOARD_NUM_ROWS; row++)
     {
-        memset(ctrl_buf, 0x00, CLEVO_8291_REPORT_SIZE);
-        ctrl_buf[0] = CLEVO_8291_CMD_ROW;
+        /*-----------------------------------------------------*\
+        | Announce row data                                     |
+        \*-----------------------------------------------------*/
+        memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
+        ctrl_buf[0] = 0x16;
+        ctrl_buf[1] = 0x00;
         ctrl_buf[2] = row;
-        WriteControl8291(ctrl_buf);
 
-        memset(row_buf, 0x00, CLEVO_8291_ROW_DATA_SIZE);
+        WriteControl(ctrl_buf);
 
-        for(int col = 0; col < num_cols; col++)
+        /*-----------------------------------------------------*\
+        | Build row data buffer                                 |
+        | Format: [pad][pad][B0..B20][G0..G20][R0..R20]         |
+        \*-----------------------------------------------------*/
+        memset(row_buf, 0x00, CLEVO_KEYBOARD_ROW_DATA_SIZE);
+
+        for(int col = 0; col < CLEVO_KEYBOARD_NUM_COLS; col++)
         {
-            int idx = (row * num_cols + col) * 3;
+            int led_idx = (row * CLEVO_KEYBOARD_NUM_COLS) + col;
+            int color_offset = led_idx * 3;
 
-            row_buf[2 + col]                = color_data[idx + 2];
-            row_buf[2 + num_cols + col]     = color_data[idx + 1];
-            row_buf[2 + num_cols * 2 + col] = color_data[idx + 0];
+            unsigned char red   = color_data[color_offset + 0];
+            unsigned char green = color_data[color_offset + 1];
+            unsigned char blue  = color_data[color_offset + 2];
+
+            /*-------------------------------------------------*\
+            | Row data layout (after 2-byte padding):           |
+            | Bytes  2-22: Blue values for columns 0-20         |
+            | Bytes 23-43: Green values for columns 0-20        |
+            | Bytes 44-64: Red values for columns 0-20          |
+            \*-------------------------------------------------*/
+            row_buf[2 + col]                             = blue;
+            row_buf[2 + CLEVO_KEYBOARD_NUM_COLS + col]   = green;
+            row_buf[2 + CLEVO_KEYBOARD_NUM_COLS*2 + col] = red;
         }
 
         WriteRowData(row_buf);

Controllers/ClevoKeyboardController/ClevoKeyboardController.h

@@ -1,11 +1,9 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardController.h                                 |
 |                                                           |
-|   Driver for Clevo per-key RGB keyboard                   |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -14,75 +12,27 @@
 #pragma once
 
 #include <string>
-#include <vector>
 #include <hidapi.h>
-#include "RGBController.h"
 
-/*---------------------------------------------------------*\
-| Device type enumeration                                   |
-\*---------------------------------------------------------*/
-enum clevo_keyboard_type
-{
-    CLEVO_KB_ITE8291,
-    CLEVO_KB_ITE829X,
-};
+/*-----------------------------------------------------*\
+| ITE 8291 keyboard defines                             |
+\*-----------------------------------------------------*/
+#define CLEVO_KEYBOARD_REPORT_SIZE     8
+#define CLEVO_KEYBOARD_ROW_DATA_SIZE   65
 
-/*---------------------------------------------------------*\
-| ITE 8291 keyboard defines (PID 0x600B)                    |
-| 8 bytes, no report ID, row-based color data               |
-\*---------------------------------------------------------*/
-#define CLEVO_8291_REPORT_SIZE         8
-#define CLEVO_8291_ROW_DATA_SIZE       65
-#define CLEVO_8291_NUM_ROWS            6
-#define CLEVO_8291_NUM_COLS            21
-#define CLEVO_8291_NUM_LEDS            (CLEVO_8291_NUM_ROWS * CLEVO_8291_NUM_COLS)
-#define CLEVO_8291_BRIGHTNESS_MAX      0x32
-#define CLEVO_8291_CMD_MODE            0x08
-#define CLEVO_8291_CMD_COLOR           0x14
-#define CLEVO_8291_CMD_ROW             0x16
-#define CLEVO_8291_POWER_OFF           0x01
-#define CLEVO_8291_POWER_ON            0x02
-#define CLEVO_8291_MODE_FLAG           0x08
+#define CLEVO_KEYBOARD_NUM_ROWS        6
+#define CLEVO_KEYBOARD_NUM_COLS        21
+#define CLEVO_KEYBOARD_NUM_LEDS        (CLEVO_KEYBOARD_NUM_ROWS * CLEVO_KEYBOARD_NUM_COLS)
 
-/*---------------------------------------------------------*\
-| ITE 829x keyboard defines (PID 0x8910)                    |
-| 6 bytes with report ID 0xCC, per-key color commands       |
-| Protocol: [0xCC, cmd, d0, d1, d2, d3]                     |
-| LED ID: ((row & 0x07) << 5) | (col & 0x1F)                |
-\*---------------------------------------------------------*/
-#define CLEVO_829X_REPORT_ID           0xCC
-#define CLEVO_829X_REPORT_SIZE         6
-#define CLEVO_829X_NUM_ROWS            6
-#define CLEVO_829X_NUM_COLS            20
-#define CLEVO_829X_NUM_LEDS            (CLEVO_829X_NUM_ROWS * CLEVO_829X_NUM_COLS)
-#define CLEVO_829X_BRIGHTNESS_MAX      0x0A
-#define CLEVO_829X_LED_ID(row, col)    (unsigned char)((((row) & 0x07) << 5) | ((col) & 0x1F))
-
-#define CLEVO_829X_CMD_SET_LED         0x01
-#define CLEVO_829X_CMD_BRIGHTNESS      0x09
-#define CLEVO_829X_CMD_ANIM            0x00
-#define CLEVO_829X_CMD_CLEAR           0x0C
-#define CLEVO_829X_CMD_WAVE_COLOR      0x15
-#define CLEVO_829X_CMD_SNAKE_COLOR     0x16
-#define CLEVO_829X_CMD_SCAN_COLOR      0x17
-#define CLEVO_829X_CMD_RANDOM_COLOR    0x18
-#define CLEVO_829X_COLOR_CUSTOM        0xAA
-#define CLEVO_829X_COLOR_SLOT_BASE     0xA1
-#define CLEVO_829X_PRESET_SLOT_BASE    0x71
-#define CLEVO_829X_CMD_SAVE_BIOS       0x20
-#define CLEVO_829X_CMD_STOP_ANIM       0x03
-
-/*---------------------------------------------------------*\
-| Shared defines                                            |
-\*---------------------------------------------------------*/
 #define CLEVO_KEYBOARD_BRIGHTNESS_MIN  0x00
-#define CLEVO_KEYBOARD_SPEED_MIN       0x00
-#define CLEVO_KEYBOARD_SPEED_MAX       0x0A
-#define CLEVO_KEYBOARD_SPEED_DEFAULT   0x00
+#define CLEVO_KEYBOARD_BRIGHTNESS_MAX  0x32
 
-/*---------------------------------------------------------*\
-| ITE 8291 modes                                            |
-\*---------------------------------------------------------*/
+#define CLEVO_KEYBOARD_SPEED_MIN       0x01
+#define CLEVO_KEYBOARD_SPEED_MAX       0x0A
+
+/*-----------------------------------------------------*\
+| ITE 8291 modes                                        |
+\*-----------------------------------------------------*/
 enum
 {
     CLEVO_KEYBOARD_MODE_DIRECT     = 0x33,
@@ -97,36 +47,9 @@ enum
     CLEVO_KEYBOARD_MODE_SPARK      = 0x11,
 };
 
-/*---------------------------------------------------------*\
-| ITE 829x firmware modes                                   |
-| Two command styles:                                       |
-|   cmd=0x00, d0=mode_id  (animation select)                |
-|   cmd=mode_id, d0=0x00  (standalone effects)              |
-\*---------------------------------------------------------*/
-enum
-{
-    CLEVO_829X_MODE_DIRECT          = 0xFD,
-    CLEVO_829X_MODE_WAVE            = 0xA0,
-    CLEVO_829X_MODE_WAVE_COLOR      = 0xB0,
-    CLEVO_829X_MODE_BREATH          = 0xA1,
-    CLEVO_829X_MODE_BREATH_COLOR    = 0xB1,
-    CLEVO_829X_MODE_BLINK           = 0xA2,
-    CLEVO_829X_MODE_BLINK_COLOR     = 0xB2,
-    CLEVO_829X_MODE_RANDOM          = 0xA3,
-    CLEVO_829X_MODE_RANDOM_COLOR    = 0xA9,
-    CLEVO_829X_MODE_SCAN            = 0xA4,
-    /* Ripple (0x07) requires Insyde BIOS EC config, not supported */
-    CLEVO_829X_MODE_SNAKE           = 0xA6,
-    CLEVO_829X_MODE_SNAKE_COLOR     = 0xB6,
-    CLEVO_829X_MODE_RAINBOW_CYCLE   = 0xA7,
-    CLEVO_829X_MODE_RAINBOW_GRAD    = 0xA8,
-    CLEVO_829X_MODE_FN_COLOR        = 0xAF,
-    CLEVO_829X_MODE_OFF             = 0xFF,
-};
-
-/*---------------------------------------------------------*\
-| Wave/reactive behaviour                                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Wave/reactive behaviour                               |
+\*-----------------------------------------------------*/
 enum
 {
     CLEVO_KEYBOARD_DIRECTION_LEFT      = 0x01,
@@ -144,40 +67,23 @@ enum
 class ClevoKeyboardController
 {
 public:
-    ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info, clevo_keyboard_type kb_type);
+    ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info);
     ~ClevoKeyboardController();
 
-    clevo_keyboard_type GetType();
-    int             GetNumRows();
-    int             GetNumCols();
-    int             GetNumLEDs();
-    unsigned char   GetBrightnessMax();
-
     std::string     GetDeviceLocation();
     std::string     GetSerialString();
     std::string     GetFirmwareVersion();
 
     void            TurnOff();
     void            SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour);
-    void            SetModeColor(unsigned char color_idx, RGBColor color);
-    void            SendColors(const unsigned char* color_data, unsigned char brightness, unsigned char speed);
-    void            SetEffect829x(unsigned char mode_value, const std::vector<RGBColor>& colors, unsigned int direction = 0, unsigned int color_mode = 0);
-    void            SetBrightnessSpeed829x(unsigned char brightness, unsigned char speed);
-    void            SaveToBios829x();
-    void            ClearBiosSave829x();
-    void            StopAnimation829x();
+    void            SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue);
+    void            SendColors(unsigned char* color_data, unsigned char brightness);
 
 private:
-    hid_device*             dev;
-    clevo_keyboard_type     type;
-    std::string             location;
-    unsigned short          version;
-    unsigned char           current_mode_829x = 0xFF;
-    unsigned char           current_brightness_829x = 0xFF;
-    unsigned char           current_speed_829x = 0xFF;
+    hid_device*     dev;
+    std::string     location;
+    unsigned short  version;
 
-    void            WriteControl8291(unsigned char* data);
+    void            WriteControl(unsigned char* data);
     void            WriteRowData(unsigned char* data);
-    void            SendCommand829x(unsigned char cmd, unsigned char d0 = 0, unsigned char d1 = 0, unsigned char d2 = 0, unsigned char d3 = 0);
-    void            SendColorSlot829x(unsigned char cmd, unsigned char slot, RGBColor color);
 };

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -1,11 +1,9 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardControllerDetect.cpp                         |
 |                                                           |
-|   Detector for Clevo per-key RGB keyboard                 |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   Detector for Clevo per-key RGB keyboard (ITE 8291)      |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -24,12 +22,11 @@
 
 /*---------------------------------------------------------*\
 | Clevo Keyboard product IDs                                |
-|   ITE 8291 and ITE 829x per-key RGB keyboard controllers  |
+| These are ITE 8291 per-key RGB keyboard controllers       |
 \*---------------------------------------------------------*/
-#define CLEVO_KEYBOARD_PID_8291                 0x600B
-#define CLEVO_KEYBOARD_PID_829X                 0x8910
+#define CLEVO_KEYBOARD_PID_600B                 0x600B
 
-static DetectedControllers DetectClevoKeyboard(hid_device_info* info, clevo_keyboard_type kb_type)
+DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& /*name*/)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;
@@ -38,7 +35,7 @@ static DetectedControllers DetectClevoKeyboard(hid_device_info* info, clevo_keyb
 
     if(dev)
     {
-        ClevoKeyboardController*     controller     = new ClevoKeyboardController(dev, *info, kb_type);
+        ClevoKeyboardController*     controller     = new ClevoKeyboardController(dev, *info);
         RGBController_ClevoKeyboard* rgb_controller = new RGBController_ClevoKeyboard(controller);
 
         detected_controllers.push_back(rgb_controller);
@@ -47,15 +44,4 @@ static DetectedControllers DetectClevoKeyboard(hid_device_info* info, clevo_keyb
     return(detected_controllers);
 }
 
-DetectedControllers DetectClevoKeyboard8291(hid_device_info* info, const std::string& /*name*/)
-{
-    return(DetectClevoKeyboard(info, CLEVO_KB_ITE8291));
-}
-
-DetectedControllers DetectClevoKeyboard829x(hid_device_info* info, const std::string& /*name*/)
-{
-    return(DetectClevoKeyboard(info, CLEVO_KB_ITE829X));
-}
-
-REGISTER_HID_DETECTOR_PU("Clevo Keyboard (ITE 8291)", DetectClevoKeyboard8291, ITE_VID, CLEVO_KEYBOARD_PID_8291, 0xFF03, 0x01);
-REGISTER_HID_DETECTOR_PU("Clevo Keyboard (ITE 829x)", DetectClevoKeyboard829x, ITE_VID, CLEVO_KEYBOARD_PID_829X, 0xFF89, 0xCC);
+REGISTER_HID_DETECTOR_PU("CLEVO Keyboard", DetectClevoKeyboardControllers, 0x048D, 0x600B, 0xFF03, 0x01);

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.cpp

@@ -1,11 +1,9 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardDevices.cpp                                  |
 |                                                           |
-|   Device list for Clevo per-key RGB keyboards             |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   Device list for Clevo per-key RGB keyboards (ITE 8291)  |
 |                                                           |
 |   Kyle Cascade ([email protected])          21 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -114,48 +112,6 @@ static const std::vector<unsigned int> clevo_tkl_values =
     15,                                                         // Right
 };
 
-/*---------------------------------------------------------*\
-| ITE 829x LED value mapping                                |
-| LED ID = ((row & 7) << 5) | col                           |
-| Row 5 (F-keys) = 0xA0+, Row 4 (numbers) = 0x80+           |
-| Row 3 (QWERTY) = 0x60+, Row 2 (home)    = 0x40+           |
-| Row 1 (Z row)  = 0x20+, Row 0 (mods)    = 0x00+           |
-\*---------------------------------------------------------*/
-static const std::vector<unsigned int> clevo_829x_full_values =
-{
-    /*---------------------------------------------------------*\
-    | Values in FULL layout visual order (same as CM keyboard)  |
-    | LED ID = ((row & 7) << 5) | col                           |
-    | Row counts: 16, 21, 21, 17, 18, 13                        |
-    \*---------------------------------------------------------*/
-/*  ESC   F1    F2    F3    F4    F5    F6    F7    F8    F9    F10   F11   F12   PRSC  SCLK  PSBK */
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0,    0,
-/*  BKTK  1     2     3     4     5     6     7     8     9     0     -     =     BSPC  INS   HOME  PGUP  NMLK  NMDV  NMTM  NMMI */
-    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2D, 0x2E, 0x0E, 0x10, 0x12, 0x30, 0x31, 0x32, 0x33,
-/*  TAB   Q     W     E     R     T     Y     U     I     O     P     [     ]     ANSI\ DEL   END   PGDN  NM7   NM8   NM9   NMPL */
-    0x40, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x0F, 0x11, 0x13, 0x50, 0x51, 0x52, 0x53,
-/*  CPLK  A     S     D     F     G     H     J     K     L     ;     '     #     ENTR  NM4   NM5   NM6        */
-    0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0,    0x6E, 0x70, 0x71, 0x72,
-/*  LSFT  ISO\  Z     X     C     V     B     N     M     ,     .     /     RSFT  ARWU  NM1   NM2   NM3   NMER */
-    0x80, 0,    0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8F, 0x90, 0x91, 0x92, 0x93,
-/*  LCTL  LFNC  LWIN  LALT  SPACE                         RALT  RMNU  RCTL  ARWL  ARDN  ARWR  NM0   NMPD */
-    0xA0, 0xA2, 0xA3, 0xA4, 0xA5,                         0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2,
-};
-
-keyboard_keymap_overlay_values clevo_829x_keyboard_layout
-{
-    KEYBOARD_SIZE_FULL,
-    {
-        clevo_829x_full_values,
-        {
-            /* No regional overlays needed */
-        }
-    },
-    {
-        /* No edit keys needed - all keys defined in full layout */
-    }
-};
-
 keyboard_keymap_overlay_values clevo_keyboard_layout
 {
     KEYBOARD_SIZE_TKL,
@@ -166,9 +122,10 @@ keyboard_keymap_overlay_values clevo_keyboard_layout
         }
     },
     {
-        /*---------------------------------------------------------*\
-        | Edit Keys                                                 |
-        \*---------------------------------------------------------*/
+        /*-------------------------------------------------------------------------------------------------------------------------------------*\
+        | Edit Keys                                                                                                                             |
+        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
+        \*-------------------------------------------------------------------------------------------------------------------------------------*/
 
         /*---------------------------------------------------------*\
         | Remove keys not present on Clevo keyboard                 |

Controllers/ClevoKeyboardController/ClevoKeyboardDevices.h

@@ -1,11 +1,9 @@
 /*---------------------------------------------------------*\
 | ClevoKeyboardDevices.h                                    |
 |                                                           |
-|   Device list for Clevo per-key RGB keyboards             |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   Device list for Clevo per-key RGB keyboards (ITE 8291)  |
 |                                                           |
 |   Kyle Cascade ([email protected])          21 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -16,8 +14,7 @@
 #include <string>
 #include "KeyboardLayoutManager.h"
 
-/*---------------------------------------------------------*\
-| Clevo keyboard layout definitions                         |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Clevo keyboard layout definitions                     |
+\*-----------------------------------------------------*/
 extern keyboard_keymap_overlay_values clevo_keyboard_layout;
-extern keyboard_keymap_overlay_values clevo_829x_keyboard_layout;

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -1,17 +1,14 @@
 /*---------------------------------------------------------*\
 | RGBController_ClevoKeyboard.cpp                           |
 |                                                           |
-|   RGBController for Clevo per-key RGB keyboard            |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   RGBController for Clevo per-key RGB keyboard (ITE 8291) |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <vector>
 #include "RGBController_ClevoKeyboard.h"
 #include "KeyboardLayoutManager.h"
 
@@ -43,306 +40,152 @@ RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController
     Direct.value                    = CLEVO_KEYBOARD_MODE_DIRECT;
     Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
     Direct.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-    Direct.brightness_max           = controller->GetBrightnessMax();
-    Direct.brightness               = controller->GetBrightnessMax();
+    Direct.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Direct.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
     Direct.color_mode               = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
-    /*---------------------------------------------------------*\
-    | ITE 8291 built-in effects (not available on ITE 829x)     |
-    \*---------------------------------------------------------*/
-    if(controller->GetType() == CLEVO_KB_ITE8291)
-    {
-        mode Rainbow;
-        Rainbow.name                    = "Rainbow";
-        Rainbow.value                   = CLEVO_KEYBOARD_MODE_RAINBOW;
-        Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        Rainbow.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
-        Rainbow.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
-        Rainbow.speed                   = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Rainbow.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Rainbow.brightness_max          = controller->GetBrightnessMax();
-        Rainbow.brightness              = controller->GetBrightnessMax();
-        Rainbow.color_mode              = MODE_COLORS_NONE;
-        modes.push_back(Rainbow);
+    mode Rainbow;
+    Rainbow.name                    = "Rainbow";
+    Rainbow.value                   = CLEVO_KEYBOARD_MODE_RAINBOW;
+    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Rainbow.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
+    Rainbow.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
+    Rainbow.speed                   = 0x05;
+    Rainbow.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Rainbow.brightness_max          = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Rainbow.brightness              = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Rainbow.color_mode              = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
 
-        mode Wave;
-        Wave.name                       = "Wave";
-        Wave.value                      = CLEVO_KEYBOARD_MODE_WAVE;
-        Wave.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Wave.speed_min                  = CLEVO_KEYBOARD_SPEED_MAX;
-        Wave.speed_max                  = CLEVO_KEYBOARD_SPEED_MIN;
-        Wave.speed                      = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min             = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max             = controller->GetBrightnessMax();
-        Wave.brightness                 = controller->GetBrightnessMax();
-        Wave.direction                  = MODE_DIRECTION_LEFT;
-        Wave.colors_min                 = 1;
-        Wave.colors_max                 = 1;
-        Wave.colors.resize(1);
-        Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Wave);
+    mode Wave;
+    Wave.name                       = "Wave";
+    Wave.value                      = CLEVO_KEYBOARD_MODE_WAVE;
+    Wave.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Wave.speed_min                  = CLEVO_KEYBOARD_SPEED_MAX;
+    Wave.speed_max                  = CLEVO_KEYBOARD_SPEED_MIN;
+    Wave.speed                      = 0x05;
+    Wave.brightness_min             = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Wave.brightness_max             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.brightness                 = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Wave.direction                  = MODE_DIRECTION_LEFT;
+    Wave.colors_min                 = 1;
+    Wave.colors_max                 = 1;
+    Wave.colors.resize(1);
+    Wave.color_mode                 = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Wave);
 
-        mode Breathing;
-        Breathing.name                  = "Breathing";
-        Breathing.value                 = CLEVO_KEYBOARD_MODE_BREATH;
-        Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Breathing.speed_min             = CLEVO_KEYBOARD_SPEED_MAX;
-        Breathing.speed_max             = CLEVO_KEYBOARD_SPEED_MIN;
-        Breathing.speed                 = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min        = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max        = controller->GetBrightnessMax();
-        Breathing.brightness            = controller->GetBrightnessMax();
-        Breathing.colors_min            = 1;
-        Breathing.colors_max            = 1;
-        Breathing.colors.resize(1);
-        Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Breathing);
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = CLEVO_KEYBOARD_MODE_BREATH;
+    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.speed_min             = CLEVO_KEYBOARD_SPEED_MAX;
+    Breathing.speed_max             = CLEVO_KEYBOARD_SPEED_MIN;
+    Breathing.speed                 = 0x05;
+    Breathing.brightness_min        = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.brightness_max        = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.brightness            = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.colors_min            = 1;
+    Breathing.colors_max            = 1;
+    Breathing.colors.resize(1);
+    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Breathing);
 
-        mode Reactive;
-        Reactive.name                   = "Reactive";
-        Reactive.value                  = CLEVO_KEYBOARD_MODE_REACTIVE;
-        Reactive.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Reactive.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
-        Reactive.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
-        Reactive.speed                  = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Reactive.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Reactive.brightness_max         = controller->GetBrightnessMax();
-        Reactive.brightness             = controller->GetBrightnessMax();
-        Reactive.colors_min             = 1;
-        Reactive.colors_max             = 1;
-        Reactive.colors.resize(1);
-        Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Reactive);
+    mode Reactive;
+    Reactive.name                   = "Reactive";
+    Reactive.value                  = CLEVO_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Reactive.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
+    Reactive.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
+    Reactive.speed                  = 0x05;
+    Reactive.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max         = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.colors_min             = 1;
+    Reactive.colors_max             = 1;
+    Reactive.colors.resize(1);
+    Reactive.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Reactive);
 
-        mode Ripple;
-        Ripple.name                     = "Ripple";
-        Ripple.value                    = CLEVO_KEYBOARD_MODE_RIPPLE;
-        Ripple.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Ripple.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
-        Ripple.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
-        Ripple.speed                    = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Ripple.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Ripple.brightness_max           = controller->GetBrightnessMax();
-        Ripple.brightness               = controller->GetBrightnessMax();
-        Ripple.colors_min               = 1;
-        Ripple.colors_max               = 1;
-        Ripple.colors.resize(1);
-        Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Ripple);
+    mode Ripple;
+    Ripple.name                     = "Ripple";
+    Ripple.value                    = CLEVO_KEYBOARD_MODE_RIPPLE;
+    Ripple.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Ripple.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
+    Ripple.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
+    Ripple.speed                    = 0x05;
+    Ripple.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Ripple.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Ripple.colors_min               = 1;
+    Ripple.colors_max               = 1;
+    Ripple.colors.resize(1);
+    Ripple.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Ripple);
 
-        mode Marquee;
-        Marquee.name                    = "Marquee";
-        Marquee.value                   = CLEVO_KEYBOARD_MODE_MARQUEE;
-        Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Marquee.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
-        Marquee.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
-        Marquee.speed                   = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Marquee.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Marquee.brightness_max          = controller->GetBrightnessMax();
-        Marquee.brightness              = controller->GetBrightnessMax();
-        Marquee.colors_min              = 1;
-        Marquee.colors_max              = 1;
-        Marquee.colors.resize(1);
-        Marquee.color_mode              = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Marquee);
+    mode Marquee;
+    Marquee.name                    = "Marquee";
+    Marquee.value                   = CLEVO_KEYBOARD_MODE_MARQUEE;
+    Marquee.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min               = CLEVO_KEYBOARD_SPEED_MAX;
+    Marquee.speed_max               = CLEVO_KEYBOARD_SPEED_MIN;
+    Marquee.speed                   = 0x05;
+    Marquee.brightness_min          = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Marquee.brightness_max          = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Marquee.brightness              = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Marquee.colors_min              = 1;
+    Marquee.colors_max              = 1;
+    Marquee.colors.resize(1);
+    Marquee.color_mode              = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Marquee);
 
-        mode Raindrop;
-        Raindrop.name                   = "Raindrop";
-        Raindrop.value                  = CLEVO_KEYBOARD_MODE_RAINDROP;
-        Raindrop.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Raindrop.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
-        Raindrop.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
-        Raindrop.speed                  = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Raindrop.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Raindrop.brightness_max         = controller->GetBrightnessMax();
-        Raindrop.brightness             = controller->GetBrightnessMax();
-        Raindrop.colors_min             = 1;
-        Raindrop.colors_max             = 1;
-        Raindrop.colors.resize(1);
-        Raindrop.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Raindrop);
+    mode Raindrop;
+    Raindrop.name                   = "Raindrop";
+    Raindrop.value                  = CLEVO_KEYBOARD_MODE_RAINDROP;
+    Raindrop.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Raindrop.speed_min              = CLEVO_KEYBOARD_SPEED_MAX;
+    Raindrop.speed_max              = CLEVO_KEYBOARD_SPEED_MIN;
+    Raindrop.speed                  = 0x05;
+    Raindrop.brightness_min         = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Raindrop.brightness_max         = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Raindrop.brightness             = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Raindrop.colors_min             = 1;
+    Raindrop.colors_max             = 1;
+    Raindrop.colors.resize(1);
+    Raindrop.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Raindrop);
 
-        mode Aurora;
-        Aurora.name                     = "Aurora";
-        Aurora.value                    = CLEVO_KEYBOARD_MODE_AURORA;
-        Aurora.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Aurora.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
-        Aurora.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
-        Aurora.speed                    = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Aurora.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Aurora.brightness_max           = controller->GetBrightnessMax();
-        Aurora.brightness               = controller->GetBrightnessMax();
-        Aurora.colors_min               = 1;
-        Aurora.colors_max               = 1;
-        Aurora.colors.resize(1);
-        Aurora.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Aurora);
+    mode Aurora;
+    Aurora.name                     = "Aurora";
+    Aurora.value                    = CLEVO_KEYBOARD_MODE_AURORA;
+    Aurora.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Aurora.speed_min                = CLEVO_KEYBOARD_SPEED_MAX;
+    Aurora.speed_max                = CLEVO_KEYBOARD_SPEED_MIN;
+    Aurora.speed                    = 0x05;
+    Aurora.brightness_min           = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Aurora.brightness_max           = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Aurora.brightness               = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Aurora.colors_min               = 1;
+    Aurora.colors_max               = 1;
+    Aurora.colors.resize(1);
+    Aurora.color_mode               = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Aurora);
 
-        mode Spark;
-        Spark.name                      = "Spark";
-        Spark.value                     = CLEVO_KEYBOARD_MODE_SPARK;
-        Spark.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Spark.speed_min                 = CLEVO_KEYBOARD_SPEED_MAX;
-        Spark.speed_max                 = CLEVO_KEYBOARD_SPEED_MIN;
-        Spark.speed                     = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Spark.brightness_min            = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Spark.brightness_max            = controller->GetBrightnessMax();
-        Spark.brightness                = controller->GetBrightnessMax();
-        Spark.colors_min                = 1;
-        Spark.colors_max                = 1;
-        Spark.colors.resize(1);
-        Spark.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Spark);
-    }
-
-    /*---------------------------------------------------------*\
-    | ITE 829x firmware effects                                 |
-    \*---------------------------------------------------------*/
-    if(controller->GetType() == CLEVO_KB_ITE829X)
-    {
-        unsigned char bmax = controller->GetBrightnessMax();
-
-        mode Wave;
-        Wave.name           = "Wave";
-        Wave.value          = CLEVO_829X_MODE_WAVE;
-        Wave.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_DIAG;
-        Wave.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Wave.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Wave.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Wave.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Wave.brightness_max = bmax;
-        Wave.brightness     = bmax;
-        Wave.direction      = MODE_DIRECTION_LEFT;
-        Wave.colors_min     = 1;
-        Wave.colors_max     = 1;
-        Wave.colors.resize(1, ToRGBColor(255, 0, 0));
-        Wave.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Wave);
-
-        mode Breathing;
-        Breathing.name           = "Breathing";
-        Breathing.value          = CLEVO_829X_MODE_BREATH;
-        Breathing.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Breathing.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Breathing.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Breathing.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Breathing.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Breathing.brightness_max = bmax;
-        Breathing.brightness     = bmax;
-        Breathing.colors_min     = 1;
-        Breathing.colors_max     = 1;
-        Breathing.colors.resize(1, ToRGBColor(255, 0, 0));
-        Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Breathing);
-
-        mode Flashing;
-        Flashing.name           = "Flashing";
-        Flashing.value          = CLEVO_829X_MODE_BLINK;
-        Flashing.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Flashing.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Flashing.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Flashing.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Flashing.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Flashing.brightness_max = bmax;
-        Flashing.brightness     = bmax;
-        Flashing.colors_min     = 1;
-        Flashing.colors_max     = 1;
-        Flashing.colors.resize(1, ToRGBColor(255, 0, 0));
-        Flashing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Flashing);
-
-        mode Random;
-        Random.name           = "Random";
-        Random.value          = CLEVO_829X_MODE_RANDOM;
-        Random.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
-        Random.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Random.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Random.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Random.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Random.brightness_max = bmax;
-        Random.brightness     = bmax;
-        Random.colors_min     = 1;
-        Random.colors_max     = 1;
-        Random.colors.resize(1, ToRGBColor(255, 0, 0));
-        Random.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Random);
-
-        mode Scan;
-        Scan.name           = "Scan";
-        Scan.value          = CLEVO_829X_MODE_SCAN;
-        Scan.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        Scan.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Scan.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Scan.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Scan.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Scan.brightness_max = bmax;
-        Scan.brightness     = bmax;
-        Scan.colors_min     = 2;
-        Scan.colors_max     = 2;
-        Scan.colors.resize(2);
-        Scan.colors[0] = ToRGBColor(255, 0, 0);
-        Scan.colors[1] = ToRGBColor(0, 0, 255);
-        Scan.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Scan);
-
-        mode Snake;
-        Snake.name           = "Snake";
-        Snake.value          = CLEVO_829X_MODE_SNAKE;
-        Snake.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_DIAG;
-        Snake.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        Snake.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        Snake.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        Snake.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        Snake.brightness_max = bmax;
-        Snake.brightness     = bmax;
-        Snake.direction      = MODE_DIRECTION_UP_LEFT;
-        Snake.colors_min     = 1;
-        Snake.colors_max     = 1;
-        Snake.colors.resize(1, ToRGBColor(255, 0, 0));
-        Snake.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(Snake);
-
-        mode RainbowCycle;
-        RainbowCycle.name           = "Spectrum Cycle";
-        RainbowCycle.value          = CLEVO_829X_MODE_RAINBOW_CYCLE;
-        RainbowCycle.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-        RainbowCycle.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        RainbowCycle.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        RainbowCycle.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        RainbowCycle.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        RainbowCycle.brightness_max = bmax;
-        RainbowCycle.brightness     = bmax;
-        RainbowCycle.color_mode     = MODE_COLORS_NONE;
-        modes.push_back(RainbowCycle);
-
-        mode RainbowGrad;
-        RainbowGrad.name           = "Rainbow Wave";
-        RainbowGrad.value          = CLEVO_829X_MODE_RAINBOW_GRAD;
-        RainbowGrad.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_DIAG;
-        RainbowGrad.speed_min      = CLEVO_KEYBOARD_SPEED_MIN;
-        RainbowGrad.speed_max      = CLEVO_KEYBOARD_SPEED_MAX;
-        RainbowGrad.speed          = CLEVO_KEYBOARD_SPEED_DEFAULT;
-        RainbowGrad.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        RainbowGrad.brightness_max = bmax;
-        RainbowGrad.brightness     = bmax;
-        RainbowGrad.direction      = MODE_DIRECTION_LEFT;
-        RainbowGrad.color_mode     = MODE_COLORS_NONE;
-        modes.push_back(RainbowGrad);
-
-        mode FnColor;
-        FnColor.name           = "Fn Highlight";
-        FnColor.value          = CLEVO_829X_MODE_FN_COLOR;
-        FnColor.flags          = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-        FnColor.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
-        FnColor.brightness_max = bmax;
-        FnColor.brightness     = bmax;
-        FnColor.colors_min     = 1;
-        FnColor.colors_max     = 1;
-        FnColor.colors.resize(1, ToRGBColor(255, 0, 0));
-        FnColor.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-        modes.push_back(FnColor);
-    }
+    mode Spark;
+    Spark.name                      = "Spark";
+    Spark.value                     = CLEVO_KEYBOARD_MODE_SPARK;
+    Spark.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Spark.speed_min                 = CLEVO_KEYBOARD_SPEED_MAX;
+    Spark.speed_max                 = CLEVO_KEYBOARD_SPEED_MIN;
+    Spark.speed                     = 0x05;
+    Spark.brightness_min            = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
+    Spark.brightness_max            = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Spark.brightness                = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
+    Spark.colors_min                = 1;
+    Spark.colors_max                = 1;
+    Spark.colors.resize(1);
+    Spark.color_mode                = MODE_COLORS_MODE_SPECIFIC;
+    modes.push_back(Spark);
 
     mode Off;
     Off.name                        = "Off";
@@ -364,22 +207,16 @@ RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
 void RGBController_ClevoKeyboard::SetupZones()
 {
     /*---------------------------------------------------------*\
-    | Select layout based on device type                        |
+    | Create keyboard layout using KeyboardLayoutManager        |
     \*---------------------------------------------------------*/
-    bool is_829x = (controller->GetType() == CLEVO_KB_ITE829X);
-
-    keyboard_keymap_overlay_values& layout = is_829x
-        ? clevo_829x_keyboard_layout
-        : clevo_keyboard_layout;
-
     KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ISO_QWERTY,
-                                 layout.base_size,
-                                 layout.key_values);
+                                 clevo_keyboard_layout.base_size,
+                                 clevo_keyboard_layout.key_values);
 
-    new_kb.ChangeKeys(layout);
+    new_kb.ChangeKeys(clevo_keyboard_layout);
 
     /*---------------------------------------------------------*\
-    | Create keyboard zone from KLM                             |
+    | Create a matrix zone for the keyboard                     |
     \*---------------------------------------------------------*/
     zone keyboard_zone;
 
@@ -396,61 +233,52 @@ void RGBController_ClevoKeyboard::SetupZones()
 
     zones.push_back(keyboard_zone);
 
+    /*---------------------------------------------------------*\
+    | Create LEDs from the KeyboardLayoutManager data           |
+    \*---------------------------------------------------------*/
     for(unsigned int led_idx = 0; led_idx < keyboard_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);
+        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
     }
 
     SetupColors();
 
     /*---------------------------------------------------------*\
-    | Build buffer map from LED values to color pointers        |
-    | 829x LED IDs have gaps (stride 32), need larger map       |
+    | Create buffer map to translate OpenRGB LED order to       |
+    | hardware LED order. The hardware expects 126 color values |
+    | indexed by LED position (0-125).                          |
     \*---------------------------------------------------------*/
     null_color = 0x00000000;
-
-    size_t map_size = is_829x
-        ? CLEVO_829X_LED_ID(CLEVO_829X_NUM_ROWS - 1, CLEVO_829X_NUM_COLS - 1) + 1
-        : (size_t)controller->GetNumLEDs();
-
-    buffer_map.resize(map_size, &null_color);
+    buffer_map.resize(CLEVO_KEYBOARD_NUM_LEDS, &null_color);
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        if(leds[led_idx].value < buffer_map.size())
-        {
-            buffer_map[leds[led_idx].value] = &colors[led_idx];
-        }
+        buffer_map[led_values[led_idx]] = &colors[led_idx];
     }
 }
 
 void RGBController_ClevoKeyboard::DeviceUpdateLEDs()
 {
-    int  num_rows = controller->GetNumRows();
-    int  num_cols = controller->GetNumCols();
-    bool is_829x  = (controller->GetType() == CLEVO_KB_ITE829X);
+    /*---------------------------------------------------------*\
+    | Build color data array using buffer map and send to device|
+    | The buffer_map translates from hardware LED index to the  |
+    | corresponding color pointer for that LED.                 |
+    \*---------------------------------------------------------*/
+    unsigned char color_data[CLEVO_KEYBOARD_NUM_LEDS * 3];
 
-    std::vector<unsigned char> color_data(num_rows * num_cols * 3);
-
-    for(int row = 0; row < num_rows; row++)
+    for(int i = 0; i < CLEVO_KEYBOARD_NUM_LEDS; i++)
     {
-        for(int col = 0; col < num_cols; col++)
-        {
-            int seq    = row * num_cols + col;
-            int led_id = is_829x ? CLEVO_829X_LED_ID(row, col) : seq;
-
-            color_data[seq * 3 + 0] = RGBGetRValue(*buffer_map[led_id]);
-            color_data[seq * 3 + 1] = RGBGetGValue(*buffer_map[led_id]);
-            color_data[seq * 3 + 2] = RGBGetBValue(*buffer_map[led_id]);
-        }
+        color_data[i * 3 + 0] = RGBGetRValue(*buffer_map[i]);
+        color_data[i * 3 + 1] = RGBGetGValue(*buffer_map[i]);
+        color_data[i * 3 + 2] = RGBGetBValue(*buffer_map[i]);
     }
 
-    controller->SendColors(color_data.data(), modes[active_mode].brightness, modes[active_mode].speed);
+    controller->SendColors(color_data, modes[active_mode].brightness);
 }
 
 void RGBController_ClevoKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
@@ -476,16 +304,6 @@ void RGBController_ClevoKeyboard::DeviceUpdateMode()
         return;
     }
 
-    /*---------------------------------------------------------*\
-    | Handle ITE 829x firmware effects                          |
-    \*---------------------------------------------------------*/
-    if(controller->GetType() == CLEVO_KB_ITE829X && mode_value != CLEVO_KEYBOARD_MODE_DIRECT)
-    {
-        controller->SetEffect829x(mode_value, modes[active_mode].colors, modes[active_mode].direction, modes[active_mode].color_mode);
-        controller->SetBrightnessSpeed829x(modes[active_mode].brightness, modes[active_mode].speed);
-        return;
-    }
-
     /*---------------------------------------------------------*\
     | Handle Direct (per-key) mode                              |
     \*---------------------------------------------------------*/
@@ -500,26 +318,41 @@ void RGBController_ClevoKeyboard::DeviceUpdateMode()
     \*---------------------------------------------------------*/
     unsigned char brightness = modes[active_mode].brightness;
     unsigned char speed      = modes[active_mode].speed;
-    unsigned char behaviour  = (mode_value == CLEVO_KEYBOARD_MODE_WAVE)
-                             ? modes[active_mode].direction + 1
-                             : 0x00;
+    unsigned char behaviour  = 0x00;
+
+    /*---------------------------------------------------------*\
+    | Set direction for wave mode                               |
+    \*---------------------------------------------------------*/
+    if(mode_value == CLEVO_KEYBOARD_MODE_WAVE)
+    {
+        switch(modes[active_mode].direction)
+        {
+            case MODE_DIRECTION_LEFT:
+                behaviour = CLEVO_KEYBOARD_DIRECTION_LEFT;
+                break;
+            case MODE_DIRECTION_RIGHT:
+                behaviour = CLEVO_KEYBOARD_DIRECTION_RIGHT;
+                break;
+            case MODE_DIRECTION_UP:
+                behaviour = CLEVO_KEYBOARD_DIRECTION_UP;
+                break;
+            case MODE_DIRECTION_DOWN:
+                behaviour = CLEVO_KEYBOARD_DIRECTION_DOWN;
+                break;
+        }
+    }
 
     /*---------------------------------------------------------*\
     | Set mode color if applicable                              |
     \*---------------------------------------------------------*/
     if(modes[active_mode].colors.size() > 0)
     {
-        controller->SetModeColor(1, modes[active_mode].colors[0]);
+        unsigned char red   = RGBGetRValue(modes[active_mode].colors[0]);
+        unsigned char green = RGBGetGValue(modes[active_mode].colors[0]);
+        unsigned char blue  = RGBGetBValue(modes[active_mode].colors[0]);
+
+        controller->SetModeColor(1, red, green, blue);
     }
 
     controller->SetMode(mode_value, brightness, speed, behaviour);
 }
-
-void RGBController_ClevoKeyboard::DeviceSaveMode()
-{
-    if(controller->GetType() == CLEVO_KB_ITE829X)
-    {
-        DeviceUpdateMode();
-        controller->SaveToBios829x();
-    }
-}

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.h

@@ -1,11 +1,9 @@
 /*---------------------------------------------------------*\
 | RGBController_ClevoKeyboard.h                             |
 |                                                           |
-|   RGBController for Clevo per-key RGB keyboard            |
-|   Supports ITE 8291 (PID 0x600B) and ITE 829x (0x8910)    |
+|   RGBController for Clevo per-key RGB keyboard (ITE 8291) |
 |                                                           |
 |   Kyle Cascade ([email protected])          16 Jan 2026 |
-|   Valentin Lobstein ([email protected]) 27 Mar 2026 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
@@ -20,7 +18,7 @@
 class RGBController_ClevoKeyboard : public RGBController
 {
 public:
-    explicit RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr);
+    RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr);
     ~RGBController_ClevoKeyboard();
 
     void        SetupZones();
@@ -30,10 +28,10 @@ public:
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
-    void        DeviceSaveMode();
 
 private:
     ClevoKeyboardController*        controller;
     std::vector<RGBColor*>          buffer_map;
+    std::vector<unsigned int>       led_values;
     RGBColor                        null_color;
 };

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -45,8 +45,7 @@ void ColorfulGPUController::SetDirect(RGBColor color)
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
 
-    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV
-    || this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV)
+    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
     {
         uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
         for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -51,7 +51,6 @@ DetectedControllers DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV,     0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
@@ -72,17 +71,13 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti SUPER Advanced OC-V", Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti SUPER Ultra W",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070TIS_DEV,       COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070TI_SUPER_ULTRA_W,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 SUPER Ultra W OC",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070S_DEV,         COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_SUPER_ULTRA_W_OC,       0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Vulcan OC-V",            DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_VULCAN_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070_ULTRAW_OCV,             0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 SUPER Ultra W OC-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4070S_DEV,         COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4070S_ULTRAW_OCV,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV,             0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Neptune OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_NEPTUNE_OCV,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC,              0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC_2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC_2,      0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ti Ultra W OC",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070TI_ULTRAW_OC,            0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);

Controllers/CoolerMasterController/CMGD160Controller/RGBController_CMGD160Controller.cpp

@@ -159,7 +159,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Front LED " + std::to_string(i + 1);
-        l.value         = i;
+
         leds.push_back(l);
     }
 
@@ -175,7 +175,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Back LED " + std::to_string(i + 1);
-        l.value         = i;
+
         leds.push_back(l);
     }
 

Controllers/CoolerMasterController/CMMM711Controller/RGBController_CMMM711Controller.cpp

@@ -146,12 +146,10 @@ void RGBController_CMMM711Controller::Init_Controller()
 
     led wheel_led;
     wheel_led.name          = "Scroll Wheel LED";
-    wheel_led.value         = 0;
     leds.push_back(wheel_led);
 
     led logo_led;
     logo_led.name           = "Logo LED";
-    logo_led.value          = 1;
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMM712Controller/RGBController_CMMM712Controller.cpp

@@ -139,7 +139,6 @@ void RGBController_CMMM712Controller::Init_Controller()
 
     led logo_led;
     logo_led.name           = "Logo LED";
-    logo_led.value          = 0;
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMMController/RGBController_CMMMController.cpp

@@ -183,28 +183,24 @@ void RGBController_CMMMController::Init_Controller()
     mouse_zone.leds_count   = leds_count;
     zones.push_back(mouse_zone);
 
-    int value               = 0;
     uint16_t pid            = controller->GetProductID();
 
     led wheel_led;
     wheel_led.name          = "Scroll Wheel";
-    wheel_led.value         = value;
-    leds.push_back(wheel_led);
 
-    value++;
+    leds.push_back(wheel_led);
 
     if(pid == 0x0065 || pid == 0x0097)
     {
         led buttons_led;
         buttons_led.name        = "Buttons";
-        buttons_led.value       = value;
+
         leds.push_back(buttons_led);
-        value++;
     }
 
     led logo_led;
     logo_led.name           = "Logo";
-    logo_led.value          = value;
+
     leds.push_back(logo_led);
 }
 

Controllers/CoolerMasterController/CMMonitorController/RGBController_CMMonitorController.cpp

@@ -162,7 +162,7 @@ void RGBController_CMMonitorController::SetupZones()
     {
         led l;
         l.name          = std::to_string(i + 1);
-        l.value         = i;
+
         leds.push_back(l);
     }
 

Controllers/CoolerMasterController/CMR6000Controller/RGBController_CMR6000Controller.cpp

@@ -169,7 +169,6 @@ void RGBController_CMR6000Controller::SetupZones()
 
     led GP_led;
     GP_led.name         = "Logo";
-    GP_led.value        = 0;
     leds.push_back(GP_led);
 
     SetupColors();

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.cpp

@@ -13,6 +13,11 @@
 #include "CMSmallARGBController.h"
 #include "StringUtils.h"
 
+cm_small_argb_headers cm_small_argb_header_data[1] =
+{
+    { "CM Small ARGB",  0x01, true,  12 }
+};
+
 CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path)
 {
     dev                     = dev_handle;
@@ -87,24 +92,6 @@ std::string CMSmallARGBController::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-std::string CMSmallARGBController::GetVersion()
-{
-    /*-----------------------------------------------------*\
-    | This device uses the serial value to determine the    |
-    | version.  It does not report a proper unique serial.  |
-    \*-----------------------------------------------------*/
-    std::string serial_string = GetSerial();
-
-    if(serial_string == CM_SMALL_ARGB_FW0012)
-    {
-        return("0012");
-    }
-    else
-    {
-        return("Unsupported");
-    }
-}
-
 std::string CMSmallARGBController::GetLocation()
 {
     return("HID: " + location);
@@ -135,11 +122,6 @@ unsigned char CMSmallARGBController::GetLedSpeed()
     return(current_speed);
 }
 
-unsigned char CMSmallARGBController::GetBrightness()
-{
-    return(current_brightness);
-}
-
 bool CMSmallARGBController::GetRandomColours()
 {
     return(bool_random);
@@ -235,9 +217,9 @@ void CMSmallARGBController::SendUpdate()
 
     hid_write(dev, buffer, buffer_size);
 
-    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0B;
-    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = 0x02;
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = 0x01;
+    buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0b;
+    buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = (false) ? 0x01 : 0x02; //This controls custom mode TODO
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[0].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.h

@@ -39,6 +39,16 @@ enum
     CM_SMALL_ARGB_BLUE_BYTE             = 11,
 };
 
+struct cm_small_argb_headers
+{
+    const char*     name;
+    unsigned char   header;
+    bool            digital;
+    unsigned int    count;
+};
+
+extern cm_small_argb_headers cm_small_argb_header_data[1];
+
 enum
 {
     CM_SMALL_ARGB_MODE_SPECTRUM       = 0x01,   //Spectrum Mode
@@ -61,8 +71,6 @@ enum
     CM_SMALL_ARGB_SPEED_FASTEST       = 0x04,   // Fastest speed
 };
 
-#define CM_SMALL_ARGB_FW0012            std::string("A202104052336")
-
 class CMSmallARGBController
 {
 public:
@@ -72,14 +80,12 @@ public:
     std::string         GetDeviceName();
     std::string         GetSerial();
     std::string         GetLocation();
-    std::string         GetVersion();
 
     unsigned char       GetMode();
     unsigned char       GetLedRed();
     unsigned char       GetLedGreen();
     unsigned char       GetLedBlue();
     unsigned char       GetLedSpeed();
-    unsigned char       GetBrightness();
     bool                GetRandomColours();
 
     void                SetLedCount(int zone, int led_count);

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -27,68 +27,22 @@
 RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController* controller_ptr)
 {
     controller                  = controller_ptr;
+    unsigned char speed         = controller->GetLedSpeed();
 
-    name                        = controller->GetDeviceName();
+    name                        = cm_small_argb_header_data[0].name;
     vendor                      = "Cooler Master";
     type                        = DEVICE_TYPE_LEDSTRIP;
-    description                 = "Cooler Master Small ARGB Controller Device";
-    version                     = controller->GetVersion();
+    description                 = controller->GetDeviceName();
+    version                     = "2.0 for FW0012";
     serial                      = controller->GetSerial();
     location                    = controller->GetLocation();
 
-    SetupModes();
-    SetupZones();
-
-    /*-----------------------------------------------------*\
-    | Initialize the active mode to the device's current    |
-    | mode                                                  |
-    \*-----------------------------------------------------*/
-    int             device_mode         = controller->GetMode();
-
-    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-    {
-        if(modes[mode_idx].value == device_mode)
-        {
-            active_mode = (int)mode_idx;
-
-            if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
-            {
-                modes[mode_idx].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
-            {
-                modes[mode_idx].speed = controller->GetLedSpeed();
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
-            {
-                modes[mode_idx].brightness = controller->GetBrightness();
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
-            {
-                modes[mode_idx].color_mode = controller->GetRandomColours() ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
-            }
-
-            break;
-        }
-    }
-}
-
-void RGBController_CMSmallARGBController::SetupModes()
-{
-    /*-----------------------------------------------------*\
-    | The Small ARGB only supports Direct mode from FW0012  |
-    | onwards, older firmware does not accept direct mode   |
-    | packets                                               |
-    \*-----------------------------------------------------*/
-    //if(serial >= CM_SMALL_ARGB_FW0012)
+    if(serial >= CM_SMALL_ARGB_FW0012)
     {
         mode Direct;
         Direct.name             = "Direct";
         Direct.value            = CM_SMALL_ARGB_MODE_DIRECT;
-        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
+        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
         Direct.brightness_min   = 0;
         Direct.brightness_max   = CM_SMALL_ARGB_BRIGHTNESS_MAX;
         Direct.brightness       = CM_SMALL_ARGB_BRIGHTNESS_MAX;
@@ -115,7 +69,7 @@ void RGBController_CMSmallARGBController::SetupModes()
     Reload.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Reload.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Reload.color_mode           = MODE_COLORS_RANDOM;
-    Reload.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
+    Reload.speed                = speed;
     modes.push_back(Reload);
 
     mode Recoil;
@@ -131,7 +85,7 @@ void RGBController_CMSmallARGBController::SetupModes()
     Recoil.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Recoil.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Recoil.color_mode           = MODE_COLORS_RANDOM;
-    Recoil.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
+    Recoil.speed                = speed;
     modes.push_back(Recoil);
 
     mode Breathing;
@@ -147,7 +101,7 @@ void RGBController_CMSmallARGBController::SetupModes()
     Breathing.speed_min         = CM_SMALL_ARGB_SPEED_SLOWEST;
     Breathing.speed_max         = CM_SMALL_ARGB_SPEED_FASTEST;
     Breathing.color_mode        = MODE_COLORS_RANDOM;
-    Breathing.speed             = CM_SMALL_ARGB_SPEED_NORMAL;
+    Breathing.speed             = speed;
     modes.push_back(Breathing);
 
     mode Refill;
@@ -163,7 +117,7 @@ void RGBController_CMSmallARGBController::SetupModes()
     Refill.speed_min            = CM_SMALL_ARGB_SPEED_SLOWEST;
     Refill.speed_max            = CM_SMALL_ARGB_SPEED_FASTEST;
     Refill.color_mode           = MODE_COLORS_RANDOM;
-    Refill.speed                = CM_SMALL_ARGB_SPEED_NORMAL;
+    Refill.speed                = speed;
     modes.push_back(Refill);
 
     mode Demo;
@@ -176,7 +130,7 @@ void RGBController_CMSmallARGBController::SetupModes()
     Demo.speed_min              = CM_SMALL_ARGB_SPEED_SLOWEST;
     Demo.speed_max              = CM_SMALL_ARGB_SPEED_FASTEST;
     Demo.color_mode             = MODE_COLORS_NONE;
-    Demo.speed                  = CM_SMALL_ARGB_SPEED_NORMAL;
+    Demo.speed                  = speed;
     modes.push_back(Demo);
 
     mode Spectrum;
@@ -189,19 +143,39 @@ void RGBController_CMSmallARGBController::SetupModes()
     Spectrum.speed_min          = CM_SMALL_ARGB_SPEED_SLOWEST;
     Spectrum.speed_max          = CM_SMALL_ARGB_SPEED_FASTEST;
     Spectrum.color_mode         = MODE_COLORS_NONE;
-    Spectrum.speed              = CM_SMALL_ARGB_SPEED_NORMAL;
+    Spectrum.speed              = speed;
     modes.push_back(Spectrum);
 
-    /*-----------------------------------------------------*\
-    | Define Passthrough mode as requiring the entire       |
-    | device, it hands control over to the motherboard      |
-    \*-----------------------------------------------------*/
     mode PassThru;
     PassThru.name               = "Pass Thru";
     PassThru.value              = CM_SMALL_ARGB_MODE_PASSTHRU;
-    PassThru.flags              = MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
     PassThru.color_mode         = MODE_COLORS_NONE;
     modes.push_back(PassThru);
+
+    SetupZones();
+
+    int temp_mode               = controller->GetMode();
+
+    for(int mode_idx = 0; mode_idx < (int)modes.size() ; mode_idx++)
+    {
+        if(temp_mode == modes[mode_idx].value)
+        {
+            active_mode         = mode_idx;
+            break;
+        }
+    }
+
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
+    }
+
+    modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = controller->GetLedSpeed();
+    }
 }
 
 RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
@@ -274,9 +248,7 @@ void RGBController_CMSmallARGBController::SetupZones()
         {
             led new_led;
             new_led.name                            = zones[zone_idx].name;
-            new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(lp_idx + 1));
-            new_led.value                           = (unsigned int)zone_idx;
+            new_led.name.append(", LED " + std::to_string(lp_idx));
 
             leds.push_back(new_led);
         }
@@ -289,7 +261,7 @@ void RGBController_CMSmallARGBController::DeviceConfigureZone(int zone_idx)
 {
     if((size_t)zone_idx < zones.size())
     {
-        controller->SetLedCount(1, zones[zone_idx].leds_count);
+        controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
 
         SetupZones();
     }
@@ -305,79 +277,37 @@ void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
 
 void RGBController_CMSmallARGBController::DeviceUpdateZoneLEDs(int zone)
 {
-    /*-----------------------------------------------------*\
-    | Only send direct packets while Direct mode is active. |
-    | Direct mode is only offered on FW0012 and newer, so   |
-    | older firmware will never send direct packets here    |
-    \*-----------------------------------------------------*/
-    if(modes[active_mode].value != CM_SMALL_ARGB_MODE_DIRECT)
+    if(serial >= CM_SMALL_ARGB_FW0012)
     {
-        return;
+        controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
     }
-
-    controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
 }
 
 void RGBController_CMSmallARGBController::DeviceUpdateSingleLED(int led)
 {
-    /*-----------------------------------------------------*\
-    | Map the LED back to its zone and update that zone     |
-    \*-----------------------------------------------------*/
-    unsigned int zone_idx = leds[led].value;
-
-    UpdateZoneLEDs(zone_idx);
+    DeviceUpdateZoneLEDs(led);
 }
 
 void RGBController_CMSmallARGBController::SetCustomMode()
 {
-    /*-----------------------------------------------------*\
-    | Direct mode is only supported on FW0012 and newer     |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | The small ARGB may not support "Direct" mode      |
+    |   in which case this will select "Pass Thru"      |
+    \*-------------------------------------------------*/
     if(serial >= CM_SMALL_ARGB_FW0012)
     {
-        /*-------------------------------------------------*\
-        | Search the mode list for Direct mode              |
-        \*-------------------------------------------------*/
-        for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-        {
-            if(modes[mode_idx].name == "Direct")
-            {
-                SetActiveMode((int)mode_idx);
-                break;
-            }
-        }
+        active_mode = 0;
     }
     else
     {
-        /*-------------------------------------------------*\
-        | Direct mode is unsupported by the firmware,       |
-        | fall back to Pass Thru                            |
-        \*-------------------------------------------------*/
-        for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
-        {
-            if(modes[mode_idx].value == CM_SMALL_ARGB_MODE_PASSTHRU)
-            {
-                SetActiveMode((int)mode_idx);
-                break;
-            }
-        }
+        active_mode = 7;
     }
 }
 
 void RGBController_CMSmallARGBController::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------*\
-    | Set up mode parameters                                |
-    \*-----------------------------------------------------*/
-    bool            random_colours  = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    RGBColor        colour          = 0;
-    unsigned int    speed           = modes[active_mode].speed;
-    unsigned int    brightness      = modes[active_mode].brightness;
+    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
 
-    if(modes[active_mode].colors.size() > 0)
-    {
-        colour                      = modes[active_mode].colors[0];
-    }
-
-    controller->SetMode(modes[active_mode].value, speed, brightness, colour, random_colours);
+    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours);
 }

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.h

@@ -18,6 +18,7 @@
 #define CM_SMALL_ARGB_MIN_LEDS          4
 #define CM_SMALL_ARGB_MAX_LEDS          48
 #define CM_SMALL_ARGB_BRIGHTNESS_MAX    0xFF
+#define CM_SMALL_ARGB_FW0012            "A202104052336"
 
 class RGBController_CMSmallARGBController : public RGBController
 {
@@ -25,9 +26,7 @@ public:
     RGBController_CMSmallARGBController(CMSmallARGBController* controller_ptr);
     ~RGBController_CMSmallARGBController();
 
-    void        SetupModes();
     void        SetupZones();
-
     void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
@@ -36,7 +35,9 @@ public:
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
-
 private:
+    void        Init_Controller();
+    int         GetDeviceMode();
+
     CMSmallARGBController*  controller;
 };