Sanitize filenames from clients in NetworkServer

.github/FUNDING.yml

@@ -1,6 +1,6 @@
 # These are supported funding model platforms
 
-github: CalcProgrammer1
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: CalcProgrammer1
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

.github/workflows/issue_opened.yml

@@ -1,21 +0,0 @@
-name: Issue Opened
-
-on:
-  issues:
-    types: [opened,reopened]
-
-jobs:
-  issue_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Greeting
-        run: gh issue comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            For any new issue please refer to https://gitlab.com/CalcProgrammer1/OpenRGB/-/issues

.github/workflows/pr_opened.yml

@@ -1,21 +0,0 @@
-name: PR Opened
-
-on:
-  pull_request:
-    types: [opened,reopened]
-
-jobs:
-  pr_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Greeting
-        run: gh pr comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.pull_request.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            Please fork https://gitlab.com/CalcProgrammer1/OpenRGB/ and raise the appropriate merge request on Gitlab.

.gitignore

@@ -8,9 +8,6 @@ OpenRGB-x86_64.AppImage
 60-openrgb.rules
 debian/changelog
 fedora/OpenRGB.spec
-OpenRGB_resource.rc
-OpenRGB Windows 32-bit/
-OpenRGB Windows 64-bit/
 
 # Directories
 .build/
@@ -31,7 +28,6 @@ Build/
 .qmake.stash
 .vscode
 .vs
-.idea
 
 # Generic Files
 .DS_Store

.gitlab/CODEOWNERS

@@ -22,12 +22,13 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDRAMController/
+/Controllers/CorsairDominatorPlatinumController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
+/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/
@@ -42,7 +43,6 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EVGAGP102GPUController/
 /Controllers/EVGAPascalGPUController/
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
-/Controllers/EVGASMBusController/                           @balika011
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
 /Controllers/EspurnaController/
@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/NZXTHue2Controller/
 /Controllers/NZXTHuePlusController/
 /Controllers/NZXTKrakenController/
+/Controllers/OpenRazerController/
 /Controllers/PNYGPUController/
 /Controllers/PatriotViperController/
 /Controllers/PhilipsHueController/

.gitlab/issue_templates/New Device.md

@@ -23,9 +23,9 @@ Please add a link to the manufacturer's product page beneath this line
 ~"DeviceType::IDK" <!-- I Don't know -->
 ~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
 ~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
-~"DeviceType::GPU::NVidia" <!-- The device is a Nvidia GPU -->
+~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
 ~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
-~"DeviceType::WMI"  <!-- The device is controlled through Windows Management Instrumentation -->
+~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->
 
 <!-- Please delete any lines that are not relevant -->
 

.gitlab/merge_request_templates/New Device.md

@@ -10,7 +10,6 @@ Please put "Initial commit for" name of the product, including manufacturer abov
 <!-- For admin purposes: Please leave this section as is -->
 
 # Checklist for Accepting a Merge Request for a New Device
-- [ ] The source branch of the merge request is not protected (`master` is protected by default when creating a fork, so it is recommended to not use it as your source).
 - [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
 - [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
 - [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).

AutoStart/AutoStart-FreeBSD.cpp

@@ -1,20 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.cpp                                     |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+#include "AutoStart-FreeBSD.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 #include <fstream>
 #include <iostream>
 #include <limits.h>
 #include <unistd.h>
 #include <sstream>
-#include "AutoStart-FreeBSD.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| FreeBSD AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -26,21 +23,21 @@ bool AutoStart::DisableAutoStart()
     std::error_code autostart_file_remove_errcode;
     bool            success                         = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
         if(!filesystem::exists(autostart_file))
         {
             success = true;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
         else
         {
             success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +50,7 @@ bool AutoStart::DisableAutoStart()
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -63,38 +60,39 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
     bool        success                             = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
 
-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
         if(!autostart_file_stream)
         {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
             success = false;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
         else
         {
+            //autostart_file_stream << desktop_file;
             autostart_file_stream.close();
             success = !autostart_file_stream.fail();
 
             if (!success)
             {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
             }
         }
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -102,9 +100,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         return(filesystem::exists(autostart_file));
@@ -117,9 +115,9 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
     char exepath[ PATH_MAX ];
 
     ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
@@ -133,16 +131,16 @@ void AutoStart::InitAutoStart(std::string name)
 
     autostart_name = name;
 
-    /*-----------------------------------------------------*\
-    | Get home and config paths                             |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
     const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
     const char *home = getenv("HOME");
 
-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
     if(xdg_config_home != NULL)
     {
         autostart_dir = xdg_config_home;
@@ -154,9 +152,9 @@ void AutoStart::InitAutoStart(std::string name)
         autostart_dir = autostart_dir + "/.config/autostart/";
     }
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_dir != "")
     {
         std::error_code ec;

AutoStart/AutoStart-FreeBSD.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.h                                       |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Linux.cpp

@@ -1,21 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.cpp                                       |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <fstream>
-#include <iostream>
-#include <sstream>
-#include <unistd.h>
-#include <linux/limits.h>
 #include "AutoStart-Linux.h"
 #include "LogManager.h"
 #include "filesystem.h"
 
+#include <fstream>
+#include <iostream>
+#include <unistd.h>
+#include <linux/limits.h>
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
 AutoStart::AutoStart(std::string name)
 {
     InitAutoStart(name);
@@ -26,21 +22,21 @@ bool AutoStart::DisableAutoStart()
     std::error_code autostart_file_remove_errcode;
     bool            success                         = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
         if(!filesystem::exists(autostart_file))
         {
             success = true;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
         else
         {
             success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +49,7 @@ bool AutoStart::DisableAutoStart()
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -63,25 +59,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
     bool        success                             = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         std::string     desktop_file                = GenerateDesktopFile(autostart_info);
         std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
 
-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
         if(!autostart_file_stream)
         {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
             success = false;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
         else
         {
             autostart_file_stream << desktop_file;
@@ -90,13 +86,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
             if (!success)
             {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
             }
         }
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -104,9 +100,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         return(filesystem::exists(autostart_file));
@@ -119,27 +115,27 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
     char exepath[ PATH_MAX ];
 
     ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
-
+    
     return(std::string(exepath, (count > 0) ? count : 0));
 }
 
-/*---------------------------------------------------------*\
-| Linux AutoStart Implementation                            |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
 
 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
-    /*-----------------------------------------------------*\
-    | Generate a .desktop file from the AutoStart           |
-    | parameters                                            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Generate a .desktop file from the AutoStart       |
+    | parameters                                        |
+    \*-------------------------------------------------*/
     std::stringstream fileContents;
 
     fileContents << "[Desktop Entry]"                               << std::endl;
@@ -151,9 +147,9 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     fileContents << "Terminal=false"                                << std::endl;
     fileContents << "Type=Application"                              << std::endl;
 
-    /*-----------------------------------------------------*\
-    | Add the executable path and arguments                 |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Add the executable path and arguments             |
+    \*-------------------------------------------------*/
     fileContents << "Exec="              << autostart_info.path;
 
     if (autostart_info.args != "")
@@ -162,7 +158,7 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     }
 
     fileContents << std::endl;
-
+    
     return(fileContents.str());
 }
 
@@ -172,16 +168,16 @@ void AutoStart::InitAutoStart(std::string name)
 
     autostart_name = name;
 
-    /*-----------------------------------------------------*\
-    | Get home and config paths                             |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
     const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
     const char *home = getenv("HOME");
 
-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
     if(xdg_config_home != NULL)
     {
         autostart_dir = xdg_config_home;
@@ -193,15 +189,15 @@ void AutoStart::InitAutoStart(std::string name)
         autostart_dir = autostart_dir + "/.config/autostart/";
     }
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_dir != "")
     {
         std::error_code ec;
 
         bool success = true;
-
+        
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-Linux.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.h                                         |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-MacOS.cpp

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.cpp                                       |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 #include <fstream>
 #include <sstream>
 #include <iostream>
 #include <unistd.h>
+
 #include <mach-o/dyld.h>
-#include "AutoStart-MacOS.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -26,21 +24,21 @@ bool AutoStart::DisableAutoStart()
     std::error_code autostart_file_remove_errcode;
     bool            success                         = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
         if(!filesystem::exists(autostart_file))
         {
             success = true;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
         else
         {
             success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +51,7 @@ bool AutoStart::DisableAutoStart()
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -63,25 +61,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
     bool        success                             = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         std::string     desktop_file                = GenerateLaunchAgentFile(autostart_info);
         std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);
 
-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
         if(!autostart_file_stream)
         {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
             success = false;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
         else
         {
             autostart_file_stream << desktop_file;
@@ -90,13 +88,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
             if (!success)
             {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
             }
         }
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -104,9 +102,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         return(filesystem::exists(autostart_file));
@@ -119,9 +117,9 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
     char     exepath[ PATH_MAX ];
     uint32_t exesize = PATH_MAX;
 
@@ -132,17 +130,17 @@ std::string AutoStart::GetExePath()
     return("");
 }
 
-/*---------------------------------------------------------*\
-| MacOS AutoStart Implementation                            |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
 
 std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 {
-    /*-----------------------------------------------------*\
-    | Generate a .plist file from the AutoStart             |
-    | parameters                                            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Generate a .plist file from the AutoStart         |
+    | parameters                                        |
+    \*-------------------------------------------------*/
     std::stringstream fileContents;
 
     fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
@@ -154,7 +152,7 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
     fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
     fileContents << "    <array>"                                                                                                   << std::endl;
     fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
-
+    
     if(autostart_info.args != "")
     {
         std::istringstream arg_parser(autostart_info.args);
@@ -165,12 +163,12 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
             fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
         }
     }
-
+    
     fileContents << "    </array>"                                                                                                  << std::endl;
     fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
     fileContents << "</dict>"                                                                                                       << std::endl;
     fileContents << "</plist>"                                                                                                      << std::endl;
-
+    
     return(fileContents.str());
 }
 
@@ -180,22 +178,22 @@ void AutoStart::InitAutoStart(std::string name)
 
     autostart_name = name;
 
-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
     autostart_dir = getenv("HOME");
     autostart_dir = autostart_dir + "/Library/LaunchAgents/";
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_dir != "")
     {
         std::error_code ec;
 
         bool success = true;
-
+        
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-MacOS.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.h                                         |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Windows.cpp

@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.cpp                                     |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <fstream>
-#include <iostream>
-#include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
 #include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+
 #include "windows.h"
+#include <shlobj.h>
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -25,34 +23,34 @@ bool AutoStart::DisableAutoStart()
     std::error_code autostart_file_remove_errcode;
     bool success                                    = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
         if(!filesystem::exists(autostart_file))
         {
             success = true;
         }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
         else
         {
             success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
-
+            
             if(!success)
             {
-                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
+                LOG_ERROR("An error occurred removing the auto start file.");
             }
         }
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return(success);
@@ -62,9 +60,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
     bool success                                    = false;
 
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         bool            weInitialised               = false;
@@ -79,9 +77,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
         result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
 
-        /*-------------------------------------------------*\
-        | If not initialized, initialize                    |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If not initialized, initialize                |
+        \*---------------------------------------------*/
         if(result == CO_E_NOTINITIALIZED)
         {
             weInitialised                           = true;
@@ -89,21 +87,21 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
             result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
         }
 
-        /*-------------------------------------------------*\
-        | If successfully initialized, save a shortcut      |
-        | from the AutoStart parameters                     |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If successfully initialized, save a shortcut  |
+        | from the AutoStart parameters                 |
+        \*---------------------------------------------*/
         if(SUCCEEDED(result))
         {
             shellLink->SetPath(exepathw.c_str());
             shellLink->SetArguments(argumentsw.c_str());
             shellLink->SetDescription(descriptionw.c_str());
             shellLink->SetIconLocation(iconw.c_str(), 0);
-
+            
             IPersistFile* persistFile;
-
+            
             result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
-
+            
             if(SUCCEEDED(result))
             {
                 result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
@@ -114,9 +112,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
             shellLink->Release();
         }
 
-        /*-------------------------------------------------*\
-        | Uninitialize when done                            |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Uninitialize when done                        |
+        \*---------------------------------------------*/
         if(weInitialised)
         {
             CoUninitialize();
@@ -124,7 +122,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
     }
     else
     {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
     }
 
     return success;
@@ -132,9 +130,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 
 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
     if(autostart_file != "")
     {
         return(filesystem::exists(autostart_file));
@@ -147,20 +145,20 @@ bool AutoStart::IsAutoStartEnabled()
 
 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
     char exepath[MAX_PATH] = "";
 
     DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
-
+    
     return(std::string(exepath, (count > 0) ? count : 0));
 }
 
-/*---------------------------------------------------------*\
-| Windows AutoStart Implementation                          |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Private Methods                                       |
+\*-----------------------------------------------------*/
 
 void AutoStart::InitAutoStart(std::string name)
 {
@@ -168,9 +166,9 @@ void AutoStart::InitAutoStart(std::string name)
 
     autostart_name = name;
 
-    /*-----------------------------------------------------*\
-    | Get startup applications path                         |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get startup applications path                     |
+    \*-------------------------------------------------*/
     HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
 
     if(SUCCEEDED(result))
@@ -185,10 +183,10 @@ void AutoStart::InitAutoStart(std::string name)
     }
 }
 
-/*---------------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String           |
-| (from wmi.cpp)                                            |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String       |
+| (from wmi.cpp)                                        |
+\*-----------------------------------------------------*/
 std::wstring AutoStart::utf8_decode(const std::string& str)
 {
     if(str.empty())
@@ -199,8 +197,8 @@ std::wstring AutoStart::utf8_decode(const std::string& str)
     int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
 
     std::wstring wstrTo(size_needed, 0);
-
+    
     MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-
+    
     return(wstrTo);
 }

AutoStart/AutoStart-Windows.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.h                                       |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart.cpp

@@ -1,14 +1,10 @@
-/*---------------------------------------------------------*\
-| AutoStart.cpp                                             |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #include "AutoStart.h"
 
+/*-----------------------------------------------------*\
+| Common AutoStart Implementation                       |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
 std::string AutoStartInterface::GetAutoStartFile()
 {
     return(autostart_file);

AutoStart/AutoStart.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart.h                                               |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

CONTRIBUTING.md

@@ -8,14 +8,17 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y
 
 * Please keep the scope of each merge request limited to one functional area.  If you wish to add a new device controller, for instance, don't also do code cleanup in another controller as part of the same merge request.
 * Explain what your merge request is changing, why you feel the change is necessary, and add any additional information you feel is needed to best understand your change in the merge request description.
-* Mark your merge request as a Draft (start title with "Draft:") until it has been fully developed and ideally tested and verified working.  Remove Draft status when you are ready for the code to be reviewed and merged.  I typically do not look at or review Draft merge requests.
+* Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * Follow the Style Guidelines below when making your code changes.
-* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.  I also recommend squashing your commits, though GitLab will do this as part of the merge process if you don't.
-* Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.
+* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
 
-### Pipelines, Shared Runners, Quotas, and Accepting Merge Requests
+### Pipelines, Shared Runners and Quotas
 
-Since mid 2022, GitLab has severely limited the usage of shared runners to all free users.  With that in mind, most pipeline jobs are skipped on forked copies of the project.  Only the Windows 64bit and Linux AppImage amd64 jobs are run on forks, and only if you have permission and available CI minutes on your account.  Unfortunately, with the ever tightening restrictions GitLab has on free CI usage, even to public projects with an open source license, you likely will not be able to utilize the CI builds for your own fork unless you set up your own runners.  Because of this, I no longer require a successful CI run in order to accept a merge request as it is an unreasonable ask given the current CI situation.  If your merge request requires additional verification, I may choose to merge it into a branch instead of into `master` so that my own runners can run the full set of jobs and then I will pull it into master after any verification or changes.  This also means that any build breakages inadvertently caused by merging a merge request may result in the merge being backed out, in which case I will either fix it myself or leave a message on the merge request to rework and resubmit a fixed version.
+Since mid 2022 Gitlab has limited the usage of shared runners to all projects and whilst quite geneorous quotas are allowed
+ for open source projects it is possible to exhaust them. With that in mind not all jobs within the pipeline build are
+ triggered to automatically run with every push to your branch with the exception of the Windows 64bit and Linux Appimage 64bit
+ jobs. If you need to test or share another build you can still start it manually from your pipeline queue.
+ Once a merge request is created all architectures and platforms will be compiled to ensure that they are ready to merge.
 
 Please refer to the following link for [further information relating to minutes and quotas](https://docs.gitlab.com/ee/ci/pipelines/cicd_minutes.html).
 
@@ -54,22 +57,12 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 * Capitalize hexadecimal literals (`0xFF` not `0xff`) except in the udev rules file (which must be lowercase to work)
 * No space between keyword and open parenthesis (`if(TRUE)` not `if (TRUE)`).  There are some instances of this that haven't been cleaned up in the code.
 * Generally, `snake_case` is used for variable names and `CamelCase` is used for function and class names
-* Add a header comment to new files with the filename, description, original author, date, and SPDX license identifier.  You can copy one from an existing file to preserve formatting.
-* Line up `=` on a tab stop when doing a lot of assignments together
+* Add a header comment to new files with the filename, description, original author, and date (this is missing on most Detect files)
+* Line up `=` when doing a lot of assignments together
 * Use this comment box style when adding comments:
-    * Try to start the comment box on the same column as the code directly beneath it and end on column 61 if possible.  See the example below:
 
 ```
-/*---------------------------------------------------------*\
-| This is a comment                                         |
-\*---------------------------------------------------------*/
+/*--------------------------------*\
+| This is a comment                |
+\*_-------------------------------*/
 ```
-
-## Translating
-
-Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
-In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
-
-## AI Guidelines
-
-OpenRGB is an open source project developed by humans for humans.  As a general rule, AI generated submissions are not permitted.  The licensing behind AI generated code is problematic.  If you choose to use AI for assistance in your development process, we can't stop you, but do not credit the AI in commits (no AI authorship/co-authorship).  Ultimately, you as a human developer are responsible for the code you submit and it is expected that any code you submit you fully understand and have manually vetted before submission.  Merge requests that appear to be straight from an AI output, commits with AI tool authorship or co-authorship tags, or otherwise AI generated submissions are subject to closure.

Colors.h

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

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,66 +1,34 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| OpenRGB includes                                      |
+\*-----------------------------------------------------*/
+#include <hidapi/hidapi.h>
+#include "Detector.h"
+#include "LogManager.h"
+#include "RGBController.h"
 
-#include <hidapi.h>
-#include "BloodyB820RController.h"
-#include "BloodyMouseController.h"
-#include "DetectionManager.h"
-#include "RGBController_BloodyB820R.h"
+/*-----------------------------------------------------*\
+| A4 Tech specific includes                             |
+\*-----------------------------------------------------*/
 #include "RGBController_BloodyMouse.h"
 
-/*---------------------------------------------------------*\
-| A4 Tech USB vendor ID                                     |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| A4 Tech USB vendor ID                                 |
+\*-----------------------------------------------------*/
 #define A4_TECH_VID                                 0x09DA
 
-DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
+        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id);
         RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+        rgb_controller->name                        = name;
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(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);
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.cpp

@@ -1,110 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "BloodyB820RController.h"
-#include "StringUtils.h"
-
-/*-------------------------------------------------------------------------------------*\
-| The controller for this device should pass a packet of 64 bytes where the subsequent  |
-| two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control  |
-| or information bytes and colors bytes starts from index 6. Moreover, the first pack-  |
-| et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on   |
-| the second packet.                                                                    |
-\*-------------------------------------------------------------------------------------*/
-
-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name)
-{
-    dev                 = dev_handle;
-    location            = path;
-    name                = dev_name;
-
-    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
-}
-
-BloodyB820RController::~BloodyB820RController()
-{
-    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
-    hid_close(dev);
-}
-
-std::string BloodyB820RController::GetSerial()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-std::string BloodyB820RController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string BloodyB820RController::GetName()
-{
-    return(name);
-}
-
-void  BloodyB820RController::SendControlPacket(uint8_t data)
-{
-    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]    = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-
-    buffer[BLOODY_B820R_MODE_BYTE]              = 0;
-    buffer[BLOODY_B820R_DATA_BYTE]              = data;
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-}
-
-void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
-{
-
-    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
-    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
-    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
-    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
-    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
-    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
-
-    /*-----------------------------------------------------------------*\
-    | Set up Direct packet                                              |
-    |   packet_map is the index of the Key from full_matrix_map and     |
-    |   the value is the position in the direct packet buffer           |
-    \*-----------------------------------------------------------------*/
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor    color                       = colors[i];
-        uint8_t     offset                      = BLOODY_B820R_RGB_OFFSET;
-        uint8_t     buffer_idx                  = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
-        uint8_t*    buffers[2][3]               =
-                {
-                        {r1_buffer, g1_buffer, b1_buffer},
-                        {r2_buffer, g2_buffer, b2_buffer}
-                };
-
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
-    }
-
-    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
-}

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.h

@@ -1,55 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-#define HID_MAX_STR                     255
-
-#define BLOODY_B820R_RGB_BUFFER_SIZE    58
-#define BLOODY_B820R_RGB_OFFSET         6
-#define BLOODY_B820R_PACKET_SIZE        64
-#define BLOODY_B820R_KEYCOUNT           104
-#define BLOODY_B820R_MODE_BYTE          3
-#define BLOODY_B820R_DATA_BYTE          8
-#define BLOODY_B820R_GAIN_CONTROL       0x01
-#define BLOODY_B820R_RELEASE_CONTROL    0x00
-
-/*---------------------------------------------------------*\
-| Bloody B820R product ID                                   |
-\*---------------------------------------------------------*/
-#define BLOODY_B820R_PID                            0xFA10
-
-enum
-{
-    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
-};
-
-class BloodyB820RController
-{
-public:
-    BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name);
-    ~BloodyB820RController();
-
-    std::string     GetSerial();
-    std::string     GetLocation();
-    std::string     GetName();
-
-    void            SetLEDDirect(std::vector<RGBColor> colors);
-    void            SendControlPacket(uint8_t data);
-private:
-    std::string     location;
-    std::string     name;
-    hid_device*     dev;
-};

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -1,243 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_BloodyB820R.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][21] =
-    {
-        {0,  NA, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, NA, NA,  NA,  NA,  13, 14,  15},
-        {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,  32,  33,  34, 35,  36},
-        {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,  53,  54,  55, 56,  57},
-        {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA,  NA,  71,  72, 73,  NA},
-        {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86,  NA,  87,  88, 89,  90},
-        {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
-    };
-
-static const char *led_names[] =
-    {
-        KEY_EN_ESCAPE,              //00
-        KEY_EN_F1,
-        KEY_EN_F2,
-        KEY_EN_F3,
-        KEY_EN_F4,
-        KEY_EN_F5,
-        KEY_EN_F6,
-        KEY_EN_F7,
-        KEY_EN_F8,
-        KEY_EN_F9,
-        KEY_EN_F10,
-        KEY_EN_F11,
-        KEY_EN_F12,
-        KEY_EN_PRINT_SCREEN,
-        KEY_EN_SCROLL_LOCK,
-        KEY_EN_PAUSE_BREAK,
-
-        KEY_EN_BACK_TICK,           //10
-        KEY_EN_1,
-        KEY_EN_2,
-        KEY_EN_3,
-        KEY_EN_4,
-        KEY_EN_5,
-        KEY_EN_6,
-        KEY_EN_7,
-        KEY_EN_8,
-        KEY_EN_9,
-        KEY_EN_0,
-        KEY_EN_MINUS,
-        KEY_EN_EQUALS,
-        KEY_EN_BACKSPACE,
-        KEY_EN_INSERT,
-        KEY_EN_HOME,
-        KEY_EN_PAGE_UP,
-        KEY_EN_NUMPAD_LOCK,
-        KEY_EN_NUMPAD_DIVIDE,
-        KEY_EN_NUMPAD_TIMES,
-        KEY_EN_NUMPAD_MINUS,
-
-        KEY_EN_TAB,                 //20
-        KEY_EN_Q,
-        KEY_EN_W,
-        KEY_EN_E,
-        KEY_EN_R,
-        KEY_EN_T,
-        KEY_EN_Y,
-        KEY_EN_U,
-        KEY_EN_I,
-        KEY_EN_O,
-        KEY_EN_P,
-        KEY_EN_LEFT_BRACKET,
-        KEY_EN_RIGHT_BRACKET,
-        KEY_EN_ANSI_BACK_SLASH,
-        KEY_EN_DELETE,
-        KEY_EN_END,
-        KEY_EN_PAGE_DOWN,
-        KEY_EN_NUMPAD_7,
-        KEY_EN_NUMPAD_8,
-        KEY_EN_NUMPAD_9,
-        KEY_EN_NUMPAD_PLUS,
-
-        KEY_EN_CAPS_LOCK,           //30
-        KEY_EN_A,
-        KEY_EN_S,
-        KEY_EN_D,
-        KEY_EN_F,
-        KEY_EN_G,
-        KEY_EN_H,
-        KEY_EN_J,
-        KEY_EN_K,
-        KEY_EN_L,
-        KEY_EN_SEMICOLON,
-        KEY_EN_QUOTE,
-        KEY_EN_ANSI_ENTER,
-        KEY_EN_NUMPAD_4,
-        KEY_EN_NUMPAD_5,
-        KEY_EN_NUMPAD_6,
-
-        KEY_EN_LEFT_SHIFT,          //40
-        KEY_EN_Z,
-        KEY_EN_X,
-        KEY_EN_C,
-        KEY_EN_V,
-        KEY_EN_B,
-        KEY_EN_N,
-        KEY_EN_M,
-        KEY_EN_COMMA,
-        KEY_EN_PERIOD,
-        KEY_EN_FORWARD_SLASH,
-        KEY_EN_RIGHT_SHIFT,
-        KEY_EN_UP_ARROW,
-        KEY_EN_NUMPAD_1,
-        KEY_EN_NUMPAD_2,
-        KEY_EN_NUMPAD_3,
-        KEY_EN_NUMPAD_ENTER,
-
-        KEY_EN_LEFT_CONTROL,        //50
-        KEY_EN_LEFT_WINDOWS,
-        KEY_EN_LEFT_ALT,
-        KEY_EN_SPACE,
-        KEY_EN_RIGHT_ALT,
-        KEY_EN_RIGHT_FUNCTION,
-        KEY_EN_MENU,
-        KEY_EN_RIGHT_CONTROL,
-        KEY_EN_LEFT_ARROW,
-        KEY_EN_DOWN_ARROW,
-        KEY_EN_RIGHT_ARROW,
-        KEY_EN_NUMPAD_0,
-        KEY_EN_NUMPAD_PERIOD
-    };
-
-/**------------------------------------------------------------------*\
-    @name A4Tech Bloody B820R
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectBloodyB820R
-    @comment The A4Tech Bloody B820R keyboard controller currently
-        supports the full size (ANSI layout).
-\*-------------------------------------------------------------------*/
-
-RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetName();
-    vendor                      = "A4Tech";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "A4Tech Bloody Keyboard";
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = BLOODY_B820R_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_BloodyB820R::~RGBController_BloodyB820R()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_BloodyB820R::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Create the Keyboard zone and add the matrix map   |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = ZONE_EN_KEYBOARD;
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-    KB_zone.matrix_map.Set(6, 21, (unsigned int *)&matrix_map);
-    zones.push_back(KB_zone);
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
-    {
-        led new_led;
-        new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_BloodyB820R::DeviceUpdateLEDs()
-{
-    controller->SetLEDDirect(colors);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
-    {
-        colour.push_back(zones[zone].colors[i]);
-    }
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateSingleLED(int led)
-{
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateMode()
-{
-    /* This device does not support modes yet */
-}

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.h

@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "BloodyB820RController.h"
-
-class RGBController_BloodyB820R : public RGBController
-{
-public:
-    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
-    ~RGBController_BloodyB820R();
-
-    void    SetupZones();
-
-    void    DeviceUpdateLEDs();
-    void    DeviceUpdateZoneLEDs(int zone);
-    void    DeviceUpdateSingleLED(int led);
-
-    void    DeviceUpdateMode();
-
-private:
-    BloodyB820RController* controller;
-};

Controllers/A4TechController/BloodyMouseController.cpp

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.cpp                                            |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "BloodyMouseController.h"
+
+BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
+{
+    dev                 = dev_handle;
+    location            = path;
+    pid                 = product_id;
+
+    InitDevice();
+}
+
+BloodyMouseController::~BloodyMouseController()
+{
+    hid_close(dev);
+}
+
+uint16_t BloodyMouseController::GetPid()
+{
+    return pid;
+}
+
+std::string BloodyMouseController::GetSerial()
+{
+    const uint8_t   sz  = HID_MAX_STR;
+    wchar_t         tmp[sz];
+
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
+    {
+        LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
+        return("");
+    }
+
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return serial;
+}
+
+std::string BloodyMouseController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyMouseController::InitDevice()
+{
+    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+
+    buffer[BLOODYMOUSE_MODE_BYTE]                   = 0;
+    buffer[BLOODYMOUSE_DATA_BYTE]                   = 1;
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}
+
+void  BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+{
+    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;
+
+        buffer[offset]                              = RGBGetRValue(colors[i]);
+        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
+        buffer[offset + 2]                          = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyMouseController.h

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.h                                              |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "LogManager.h"
+#include "RGBController.h"
+
+#pragma once
+
+/*-----------------------------------------------------*\
+| Mouse product IDs                                     |
+\*-----------------------------------------------------*/
+#define BLOODY_W60_PRO_PID                          0x37EA
+
+/*-----------------------------------------------------*\
+| Mousemat product IDs                                  |
+\*-----------------------------------------------------*/
+#define BLOODY_MP_50RS_PID                          0xFA60
+
+#define HID_MAX_STR 255
+#define BLOODYMOUSE_WRITE_PACKET_SIZE   64
+
+#define BLOODYMOUSE_BRIGHTNESS_MIN      0
+#define BLOODYMOUSE_BRIGHTNESS_MAX      255
+
+enum
+{
+    BLOODYMOUSE_MODE_DIRECT             = 0x01, //Direct Led Control - Independently set LEDs in zone
+};
+
+enum
+{
+    BLOODYMOUSE_REPORT_BYTE             = 1,
+    BLOODYMOUSE_COMMAND_BYTE            = 2,
+    BLOODYMOUSE_MODE_BYTE               = 3,
+    BLOODYMOUSE_DATA_BYTE               = 8,
+};
+
+class BloodyMouseController
+{
+public:
+    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
+    ~BloodyMouseController();
+
+    uint16_t        GetPid();
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLedsDirect(std::vector<RGBColor> colors);
+private:
+    uint16_t        pid;
+    std::string     location;
+    hid_device*     dev;
+
+    void            InitDevice();
+};

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -1,84 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "BloodyMouseController.h"
-#include "StringUtils.h"
-
-BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name)
-{
-    dev                 = dev_handle;
-    location            = path;
-    pid                 = product_id;
-    name                = dev_name;
-
-    InitDevice();
-}
-
-BloodyMouseController::~BloodyMouseController()
-{
-    hid_close(dev);
-}
-
-uint16_t BloodyMouseController::GetPid()
-{
-    return(pid);
-}
-
-std::string BloodyMouseController::GetSerial()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-std::string BloodyMouseController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string BloodyMouseController::GetName()
-{
-    return(name);
-}
-
-void BloodyMouseController::InitDevice()
-{
-    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-
-    buffer[BLOODYMOUSE_MODE_BYTE]                   = 0;
-    buffer[BLOODYMOUSE_DATA_BYTE]                   = 1;
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-}
-
-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
-{
-    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;
-
-        buffer[offset]                              = RGBGetRValue(colors[i]);
-        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
-        buffer[offset + 2]                          = RGBGetBValue(colors[i]);
-    }
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-}

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W70_MAX_PID                          0x79EF
-#define BLOODY_W90_MAX_PID                          0x3666
-#define BLOODY_W90_PRO_PID                          0x39B6
-
-/*-----------------------------------------------------*\
-| Mousemat product IDs                                  |
-\*-----------------------------------------------------*/
-#define BLOODY_MP_50RS_PID                          0xFA60
-
-#define HID_MAX_STR                     255
-#define BLOODYMOUSE_WRITE_PACKET_SIZE   64
-
-#define BLOODYMOUSE_BRIGHTNESS_MIN      0
-#define BLOODYMOUSE_BRIGHTNESS_MAX      255
-
-enum
-{
-    BLOODYMOUSE_MODE_DIRECT             = 0x01, //Direct Led Control - Independently set LEDs in zone
-};
-
-enum
-{
-    BLOODYMOUSE_REPORT_BYTE             = 1,
-    BLOODYMOUSE_COMMAND_BYTE            = 2,
-    BLOODYMOUSE_MODE_BYTE               = 3,
-    BLOODYMOUSE_DATA_BYTE               = 8,
-};
-
-class BloodyMouseController
-{
-public:
-    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name);
-    ~BloodyMouseController();
-
-    uint16_t        GetPid();
-    std::string     GetSerial();
-    std::string     GetLocation();
-    std::string     GetName();
-
-    void            SetLedsDirect(std::vector<RGBColor> colors);
-
-private:
-    uint16_t        pid;
-    std::string     location;
-    std::string     name;
-    hid_device*     dev;
-
-    void            InitDevice();
-};

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -1,42 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "BloodyMouseController.h"
-
-struct mouse_zone
-{
-    std::string             name;
-    std::vector<uint8_t>    zone_leds;
-};
-
-typedef std::vector<mouse_zone> mouse_layout;
-
-class RGBController_BloodyMouse : public RGBController
-{
-public:
-    RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
-    ~RGBController_BloodyMouse();
-
-    void                    SetupZones();
-
-    void                    DeviceUpdateLEDs();
-    void                    DeviceUpdateZoneLEDs(int zone);
-    void                    DeviceUpdateSingleLED(int led);
-
-    void                    DeviceUpdateMode();
-
-private:
-    BloodyMouseController*  controller;
-};

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.cpp                                        |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
 
 #include "RGBController_BloodyMouse.h"
 
@@ -27,19 +25,6 @@ static const mouse_layout w60_pro
     }
 };
 
-static const mouse_layout w90_max
-{
-    {
-        "Scroll Wheel", { 14 }
-    },
-    {
-        "Logo",         { 7 }
-    },
-    {
-        "Rear",         { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
-    }
-};
-
 static const mouse_layout mp_50rs
 {
     {
@@ -71,7 +56,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
             type                = DEVICE_TYPE_MOUSE;
     }
 
-    name                        = controller->GetName();
+    name                        = "BloodyMouse";
     vendor                      = "Bloody";
     description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
     serial                      = controller->GetSerial();
@@ -89,8 +74,6 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
 
 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -106,17 +89,11 @@ void RGBController_BloodyMouse::SetupZones()
     | Select layout from PID                            |
     \*-------------------------------------------------*/
     mouse_layout layout;
-
     switch(controller->GetPid())
     {
         case BLOODY_W60_PRO_PID:
             layout = w60_pro;
             break;
-        case BLOODY_W70_MAX_PID:
-        case BLOODY_W90_MAX_PID:
-        case BLOODY_W90_PRO_PID:
-            layout = w90_max;
-            break;
         case BLOODY_MP_50RS_PID:
             layout = mp_50rs;
             break;
@@ -132,10 +109,11 @@ void RGBController_BloodyMouse::SetupZones()
 
         zone new_zone;
         new_zone.name           = mz.name;
-        new_zone.leds_min       = (unsigned int)mz.zone_leds.size();
+        new_zone.leds_min       = mz.zone_leds.size();
         new_zone.leds_max       = new_zone.leds_min;
         new_zone.leds_count     = new_zone.leds_min;
         new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+        new_zone.matrix_map     = NULL;
         zones.push_back(new_zone);
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
@@ -161,6 +139,13 @@ void RGBController_BloodyMouse::SetupZones()
     SetupColors();
 }
 
+void RGBController_BloodyMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_BloodyMouse::DeviceUpdateLEDs()
 {
     std::vector<RGBColor> colour;
@@ -173,12 +158,12 @@ void RGBController_BloodyMouse::DeviceUpdateLEDs()
     controller->SetLedsDirect(colour);
 }
 
-void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_BloodyMouse::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.h                                          |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#pragma once
+#include <vector>
+#include "LogManager.h"
+#include "RGBController.h"
+#include "BloodyMouseController.h"
+
+struct mouse_zone
+{
+    std::string             name;
+    std::vector<uint8_t>    zone_leds;
+};
+
+typedef std::vector<mouse_zone> mouse_layout;
+
+class RGBController_BloodyMouse : public RGBController
+{
+public:
+    RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
+    ~RGBController_BloodyMouse();
+
+    void                    SetupZones();
+    void                    ResizeZone(int zone, int new_size);
+
+    void                    DeviceUpdateLEDs();
+    void                    UpdateZoneLEDs(int zone);
+    void                    UpdateSingleLED(int led);
+
+    void                    DeviceUpdateMode();
+
+private:
+    BloodyMouseController*  controller;
+};

Controllers/AMBXController/AMBXController.cpp

@@ -1,195 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXController.cpp                                        |
-|                                                           |
-|   Driver for Philips amBX Gaming lights                   |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "AMBXController.h"
-#include "LogManager.h"
-#include "StringUtils.h"
-#include <cstring>
-#include <thread>
-#include <chrono>
-
-AMBXController::AMBXController(const char* path)
-{
-    initialized      = false;
-    usb_context      = nullptr;
-    dev_handle       = nullptr;
-
-    location = "USB: ";
-    location += path;
-
-    // Initialize libusb in this instance
-    if(libusb_init(&usb_context) < 0)
-    {
-        return;
-    }
-
-    // Get the device list
-    libusb_device** device_list;
-    ssize_t device_count = libusb_get_device_list(usb_context, &device_list);
-
-    if(device_count < 0)
-    {
-        return;
-    }
-
-    for(ssize_t i = 0; i < device_count; i++)
-    {
-        libusb_device* device = device_list[i];
-        struct libusb_device_descriptor desc;
-
-        if(libusb_get_device_descriptor(device, &desc) != LIBUSB_SUCCESS)
-        {
-            continue;
-        }
-
-        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
-        {
-            uint8_t bus = libusb_get_bus_number(device);
-            uint8_t address = libusb_get_device_address(device);
-
-            char current_path[32];
-            snprintf(current_path, sizeof(current_path), "%d-%d", bus, address);
-
-            if(strcmp(path, current_path) == 0)
-            {
-                // Try to open this device
-                if(libusb_open(device, &dev_handle) != LIBUSB_SUCCESS)
-                {
-                    continue;
-                }
-
-                // Try to detach the kernel driver if attached
-                if(libusb_kernel_driver_active(dev_handle, 0))
-                {
-                    libusb_detach_kernel_driver(dev_handle, 0);
-                }
-
-                // Set auto-detach for Windows compatibility
-                libusb_set_auto_detach_kernel_driver(dev_handle, 1);
-
-                // Claim the interface
-                if(libusb_claim_interface(dev_handle, 0) != LIBUSB_SUCCESS)
-                {
-                    libusb_close(dev_handle);
-                    dev_handle = nullptr;
-                    continue;
-                }
-
-                // Get string descriptor for serial number if available
-                if(desc.iSerialNumber != 0)
-                {
-                    unsigned char serial_str[256];
-                    int serial_result = libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
-                                                                         serial_str, sizeof(serial_str));
-                    if(serial_result > 0)
-                    {
-                        serial = std::string(reinterpret_cast<char*>(serial_str), serial_result);
-                    }
-                }
-
-                // Successfully opened and claimed the device
-                initialized = true;
-                break;
-            }
-        }
-    }
-
-    libusb_free_device_list(device_list, 1);
-}
-
-AMBXController::~AMBXController()
-{
-    if(initialized)
-    {
-        // Turn off all lights before closing
-        unsigned int led_ids[5] =
-        {
-            AMBX_LIGHT_LEFT,
-            AMBX_LIGHT_RIGHT,
-            AMBX_LIGHT_WALL_LEFT,
-            AMBX_LIGHT_WALL_CENTER,
-            AMBX_LIGHT_WALL_RIGHT
-        };
-
-        RGBColor colors[5] = { 0, 0, 0, 0, 0 };
-        SetLEDColors(led_ids, colors, 5);
-    }
-
-    if(dev_handle != nullptr)
-    {
-        // Release the interface
-        libusb_release_interface(dev_handle, 0);
-
-        // Close the device
-        libusb_close(dev_handle);
-        dev_handle = nullptr;
-    }
-
-    if(usb_context != nullptr)
-    {
-        libusb_exit(usb_context);
-        usb_context = nullptr;
-    }
-}
-
-std::string AMBXController::GetDeviceLocation()
-{
-    return location;
-}
-
-std::string AMBXController::GetSerialString()
-{
-    return serial;
-}
-
-bool AMBXController::IsInitialized()
-{
-    return initialized;
-}
-
-void AMBXController::SendPacket(unsigned char* packet, unsigned int size)
-{
-    if(!initialized || dev_handle == nullptr)
-    {
-        return;
-    }
-
-    int actual_length = 0;
-    libusb_interrupt_transfer(dev_handle, AMBX_ENDPOINT_OUT, packet, size, &actual_length, 100);
-}
-
-void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
-{
-    if(!initialized)
-    {
-        return;
-    }
-
-    unsigned char color_buf[6] =
-    {
-        AMBX_PACKET_HEADER,
-        static_cast<unsigned char>(led),
-        AMBX_SET_COLOR,
-        (unsigned char)RGBGetRValue(color),
-        (unsigned char)RGBGetGValue(color),
-        (unsigned char)RGBGetBValue(color)
-    };
-
-    SendPacket(color_buf, 6);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
-{
-    for(unsigned int i = 0; i < count; i++)
-    {
-        SetLEDColor(leds[i], colors[i]);
-    }
-}

Controllers/AMBXController/AMBXController.h

@@ -1,57 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXController.h                                          |
-|                                                           |
-|   Driver for Philips amBX Gaming lights                   |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include <string>
-
-#ifdef _WIN32
-#include "dependencies/libusb-1.0.27/include/libusb.h"
-#else
-#include <libusb.h>
-#endif
-
-#define AMBX_VID                            0x0471
-#define AMBX_PID                            0x083F
-#define AMBX_ENDPOINT_OUT                   0x02
-#define AMBX_PACKET_HEADER                  0xA1
-#define AMBX_SET_COLOR                      0x03
-
-enum
-{
-    AMBX_LIGHT_LEFT         = 0x0B,
-    AMBX_LIGHT_RIGHT        = 0x1B,
-    AMBX_LIGHT_WALL_LEFT    = 0x2B,
-    AMBX_LIGHT_WALL_CENTER  = 0x3B,
-    AMBX_LIGHT_WALL_RIGHT   = 0x4B
-};
-
-class AMBXController
-{
-public:
-    AMBXController(const char* path);
-    ~AMBXController();
-
-    std::string     GetDeviceLocation();
-    std::string     GetSerialString();
-
-    bool            IsInitialized();
-    void            SetLEDColor(unsigned int led, RGBColor color);
-    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
-
-private:
-    libusb_context*          usb_context;
-    libusb_device_handle*    dev_handle;
-    std::string              location;
-    std::string              serial;
-    bool                     initialized;
-
-    void                    SendPacket(unsigned char* packet, unsigned int size);
-};

Controllers/AMBXController/AMBXControllerDetect.cpp

@@ -1,77 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXControllerDetect.cpp                                  |
-|                                                           |
-|   Detector for Philips amBX Gaming lights                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "AMBXController.h"
-#include "DetectionManager.h"
-#include "RGBController.h"
-#include "RGBController_AMBX.h"
-
-#ifdef _WIN32
-#include "dependencies/libusb-1.0.27/include/libusb.h"
-#else
-#include <libusb.h>
-#endif
-
-DetectedControllers DetectAMBXControllers()
-{
-    DetectedControllers detected_controllers;
-    libusb_context*     ctx = NULL;
-
-    if(libusb_init(&ctx) >= 0)
-    {
-        libusb_device** devs;
-        ssize_t num_devs = libusb_get_device_list(ctx, &devs);
-
-        if(num_devs > 0)
-        {
-            for(ssize_t i = 0; i < num_devs; i++)
-            {
-                libusb_device* dev = devs[i];
-                libusb_device_descriptor desc;
-
-                if(libusb_get_device_descriptor(dev, &desc) != 0)
-                {
-                    continue;
-                }
-
-                if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
-                {
-                    uint8_t bus = libusb_get_bus_number(dev);
-                    uint8_t address = libusb_get_device_address(dev);
-                    char device_path[32];
-                    snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
-
-                    // Use the AMBXController to handle opening and initializing
-                    AMBXController* controller = new AMBXController(device_path);
-
-                    if(controller->IsInitialized())
-                    {
-                        RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
-                        detected_controllers.push_back(rgb_controller);
-                    }
-                    else
-                    {
-                        delete controller;
-                    }
-                }
-            }
-
-            libusb_free_device_list(devs, 1);
-            libusb_exit(ctx);
-        }
-        else
-        {
-            libusb_exit(ctx);
-        }
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -1,174 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AMBX.cpp                                    |
-|                                                           |
-|   RGB Controller for Philips amBX Gaming lights           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AMBX.h"
-
-/**------------------------------------------------------------------*\
-    @name Philips amBX
-    @category Accessory
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAMBXControllers
-    @comment The Philips amBX Gaming lights system includes left and right
-    lights and a wall-washer bar with three zones.
-\*-------------------------------------------------------------------*/
-
-RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
-{
-    controller = controller_ptr;
-
-    name        = "Philips amBX";
-    vendor      = "Philips";
-    type        = DEVICE_TYPE_ACCESSORY;
-    description = "Philips amBX Gaming Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    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_AMBX::~RGBController_AMBX()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_AMBX::SetupZones()
-{
-    // Set up zones
-    zone side_lights_zone;
-    side_lights_zone.name       = "Side Lights";
-    side_lights_zone.type       = ZONE_TYPE_LINEAR;
-    side_lights_zone.leds_min   = 2;
-    side_lights_zone.leds_max   = 2;
-    side_lights_zone.leds_count = 2;
-    zones.push_back(side_lights_zone);
-
-    zone wallwasher_zone;
-    wallwasher_zone.name       = "Wallwasher";
-    wallwasher_zone.type       = ZONE_TYPE_LINEAR;
-    wallwasher_zone.leds_min   = 3;
-    wallwasher_zone.leds_max   = 3;
-    wallwasher_zone.leds_count = 3;
-    zones.push_back(wallwasher_zone);
-
-    // 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();
-}
-
-void RGBController_AMBX::DeviceUpdateLEDs()
-{
-    if(!controller->IsInitialized())
-    {
-        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()));
-}
-
-void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    unsigned int start_idx = 0;
-    unsigned int zone_size = 0;
-
-    // Calculate start index and size
-    for(unsigned int z_idx = 0; z_idx < zones.size(); z_idx++)
-    {
-        if(z_idx == (unsigned int)zone)
-        {
-            zone_size = zones[z_idx].leds_count;
-            break;
-        }
-
-        start_idx += zones[z_idx].leds_count;
-    }
-
-    unsigned int led_values[5];
-    RGBColor led_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];
-    }
-
-    controller->SetLEDColors(led_values, led_colors, zone_size);
-}
-
-void RGBController_AMBX::DeviceUpdateSingleLED(int led)
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    unsigned int led_value = leds[led].value;
-    RGBColor color = colors[led];
-    controller->SetLEDColor(led_value, color);
-}
-
-void RGBController_AMBX::DeviceUpdateMode()
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    DeviceUpdateLEDs();
-}

Controllers/AMBXController/RGBController_AMBX.h

@@ -1,31 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AMBX.h                                      |
-|                                                           |
-|   RGB Controller for Philips amBX Gaming lights           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AMBXController.h"
-
-class RGBController_AMBX : public RGBController
-{
-public:
-    RGBController_AMBX(AMBXController* controller_ptr);
-    ~RGBController_AMBX();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AMBXController* controller;
-};

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -1,24 +1,21 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.cpp                              |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Driver for AMD Wraith Prism RGB lighting |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
 
+#include "AMDWraithPrismController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
-#include "AMDWraithPrismController.h"
-#include "StringUtils.h"
 
 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
-    dev                         = dev_handle;
-    location                    = path;
+    dev         = dev_handle;
+    location    = path;
 
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;
@@ -56,7 +53,10 @@ std::string AMDWraithPrismController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string AMDWraithPrismController::GetFirmwareVersionString()

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.h                                |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Definitions and types for AMD Wraith     |
+|  Prism lighting controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
+
 #include "RGBController.h"
 
+#pragma once
+
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
 

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -1,45 +1,30 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismControllerDetect.cpp                        |
-|                                                           |
-|   Detector for AMD Wraith Prism                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
+#include "Detector.h"
 #include "AMDWraithPrismController.h"
-#include "DetectionManager.h"
+#include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
+#include <hidapi/hidapi.h>
 
-/*---------------------------------------------------------*\
-| AMD Wraith Prism vendor ID                                |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_VID                        0x2516
+#define AMD_WRAITH_PRISM_VID 0x2516
+#define AMD_WRAITH_PRISM_PID 0x0051
 
-/*---------------------------------------------------------*\
-| AMD Wraith Prism product ID                               |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_PID                        0x0051
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAMDWraithPrismControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
+*                                                                                          *
+\******************************************************************************************/
 
-DetectedControllers DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
         AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
         RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-
-        detected_controllers.push_back(rgb_controller);
+        // Constructor sets the name
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.cpp                          |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.cpp         |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_AMDWraithPrism.h"
 
@@ -27,14 +25,14 @@
 
 RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;
 
-    name                        = "AMD Wraith Prism";
-    vendor                      = "Cooler Master";
-    type                        = DEVICE_TYPE_COOLER;
-    description                 = "AMD Wraith Prism Device";
-    version                     = controller->GetFirmwareVersionString();
-    location                    = controller->GetLocationString();
+    name        = "AMD Wraith Prism";
+    vendor      = "Cooler Master";
+    type        = DEVICE_TYPE_COOLER;
+    description = "AMD Wraith Prism Device";
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetLocationString();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -132,30 +130,29 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-    Shutdown();
-
     delete controller;
 }
 
 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 };
+    /*---------------------------------------------------------*\
+    | LED maps                                                  |
+    \*---------------------------------------------------------*/
+    const unsigned int logo_leds[1] =   { 0x00 };
+    const unsigned int fan_leds[1] =    { 0x01 };
+    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
+                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
 
-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
     zone logo_zone;
     logo_zone.name          = "Logo";
     logo_zone.type          = ZONE_TYPE_SINGLE;
     logo_zone.leds_min      = 1;
     logo_zone.leds_max      = 1;
     logo_zone.leds_count    = 1;
+    logo_zone.matrix_map    = NULL;
     zones.push_back(logo_zone);
 
     zone fan_zone;
@@ -164,79 +161,81 @@ void RGBController_AMDWraithPrism::SetupZones()
     fan_zone.leds_min       = 1;
     fan_zone.leds_max       = 1;
     fan_zone.leds_count     = 1;
+    fan_zone.matrix_map     = NULL;
     zones.push_back(fan_zone);
 
     zone ring_zone;
     ring_zone.name          = "Ring";
     ring_zone.type          = ZONE_TYPE_LINEAR;
-    ring_zone.leds_min      = 15;
-    ring_zone.leds_max      = 15;
-    ring_zone.leds_count    = 15;
+    ring_zone.leds_min      = 14;
+    ring_zone.leds_max      = 14;
+    ring_zone.leds_count    = 14;
+    ring_zone.matrix_map    = NULL;
     zones.push_back(ring_zone);
 
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led logo_led;
-        logo_led.name       = "Logo LED";
-        logo_led.value      = logo_leds[led_idx];
+        logo_led.name = "Logo LED";
+        logo_led.value = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led fan_led;
-        fan_led.name        = "Fan LED";
-        fan_led.value       = fan_leds[led_idx];
+        fan_led.name = "Fan LED";
+        fan_led.value = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
-    for(unsigned int led_idx = 0; led_idx < 15; led_idx++)
+    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
     {
         led ring_led;
-        ring_led.name       = "Ring LED";
-        ring_led.value      = ring_leds[led_idx];
+        ring_led.name = "Ring LED";
+        ring_led.value = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 
     SetupColors();
 }
 
+void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
-        unsigned char   led_ids[17];
-        RGBColor        color_buf[17];
-        unsigned int    leds_count;
+        unsigned char   led_ids[15];
+        RGBColor        color_buf[15];
+        unsigned int    leds_count = 0;
 
-        /*-------------------------------------------------*\
-        | Send logo and fan LEDs in the first packet        |
-        \*-------------------------------------------------*/
-        leds_count = 0;
-        for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
+        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
         {
             led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
             color_buf[leds_count]   = colors[led_idx];
 
             leds_count++;
-        }
-        controller->SendDirectPacket(leds_count, led_ids, color_buf);
 
-        /*-------------------------------------------------*\
-        | Send all ring LEDs in the second packet           |
-        \*-------------------------------------------------*/
-        leds_count = 0;
-        for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
+            if(leds_count >= 15)
+            {
+                controller->SendDirectPacket(15, led_ids, color_buf);
+                leds_count = 0;
+            }
+        }
+
+        if(leds_count > 0)
         {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
-            color_buf[leds_count]   = colors[led_idx + 2];
-
-            leds_count++;
+            controller->SendDirectPacket(leds_count, led_ids, color_buf);
         }
-        controller->SendDirectPacket(leds_count, led_ids, color_buf);
     }
     else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
     {
@@ -263,12 +262,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AMDWraithPrism::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AMDWraithPrism::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.h                            |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.h           |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
 
 #pragma once
-
 #include "RGBController.h"
 #include "AMDWraithPrismController.h"
 
@@ -22,9 +19,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -1,27 +1,24 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.cpp                                 |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCKeyboardController.cpp                |
+|                                           |
+|  Driver for AOC Keyboard lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
-#include <chrono>
-#include <cstring>
-#include <thread>
 #include "AOCKeyboardController.h"
-#include "StringUtils.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
 
 using namespace std::chrono_literals;
 
-AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
-    name        = dev_name;
 }
 
 AOCKeyboardController::~AOCKeyboardController()
@@ -31,12 +28,7 @@ AOCKeyboardController::~AOCKeyboardController()
 
 std::string AOCKeyboardController::GetDeviceLocation()
 {
-    return("HID: " + location);
-}
-
-std::string AOCKeyboardController::GetDeviceName()
-{
-    return(name);
+    return("HID " + location);
 }
 
 std::string AOCKeyboardController::GetSerialString()
@@ -49,7 +41,10 @@ std::string AOCKeyboardController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 void AOCKeyboardController::SetLightingConfig

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.h                                   |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCKeyboardController.h                  |
+|                                           |
+|  Definitions and types for AOC keyboard   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Keyboard Modes                        |
 \*-----------------------------------------*/
@@ -64,11 +62,10 @@ enum
 class AOCKeyboardController
 {
 public:
-    AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCKeyboardController(hid_device* dev_handle, const char* path);
     ~AOCKeyboardController();
 
     std::string GetDeviceLocation();
-    std::string GetDeviceName();
     std::string GetSerialString();
 
     void SetLightingConfig
@@ -89,7 +86,6 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 
     void SendStartPacket();
     void SendEndPacket();

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -1,42 +1,34 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC keyboard                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCKeyboardController.h"
+#include "RGBController.h"
 #include "RGBController_AOCKeyboard.h"
 
-/*---------------------------------------------------------*\
-| AOC Keyboard IDs                                          |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
-#define AOC_GK500_PID_2                             0x1229
 
-DetectedControllers DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCKeyboardControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
+        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
         RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
+        rgb_controller->name                      = name;
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2, 0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.cpp                             |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCKeyboard.h"
 #include "KeyboardLayoutManager.h"
@@ -35,10 +32,10 @@ layout_values aoc_keyboard_offset_values =
             75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
         /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
             60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                     NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,    0,   10,                      57,   72,   87,
-        /* LSFT    \     Z     X     C     V     B     N     M     ,     .     /   RSFT             ARWU          NP1   NP2   NP3  NPEN */
-            30,    0,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,               11,          42,   27,   12,  101,
+        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
+            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
+        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
+            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
         /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
             15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
     },
@@ -50,14 +47,14 @@ layout_values aoc_keyboard_offset_values =
 
 RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_KEYBOARD;
-    description                     = "AOC Keyboard Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Keyboard Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "AOC Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Static;
     Static.name                     = "Static";
@@ -257,31 +254,41 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 
 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_AOCKeyboard::SetupZones()
 {
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
-
     /*---------------------------------------------------------*\
     | Create the keyboard zone usiung Keyboard Layout Manager   |
     \*---------------------------------------------------------*/
     zone new_zone;
-    new_zone.name                   = ZONE_EN_KEYBOARD;
-    new_zone.type                   = ZONE_TYPE_MATRIX;
-    new_zone.leds_count             = new_kb.GetKeyCount();
-    new_zone.leds_min               = new_zone.leds_count;
-    new_zone.leds_max               = new_zone.leds_count;
-    new_zone.matrix_map             = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
+    new_zone.name               = ZONE_EN_KEYBOARD;
+    new_zone.type               = ZONE_TYPE_MATRIX;
+
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
+
+    matrix_map_type * new_map   = new matrix_map_type;
+    new_zone.matrix_map         = new_map;
+    new_zone.matrix_map->height = new_kb.GetRowCount();
+    new_zone.matrix_map->width  = new_kb.GetColumnCount();
+
+    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
+    new_zone.leds_count         = new_kb.GetKeyCount();
+    new_zone.leds_min           = new_zone.leds_count;
+    new_zone.leds_max           = new_zone.leds_count;
+
+    /*---------------------------------------------------------*\
+    | Matrix map still uses declared zone rows and columns      |
+    |   as the packet structure depends on the matrix map       |
+    \*---------------------------------------------------------*/
+    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
 
     /*---------------------------------------------------------*\
     | Create LEDs for the Matrix zone                           |
     |   Place keys in the layout to populate the matrix         |
     \*---------------------------------------------------------*/
-    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
     {
         led new_led;
 
@@ -292,9 +299,18 @@ void RGBController_AOCKeyboard::SetupZones()
 
     zones.push_back(new_zone);
 
+
+
     SetupColors();
 }
 
+void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
@@ -314,12 +330,12 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AOCKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCKeyboard::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.h                               |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.h              |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 
@@ -22,9 +19,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -1,23 +1,19 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.cpp                                    |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMouseController.cpp                   |
+|                                           |
+|  Driver for AOC Mouse lighting controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMouseController.h"
 
 #include <cstring>
-#include "AOCMouseController.h"
-#include "StringUtils.h"
 
-AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
-    name        = dev_name;
 }
 
 AOCMouseController::~AOCMouseController()
@@ -27,12 +23,7 @@ AOCMouseController::~AOCMouseController()
 
 std::string AOCMouseController::GetDeviceLocation()
 {
-    return("HID: " + location);
-}
-
-std::string AOCMouseController::GetDeviceName()
-{
-    return(name);
+    return("HID " + location);
 }
 
 std::string AOCMouseController::GetSerialString()
@@ -45,7 +36,10 @@ std::string AOCMouseController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 /*-------------------------------------------------------------------------------------------------*\

Controllers/AOCMouseController/AOCMouseController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.h                                      |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMouseController.h                     |
+|                                           |
+|  Definitions and types for AOC mouse      |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |
@@ -56,11 +54,10 @@ enum
 class AOCMouseController
 {
 public:
-    AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCMouseController(hid_device* dev_handle, const char* path);
     ~AOCMouseController();
 
     std::string GetDeviceLocation();
-    std::string GetDeviceName();
     std::string GetSerialString();
 
     void SendDirect
@@ -80,5 +77,4 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 };

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -1,40 +1,34 @@
-/*---------------------------------------------------------*\
-| AOCMouseControllerDetect.cpp                              |
-|                                                           |
-|   Detector for AOC mouse                                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCMouseController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMouse.h"
 
-/*---------------------------------------------------------*\
-| AOC Mouse IDs                                             |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179
 
-DetectedControllers DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMouseControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mouse controller exists there.              *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
+        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
         RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
+        rgb_controller->name                   = name;
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.cpp                                |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.cpp               |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCMouse.h"
 
@@ -24,14 +21,14 @@
 
 RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_MOUSE;
-    description                     = "AOC Mouse Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Mouse Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "AOC Mouse Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";
@@ -123,8 +120,6 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -136,6 +131,7 @@ void RGBController_AOCMouse::SetupZones()
     logo_zone.leds_min              = 1;
     logo_zone.leds_max              = 1;
     logo_zone.leds_count            = 1;
+    logo_zone.matrix_map            = NULL;
     zones.push_back(logo_zone);
 
     led logo_led;
@@ -148,6 +144,7 @@ void RGBController_AOCMouse::SetupZones()
     scroll_wheel_zone.leds_min      = 1;
     scroll_wheel_zone.leds_max      = 1;
     scroll_wheel_zone.leds_count    = 1;
+    scroll_wheel_zone.matrix_map    = NULL;
     zones.push_back(scroll_wheel_zone);
 
     led scroll_wheel_led;
@@ -157,17 +154,24 @@ void RGBController_AOCMouse::SetupZones()
     SetupColors();
 }
 
+void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCMouse::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_AOCMouse::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMouse::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.h                                  |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.h                 |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 
@@ -22,9 +19,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -1,23 +1,20 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.cpp                                 |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMousematController.cpp                |
+|                                           |
+|  Driver for AOC Mousemat lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMousematController.h"
 
 #include <cstring>
-#include "AOCMousematController.h"
-#include "StringUtils.h"
 
-AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
-    name        = dev_name;
 }
 
 AOCMousematController::~AOCMousematController()
@@ -27,12 +24,7 @@ AOCMousematController::~AOCMousematController()
 
 std::string AOCMousematController::GetDeviceLocation()
 {
-    return("HID: " + location);
-}
-
-std::string AOCMousematController::GetDeviceName()
-{
-    return(name);
+    return("HID " + location);
 }
 
 std::string AOCMousematController::GetSerialString()
@@ -45,7 +37,10 @@ std::string AOCMousematController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 /*-------------------------------------------------------------------------------------------------*\

Controllers/AOCMousematController/AOCMousematController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.h                                   |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMousematController.h                  |
+|                                           |
+|  Definitions and types for AOC mousemat   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |
@@ -55,11 +53,10 @@ enum
 class AOCMousematController
 {
 public:
-    AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCMousematController(hid_device* dev_handle, const char* path);
     ~AOCMousematController();
 
     std::string GetDeviceLocation();
-    std::string GetDeviceName();
     std::string GetSerialString();
 
     void SendDirect
@@ -79,5 +76,4 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 };

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -1,40 +1,34 @@
-/*---------------------------------------------------------*\
-| AOCMousematControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC mousemat                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCMousematController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMousemat.h"
 
-/*---------------------------------------------------------*\
-| AOC Mousemat IDs                                          |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_AMM700_PID                              0x1162
 
-DetectedControllers DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMousematControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
+        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
         RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
+        rgb_controller->name                      = name;
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);
+REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.cpp                             |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCMousemat.h"
 
@@ -24,14 +21,14 @@
 
 RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_MOUSEMAT;
-    description                     = "AOC Mousemat Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Mousemat Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "AOC Mousemat Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";
@@ -113,8 +110,6 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -126,6 +121,7 @@ void RGBController_AOCMousemat::SetupZones()
     mousemat_zone.leds_min      = 1;
     mousemat_zone.leds_max      = 1;
     mousemat_zone.leds_count    = 1;
+    mousemat_zone.matrix_map    = NULL;
     zones.push_back(mousemat_zone);
 
     led mousemat_led;
@@ -135,17 +131,24 @@ void RGBController_AOCMousemat::SetupZones()
     SetupColors();
 }
 
+void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCMousemat::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_AOCMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMousemat::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.h                               |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.h              |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 
@@ -22,9 +19,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -1,22 +1,19 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.cpp                         |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.cpp        |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 #include <cstring>
-#include "ASRockPolychromeUSBController.h"
-#include "dmiinfo.h"
-#include "ResourceManager.h"
+#include <stdio.h>
+
 #include "RGBController.h"
-#include "SettingsManager.h"
-#include "StringUtils.h"
+#include "ResourceManager.h"
+#include "ASRockPolychromeUSBController.h"
+#include "dependencies/dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -57,7 +54,7 @@ PolychromeUSBController::~PolychromeUSBController()
 
 unsigned int PolychromeUSBController::GetChannelCount()
 {
-    return((unsigned int)device_info.size());
+    return(device_info.size());
 }
 
 std::string PolychromeUSBController::GetDeviceLocation()
@@ -80,7 +77,10 @@ std::string PolychromeUSBController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 void PolychromeUSBController::SetDeviceInfo()
@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
     WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }
 
-void PolychromeUSBController::SetZoneSize(int zone, int new_size)
+void PolychromeUSBController::ResizeZone(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 
@@ -324,7 +324,6 @@ void PolychromeUSBController::WriteAllZones
         | Send packet                                           |
         \*-----------------------------------------------------*/
         hid_write(dev, usb_buf, 65);
-        hid_read(dev, usb_buf, 64);
 
         /*-----------------------------------------------------*\
         | Zero out buffer                                       |
@@ -381,7 +380,7 @@ void PolychromeUSBController::WriteRGSwap
     bool chnl8
     )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>((((unsigned char)chnl8 << 7) | ((unsigned char)pcb << 6) | ((unsigned char)io << 5) | ((unsigned char)pch << 4) | ((unsigned char)ahdr1 << 3) | ((unsigned char)ahdr0 << 2) | ((unsigned char)hdr1 << 1) | (unsigned char)hdr0))};
+    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
     WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -1,21 +1,19 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.h                           |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.h          |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
@@ -135,7 +133,7 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        SetZoneSize(int zone, int new_size);
+    void                                        ResizeZone(int zone, int new_size);
     void                                        SetRGSwap(bool reset);
 
 protected:
@@ -156,11 +154,12 @@ protected:
         );
 
 private:
+    unsigned int  led_count;
     std::string   device_name;
     unsigned char configtable[12];
     bool          rgswapconfig[8] = { 0 };
 
-    void SetDeviceInfo();
+    void SetDeviceInfo();    
     void ReadConfigTables();
     void Commit();
 };

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -1,19 +1,13 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBControllerDetect.cpp                   |
-|                                                           |
-|   Detector for ASRock Polychrome USB motherboards         |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
+#include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
-#include "DetectionManager.h"
+#include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <hidapi/hidapi.h>
 
 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -26,23 +20,17 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
 
-DetectedControllers DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
+void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
         RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip",  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
+REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.cpp                     |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.cpp    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 
-#include <string.h>
 #include "RGBController_ASRockPolychromeUSB.h"
+#include <string.h>
 
 #define ASROCK_USB_MAX_ZONES        8
 #define ASROCK_ADDRESSABLE_MAX_LEDS 100
@@ -185,25 +183,8 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     SetupZones();
 }
 
-RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_PolychromeUSB::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
@@ -214,55 +195,28 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
-
-            if(first_run)
-            {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = device_info.num_leds;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
 
+
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
@@ -273,6 +227,8 @@ void RGBController_PolychromeUSB::SetupZones()
 
             leds.push_back(new_led);
         }
+
+        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
@@ -315,14 +271,10 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
-    {
-        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
-
-        SetupZones();
-    }
+    zones[zone].leds_count = (unsigned char) new_size;
+    controller->ResizeZone(zones_info[zone].zone, new_size);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -341,11 +293,11 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
             set_mode = active_mode;
         }
 
-        controller->WriteZone((unsigned char)zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+        controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
     }
 }
 
-void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
+void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
 {
     unsigned char set_mode=zones_info[zone].mode;
 
@@ -357,7 +309,7 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
     controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
-void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
+void RGBController_PolychromeUSB::UpdateSingleLED(int led)
 {
     unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -1,14 +1,12 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.h                       |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.h      |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 
 #pragma once
 
@@ -19,19 +17,19 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
     RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
-    ~RGBController_PolychromeUSB();
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 
 private:
+    bool                            initializedMode;
     PolychromeUSBController*        controller;
     std::vector<PolychromeZoneInfo> zones_info;
 

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.cpp                           |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.cpp      |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
 #include "ASRockASRRGBSMBusController.h"
 #include <cstring>
-#include "dmiinfo.h"
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -36,7 +34,7 @@ ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()
 
 std::string ASRockASRRGBSMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -66,7 +64,7 @@ void ASRockASRRGBSMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, ui
 {
     uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
     uint8_t select_led_pkt[1]  = { led };
-
+    
     /*-----------------------------------------------------*\
     | Select LED                                            |
     \*-----------------------------------------------------*/

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.h                             |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockASRRGBSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>
 
 #pragma once
 
-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t	polychrome_dev_id;
 
 #define ASROCK_ASR_CONTROLLER_NAME  "ASRock ASR RGB SMBus Controller"
@@ -64,7 +63,7 @@ public:
     uint8_t                 GetMode();
     void                    SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
     void                    SetMode(uint8_t zone, uint8_t mode, uint8_t speed);
-
+    
     uint16_t                fw_version;
 
 private:

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.h                               |
-|                                                           |
-|   RGBController for SMBus ASRock ASR RGB motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockASRRGBSMBusController.h"
-
-class RGBController_ASRockASRRGBSMBus : public RGBController
-{
-public:
-    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
-    ~RGBController_ASRockASRRGBSMBus();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockASRRGBSMBusController* controller;
-};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "ASRockPolychromeV1SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -36,7 +34,7 @@ ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()
 
 std::string ASRockPolychromeV1SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.h      |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
 
-#pragma once
-
-#include <string>
 #include "i2c_smbus.h"
 #include "RGBController.h"
+#include <string>
+
+#pragma once
 
 typedef uint8_t	polychrome_dev_id;
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV1SMBusController.h"
-
-class RGBController_ASRockPolychromeV1SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV1SMBus();
-
-    void        SetupZones();
-
-    void        DeviceConfigureZone(int zone_idx);
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
-};

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV2SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "ASRockPolychromeV2SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -37,7 +35,7 @@ ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()
 
 std::string ASRockPolychromeV2SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>
 
 #pragma once
 
-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t polychrome_dev_id;
 
 #define ASROCK_V2_CONTROLLER_NAME  "ASRock Polychrome v2 SMBus Controller"
@@ -133,7 +132,7 @@ public:
 
     uint8_t                 zone_led_count[6];
     uint16_t                fw_version;
-
+    
 private:
     std::string             device_name;
     uint8_t                 active_zone;

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -1,36 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV2SMBusController.h"
-
-class RGBController_ASRockPolychromeV2SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV2SMBus();
-
-    void        SetupZones();
-
-    void        DeviceConfigureZone(int zone_idx);
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV2SMBusController* controller;
-};

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -1,26 +1,26 @@
-/*---------------------------------------------------------*\
-| ASRockSMBusControllerDetect.cpp                           |
-|                                                           |
-|   Detector for SMBus ASRock ASR RGB and Polychrome        |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
 #include "LogManager.h"
+#include "RGBController.h"
 #include "RGBController_ASRockASRRGBSMBus.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*******************************************************************************************\
+*                                                                                           *
+*   TestForPolychromeSMBusController                                                        *
+*                                                                                           *
+*       Tests the given address to see if an ASRock RGB controller exists there.            *
+*       First does a quick write to test for a response                                     *
+*                                                                                           *
+\*******************************************************************************************/
 
 #define ASROCK_DETECTOR_NAME        "ASRock SMBus Detectector"
 #define VENDOR_NAME                 "ASRock"
@@ -58,7 +58,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)
 
     return(pass);
 
-}
+}   /* TestForPolychromeController() */
 
 uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
 {
@@ -85,54 +85,64 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
-{
-    DetectedControllers detected_controllers;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPolychromeControllers                                                            *
+*                                                                                          *
+*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
+*       address 0x6A.                                                                      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
+*           dev - I2C address of Polychrome device                                         *
+*                                                                                          *
+\******************************************************************************************/
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+{
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                 // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
                 {
                     LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
 
                     u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
 
-                    switch(version.msb)
+                    switch (version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
                                 LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
-                                detected_controllers.push_back(rgb_controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
                             }
                             break;
 
                             case ASROCK_TYPE_POLYCHROME_V1:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
-                                detected_controllers.push_back(rgb_controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
                             }
                             break;
 
                             case ASROCK_TYPE_POLYCHROME_V2:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
-                                detected_controllers.push_back(rgb_controller);
+                                ResourceManager::get()->RegisterRGBController(rgb_controller);
                             }
                             break;
 
@@ -153,7 +163,6 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
         }
     }
 
-    return(detected_controllers);
-}
+}   /* DetectSMBusPolychromeControllers() */
 
 REGISTER_I2C_DETECTOR("ASRock Motherboard SMBus Controllers", DetectASRockSMBusControllers);

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.cpp                             |
-|                                                           |
-|   RGBController for SMBus ASRock ASR LED motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_ASRockASRRGBSMBus.h"
 
@@ -113,8 +111,6 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB
 
 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -137,6 +133,7 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     new_zone->leds_min      = 1;
     new_zone->leds_max      = 1;
     new_zone->leds_count    = 1;
+    new_zone->matrix_map    = NULL;
 
     /*---------------------------------------------------------*\
     | Push new zone to zones vector                             |
@@ -161,20 +158,27 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     SetupColors();
 }
 
+void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-        DeviceUpdateSingleLED(led);
+        UpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockASRRGBSMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockASRRGBSMBus::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
+void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.h    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockASRRGBSMBusController.h"
+
+class RGBController_ASRockASRRGBSMBus : public RGBController
+{
+public:
+    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
+    ~RGBController_ASRockASRRGBSMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockASRRGBSMBusController* controller;
+};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
@@ -230,8 +227,6 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -269,6 +264,7 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
             new_zone->leds_min      = 1;
             new_zone->leds_max      = 1;
             new_zone->leds_count    = 1;
+            new_zone->matrix_map    = NULL;
 
             if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
             {
@@ -298,9 +294,10 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
+void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
 {
-    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
+    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    controller-> SetARGBSize(new_size & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 
@@ -309,19 +306,19 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
     LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
     for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
     {
-        DeviceUpdateSingleLED(zone_idx);
+        UpdateSingleLED(zone_idx);
     }
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
 {
-    LOG_TRACE("[%s] DeviceUpdateZoneLEDs()", name.c_str());
+    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
 {
-    LOG_TRACE("[%s] DeviceUpdateSingleLED(%02X)", name.c_str(), zone);
+    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
 
     uint8_t red = RGBGetRValue(colors[zone]);
     uint8_t grn = RGBGetGValue(colors[zone]);
@@ -338,7 +335,7 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
         for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
         {
             controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
-            DeviceUpdateSingleLED(zone_idx);
+            UpdateSingleLED(zone_idx);
         }
     }
     else

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV1SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV1SMBusController.h"
+
+class RGBController_ASRockPolychromeV1SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV1SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
+};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV2SMBus.cpp|
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 
@@ -185,8 +182,6 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR
 
 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -231,6 +226,8 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_zone->type          = ZONE_TYPE_SINGLE;
             }
 
+            new_zone->matrix_map        = NULL;
+
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/
@@ -281,7 +278,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
+void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -290,18 +287,18 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/
 
 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-        DeviceUpdateSingleLED(led);
+        UpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV2SMBus::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
+void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromev2SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV2SMBusController.h"
+
+class RGBController_ASRockPolychromeV2SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV2SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV2SMBusController* controller;
+};

Controllers/AlienwareController/AlienwareController.cpp

@@ -1,14 +1,13 @@
-/*---------------------------------------------------------*\
-| AlienwareController.cpp                                   |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 21 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.cpp                  |
+|                                           |
+|  Driver for Alienware lighting controller |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/21/2021    |
+\*-----------------------------------------*/
 
+#include "RGBController.h"
+#include "AlienwareController.h"
 #include <cstring>
 #include <cstdint>
 #include <map>
@@ -16,10 +15,6 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "RGBController.h"
-#include "AlienwareController.h"
-#include "LogManager.h"
-#include "StringUtils.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -29,11 +24,8 @@ typedef uint32_t alienware_platform_id;
 \*---------------------------------------------------------*/
 static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
-    { 0x0C01,   4 },    // Dell G5 SE 5505
-    { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 },    // Dell G15   5511
-    { 0x0E0A,   4 }     // Dell G15   5530
-
+    { 0x0C01,   4 }, // Dell G5 SE 5505
+    { 0x0A01,  16 }  // Dell G7 15 7500
 };
 
 /*---------------------------------------------------------*\
@@ -47,9 +39,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
                   "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
-                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
-    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -90,7 +80,9 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
     /*-----------------------------------------------------*\
     | Get serial number                                     |
     \*-----------------------------------------------------*/
-    serial_number       = StringUtils::wstring_to_string(info.serial_number);
+    std::wstring tmp_serial_number;
+    tmp_serial_number   = info.serial_number;
+    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
 
     /*-----------------------------------------------------*\
     | Get zone information by checking firmware             |
@@ -99,11 +91,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
     report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
     alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];
 
-    /*-----------------------------------------------------*\
-    | Check if the device reports the wrong number of zones |
-    \*-----------------------------------------------------*/
-    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
-
     /*-----------------------------------------------------*\
     | Get firmware version                                  |
     \*-----------------------------------------------------*/
@@ -114,6 +101,11 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
     fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
     version             = fw_string.str();
 
+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
     /*-----------------------------------------------------*\
     | Initialize Alienware zones                            |
     \*-----------------------------------------------------*/
@@ -121,13 +113,10 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
 
     if(zone_names_table.count(platform_id))
     {
-        LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
         zone_names = zone_names_table.at(platform_id);
     }
     else
     {
-        LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
-
         /*-------------------------------------------------*\
         | If this is an unknown controller, set the name of |
         | all regions to "Unknown"                          |
@@ -171,7 +160,7 @@ AlienwareController::~AlienwareController()
 
 unsigned int AlienwareController::GetZoneCount()
 {
-    return((unsigned int)zones.size());
+    return(zones.size());
 }
 
 std::vector<const char*> AlienwareController::GetZoneNames()
@@ -276,7 +265,7 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -380,7 +369,7 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -519,7 +508,7 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones      = (uint16_t)zones.size();
+    uint16_t num_zones      = zones.size();
 
     usb_buf[0x00]           = 0x00;
     usb_buf[0x01]           = 0x03;
@@ -655,7 +644,7 @@ void AlienwareController::UpdateDim()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        dim_zone_map[zones[i].dim].emplace_back(i);
     }
 
     for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -682,7 +671,7 @@ bool AlienwareController::UpdateDirect()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        color_zone_map[zones[i].color[0]].emplace_back(i);
     }
 
     for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)

Controllers/AlienwareController/AlienwareController.h

@@ -1,27 +1,25 @@
-/*---------------------------------------------------------*\
-| AlienwareController.h                                     |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.h                    |
+|                                           |
+|  Driver for Dell Alienware RGB USB        |
+|  controller                               |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Alienware Controller                                                           |
 \*----------------------------------------------------------------------------------------------*/
 
 #define ALIENWARE_REPORT_SIZE               33
 #define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-#define ALIENWARE_CONTROLLER_NAME           "AlienWare Controller"
+
 enum
 {
     ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -1,14 +1,6 @@
-/*---------------------------------------------------------*\
-| AlienwareControllerDetect.cpp                             |
-|                                                           |
-|   Detector for Dell Alienware RGB USB controller          |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
+#include "Detector.h"
 #include "AlienwareController.h"
-#include "DetectionManager.h"
+#include "RGBController.h"
 #include "RGBController_Alienware.h"
 
 /*---------------------------------------------------------*\
@@ -19,26 +11,19 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID1                      0x0550
-#define ALIENWARE_G_SERIES_PID2                      0x0551
+#define ALIENWARE_G_SERIES_PID                         0x0550
 
-DetectedControllers DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareController*     controller     = new AlienwareController(dev, *info, name);
         RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID2);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -1,17 +1,16 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.cpp                               |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware USB Driver                     |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_Alienware.h"
 
 #include <thread>
 #include <chrono>
-#include "RGBController_Alienware.h"
 
 /**------------------------------------------------------------------*\
     @name Alienware
@@ -125,13 +124,6 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     controller->UpdateDim();
 }
 
-RGBController_Alienware::~RGBController_Alienware()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_Alienware::SetupZones()
 {
     /*-------------------------------------------------*\
@@ -148,6 +140,7 @@ void RGBController_Alienware::SetupZones()
         new_zone.leds_min   = 1;
         new_zone.leds_max   = 1;
         new_zone.leds_count = 1;
+        new_zone.matrix_map = nullptr;
 
         zones.emplace_back(new_zone);
     }
@@ -164,19 +157,26 @@ void RGBController_Alienware::SetupZones()
     SetupColors();
 }
 
+void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_Alienware::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_Alienware::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_Alienware::DeviceUpdateSingleLED(int led)
+void RGBController_Alienware::UpdateSingleLED(int led)
 {
-    DeviceUpdateZoneLEDs(led);
+    UpdateZoneLEDs(led);
 }
 
 static bool modes_eq(const mode& mode1, const mode& mode2)
@@ -213,7 +213,7 @@ void RGBController_Alienware::DeviceUpdateMode()
         /*-----------------------------------------------------*\
         | Setup state per zone                                  |
         \*-----------------------------------------------------*/
-        for(uint8_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
         {
             zone current_zone = zones[zone_idx];
 

Controllers/AlienwareController/RGBController_Alienware.h

@@ -1,31 +1,31 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.h                                 |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware RGB USB Driver                 |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
 
 #pragma once
 
-#include <chrono>
 #include "RGBController.h"
 #include "AlienwareController.h"
 
+#include <chrono>
+
 class RGBController_Alienware : public RGBController
 {
 public:
     RGBController_Alienware(AlienwareController* controller_ptr);
-    ~RGBController_Alienware();
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.cpp

@@ -1,453 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <cstring>
-#include "AlienwareAW410KController.h"
-#include "StringUtils.h"
-
-AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name)
-{
-    dev         = dev_handle;
-    location    = path;
-    name        = dev_name;
-
-    SendCommit();
-}
-
-AlienwareAW410KController::~AlienwareAW410KController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareAW410KController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareAW410KController::GetDeviceName()
-{
-    return(name);
-}
-
-std::string AlienwareAW410KController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-void AlienwareAW410KController::SendCommit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x0A]           = 0x10;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0C]           = 0x01;
-    usb_buf[0x0D]           = 0x02;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-}
-
-void AlienwareAW410KController::SendfeatureReport
-    (
-    unsigned char   first_byte,
-    unsigned char   second_byte,
-    unsigned char   third_byte,
-    unsigned char   forth_byte
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Feature report packet                          |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = first_byte;
-    usb_buf[0x02]           = second_byte;
-    usb_buf[0x03]           = third_byte;
-    usb_buf[0x04]           = forth_byte;
-
-    /*-----------------------------------------------------*\
-    | Send Feature report packet                            |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 10 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-}
-
-void AlienwareAW410KController::SendEdit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Edit packet                                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x01;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendInitialize()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = 0xAD;
-    usb_buf[0x06]           = 0x80;
-    usb_buf[0x07]           = 0x10;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SetDirect
-    (
-    unsigned char   /*zone*/,
-    unsigned char   r,
-    unsigned char   g,
-    unsigned char   b
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x01;
-    usb_buf[0x04]           = r;
-    usb_buf[0x05]           = g;
-    usb_buf[0x06]           = b;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW410KController::SendDirectOn
-    (
-    std::vector<SelectedButtons>     &frame_data
-    )
-{
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
-
-    /*-----------------------------------------------*\
-    | To Guarantee the data are always %4 =0 append   |
-    | zeros at end of last packet                     |
-    \*-----------------------------------------------*/
-    for(unsigned int i = 0; i < (frame_data.size() % 4); i++)
-    {
-        SelectedButtons key;
-        key.idx     = 0x00;
-        key.red     = 0x00;
-        key.green   = 0x00;
-        key.blue    = 0x00;
-
-        frame_data.push_back(key);
-    }
-
-    unsigned char usb_buf[65];
-    unsigned int  frame_idx = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 65);
-
-    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
-    {
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0x0E;
-        usb_buf[0x02]           = 0x01;
-        usb_buf[0x03]           = 0x00;
-        usb_buf[0x04]           = ++frame_idx;
-        usb_buf[0x05]           = frame_data[packet_idx].idx;
-        usb_buf[0x06]           = 0x81;
-        usb_buf[0x07]           = 0x00;
-        usb_buf[0x08]           = 0xA5;
-        usb_buf[0x0A]           = 0x0A;
-        usb_buf[0x0B]           = frame_data[packet_idx].red;
-        usb_buf[0x0C]           = frame_data[packet_idx].green;
-        usb_buf[0x0D]           = frame_data[packet_idx].blue;
-        usb_buf[0x12]           = 0x01;
-
-        usb_buf[0x14]           = frame_data[++packet_idx].idx;
-        usb_buf[0x15]           = 0x81;
-        usb_buf[0x16]           = 0x00;
-        usb_buf[0x17]           = 0xA5;
-        usb_buf[0x19]           = 0x0A;
-        usb_buf[0x1A]           = frame_data[packet_idx].red;
-        usb_buf[0x1B]           = frame_data[packet_idx].green;
-        usb_buf[0x1C]           = frame_data[packet_idx].blue;
-        usb_buf[0x21]           = 0x01;
-
-        usb_buf[0x23]           = frame_data[++packet_idx].idx;
-        usb_buf[0x24]           = 0x81;
-        usb_buf[0x25]           = 0x00;
-        usb_buf[0x26]           = 0xA5;
-        usb_buf[0x28]           = 0x0A;
-        usb_buf[0x29]           = frame_data[packet_idx].red;
-        usb_buf[0x2A]           = frame_data[packet_idx].green;
-        usb_buf[0x2B]           = frame_data[packet_idx].blue;
-        usb_buf[0x30]           = 0x01;
-
-        usb_buf[0x32]           = frame_data[++packet_idx].idx;
-        usb_buf[0x33]           = 0x81;
-        usb_buf[0x34]           = 0x00;
-        usb_buf[0x35]           = 0xA5;
-        usb_buf[0x37]           = 0x0A;
-        usb_buf[0x38]           = frame_data[packet_idx].red;
-        usb_buf[0x39]           = frame_data[packet_idx].green;
-        usb_buf[0x3A]           = frame_data[packet_idx].blue;
-        usb_buf[0x3F]           = 0x01;
-
-        hid_write(dev, (unsigned char *)usb_buf, 65);
-    }
-}
-
-
-void AlienwareAW410KController::SetMode
-    (
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendMode(ALIENWARE_AW410K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
-    SendCommit();
-}
-
-void AlienwareAW410KController::DeviceUpdateSingleLED
-    (
-    unsigned char   led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
-
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Single LED packet                              |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = led;
-    usb_buf[0x06]           = 0x81;
-    usb_buf[0x07]           = 0x00;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x09]           = 0x00;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x0B]           = red;
-    usb_buf[0x0C]           = green;
-    usb_buf[0x0D]           = blue;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
-}
-void AlienwareAW410KController::SendMode
-    (
-    unsigned char   /*zone*/,
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Mode Control packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red;
-    usb_buf[0x05]           = green;
-    usb_buf[0x06]           = blue;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = colorMode;
-    usb_buf[0x0F]           = direction;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AlienwareAW410KController::SetMorphMode
-    (
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   red1,
-    unsigned char   green1,
-    unsigned char   blue1,
-    unsigned char   red2,
-    unsigned char   green2,
-    unsigned char   blue2
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Morph Mode packet                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red1;
-    usb_buf[0x05]           = green1;
-    usb_buf[0x06]           = blue1;
-    usb_buf[0x07]           = red2;
-    usb_buf[0x08]           = green2;
-    usb_buf[0x09]           = blue2;
-    usb_buf[0x0E]           = 0x02;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.h

@@ -1,157 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.h                               |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_MODE_KEYBOARD         = 0x01,
-};
-
-enum
-{
-    ALIENWARE_AW410K_ZONE_DIRECT_KEYBOARD       = 0x01,
-    ALIENWARE_AW410K_ZONE_DIRECT_MEDIA          = 0x02,
-    ALIENWARE_AW410K_ZONE_DIRECT_INDICATORS     = 0x40,
-};
-
-enum
-{
-    ALIENWARE_AW410K_MODE_OFF                   = 0x00,
-    ALIENWARE_AW410K_MODE_DIRECT                = 0x01,
-    ALIENWARE_AW410K_MODE_PULSE                 = 0x02,
-    ALIENWARE_AW410K_MODE_MORPH                 = 0x03,
-    ALIENWARE_AW410K_MODE_BREATHING             = 0x07,
-    ALIENWARE_AW410K_MODE_SPECTRUM              = 0x08,
-    ALIENWARE_AW410K_MODE_SINGLE_WAVE           = 0x0F,
-    ALIENWARE_AW410K_MODE_RAINBOW_WAVE          = 0x10,
-    ALIENWARE_AW410K_MODE_SCANNER               = 0x11,
-    ALIENWARE_AW410K_MODE_STATIC                = 0x13,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
-    ALIENWARE_AW410K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
-    ALIENWARE_AW410K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
-};
-
-enum
-{
-    ALIENWARE_AW410K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
-    ALIENWARE_AW410K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
-    ALIENWARE_AW410K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
-    ALIENWARE_AW410K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
-};
-
-enum
-{
-    ALIENWARE_AW410K_SINGLE_COLOR_MODE          = 0x01,
-    ALIENWARE_AW410K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
-    ALIENWARE_AW410K_RANBOW_COLOR_MODE          = 0x03,
-};
-
-struct SelectedButtons
-{
-    unsigned char idx;
-    unsigned char red;
-    unsigned char green;
-    unsigned char blue;
-};
-
-class AlienwareAW410KController
-{
-public:
-    AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name);
-    ~AlienwareAW410KController();
-
-    std::string GetDeviceLocation();
-    std::string GetDeviceName();
-    std::string GetSerialString();
-
-    void        SendInitialize();
-    void        SendCommit();
-    void        SendfeatureReport
-                    (
-                    unsigned char   first_byte,
-                    unsigned char   second_byte,
-                    unsigned char   third_byte,
-                    unsigned char   forth_byte
-                    );
-
-    void        SendEdit();
-
-    void        SetDirect
-                    (
-                    unsigned char   zone,
-                    unsigned char   r,
-                    unsigned char   g,
-                    unsigned char   b
-                    );
-
-    void    SendDirectOn
-                    (
-                    std::vector<SelectedButtons>     &frame_data
-                    );
-
-    void        SetMode
-                    (
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-    void        SetMorphMode
-                    (
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   red1,
-                    unsigned char   green1,
-                    unsigned char   blue1,
-                    unsigned char   red2,
-                    unsigned char   green2,
-                    unsigned char   blue2
-                    );
-
-    void        DeviceUpdateSingleLED
-                    (
-                    unsigned char   led,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-    std::string             name;
-
-    void        SendMode
-                    (
-                    unsigned char   zone,
-                    unsigned char   mode,
-                    unsigned char   speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-};

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW410K.h                           |
-|                                                           |
-|   RGBController for Alienware AW410K keyboard             |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW410KController.h"
-
-class RGBController_AlienwareAW410K : public RGBController
-{
-public:
-    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
-    ~RGBController_AlienwareAW410K();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW410KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

@@ -1,23 +1,19 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.cpp            |
+|                                           |
+|  Driver for Alienware AW510K              |
+|  keyboard light controller                |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "AlienwareAW510KController.h"
-#include "StringUtils.h"
+#include <cstring>
 
-AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name)
+AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
     location    = path;
-    name        = dev_name;
 
     SendCommit();
 }
@@ -32,27 +28,20 @@ std::string AlienwareAW510KController::GetDeviceLocation()
     return("HID: " + location);
 }
 
-std::string AlienwareAW510KController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AlienwareAW510KController::GetSerialString()
 {
     wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    hid_get_serial_number_string(dev, serial_string, 128);
 
-    if(ret != 0)
-    {
-        return("");
-    }
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
 
-    return(StringUtils::wstring_to_string(serial_string));
+    return(return_string);
 }
 
 void AlienwareAW510KController::SendCommit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -74,7 +63,7 @@ void AlienwareAW510KController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -82,6 +71,7 @@ void AlienwareAW510KController::SendCommit()
     std::this_thread::sleep_for(std::chrono::milliseconds(20));
 }
 
+
 void AlienwareAW510KController::SendfeatureReport
     (
     unsigned char   first_byte,
@@ -90,7 +80,7 @@ void AlienwareAW510KController::SendfeatureReport
     unsigned char   forth_byte
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -109,7 +99,7 @@ void AlienwareAW510KController::SendfeatureReport
     /*-----------------------------------------------------*\
     | Send Feature report packet                            |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 10 milliseconds                                 |
@@ -119,7 +109,7 @@ void AlienwareAW510KController::SendfeatureReport
 
 void AlienwareAW510KController::SendEdit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -137,7 +127,7 @@ void AlienwareAW510KController::SendEdit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -147,7 +137,7 @@ void AlienwareAW510KController::SendEdit()
 
 void AlienwareAW510KController::SendInitialize()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -172,7 +162,7 @@ void AlienwareAW510KController::SendInitialize()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -226,7 +216,7 @@ void AlienwareAW510KController::SendDirectOn
     std::vector<SelectedKeys>     &frame_data
     )
 {
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
 
     /*-----------------------------------------------*\
     | To Guarantee the data are always %4 =0 append   |
@@ -306,7 +296,7 @@ void AlienwareAW510KController::SendDirectOn
 void AlienwareAW510KController::SetMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -318,7 +308,7 @@ void AlienwareAW510KController::SetMode
     SendCommit();
 }
 
-void AlienwareAW510KController::DeviceUpdateSingleLED
+void AlienwareAW510KController::UpdateSingleLED
     (
     unsigned char   led,
     unsigned char   red,
@@ -328,7 +318,7 @@ void AlienwareAW510KController::DeviceUpdateSingleLED
 {
     SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
 
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -358,7 +348,7 @@ void AlienwareAW510KController::DeviceUpdateSingleLED
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -370,7 +360,7 @@ void AlienwareAW510KController::SendMode
     (
     unsigned char   /*zone*/,
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -378,7 +368,7 @@ void AlienwareAW510KController::SendMode
     unsigned char   blue
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -404,13 +394,13 @@ void AlienwareAW510KController::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void AlienwareAW510KController::SetMorphMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   red1,
     unsigned char   green1,
     unsigned char   blue1,
@@ -419,7 +409,7 @@ void AlienwareAW510KController::SetMorphMode
     unsigned char   blue2
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -448,5 +438,5 @@ void AlienwareAW510KController::SetMorphMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }

Controllers/AlienwareKeyboardController/AlienwareAW510KController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.h                               |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.h              |
+|                                           |
+|  Definitions and types for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#pragma once
+#include "RGBController.h"
 
 #include <string>
-#include <hidapi.h>
-#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
 
 enum
 {
@@ -77,11 +76,10 @@ struct SelectedKeys
 class AlienwareAW510KController
 {
 public:
-    AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AlienwareAW510KController(hid_device* dev_handle, const char* path);
     ~AlienwareAW510KController();
 
     std::string GetDeviceLocation();
-    std::string GetDeviceName();
     std::string GetSerialString();
 
     void        SendInitialize();
@@ -112,7 +110,7 @@ public:
     void        SetMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,
@@ -123,7 +121,7 @@ public:
     void        SetMorphMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   red1,
                     unsigned char   green1,
                     unsigned char   blue1,
@@ -132,7 +130,7 @@ public:
                     unsigned char   blue2
                     );
 
-    void        DeviceUpdateSingleLED
+    void        UpdateSingleLED
                     (
                     unsigned char   led,
                     unsigned char   red,
@@ -143,13 +141,12 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 
     void        SendMode
                     (
                     unsigned char   zone,
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.h                           |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW510KController.h"
-
-class RGBController_AlienwareAW510K : public RGBController
-{
-public:
-    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
-    ~RGBController_AlienwareAW510K();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW510KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,65 +1,38 @@
-/*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
-|                                                           |
-|   Detector for Alienware Keyboard                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "DetectionManager.h"
-#include "AlienwareAW410KController.h"
+#include "Detector.h"
 #include "AlienwareAW510KController.h"
-#include "RGBController_AlienwareAW410K.h"
+#include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
+#include <hidapi/hidapi.h>
 
-/*---------------------------------------------------------*\
-| Alienware vendor ID                                       |
-\*---------------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
+/*-----------------------------------------------------*\
+| Alienware vendor ID                                   |
+\*-----------------------------------------------------*/
+#define ALIENWARE_VID           0x04F2
 
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define ALIENWARE_AW510K_PID    0x1830
 
-DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAlienwareKeyboardControllers                                                     *
+*                                                                                          *
+*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
-        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
+        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path);
         RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
-
-        detected_controllers.push_back(rgb_controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
+}   /* DetectAlienwareKeyboardControllers() */
 
-    return(detected_controllers);
-}
-
-DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
-        RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
 
 REGISTER_HID_DETECTOR_IPU("Alienware 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/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.cpp                         |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.cpp        |
+|                                           |
+|  Generic RGB Interface for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#include <iterator>
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AlienwareAW510K.h"
+#include <iterator>
 
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
@@ -47,9 +45,9 @@ typedef struct
     const char *        name;
     const unsigned char zone;
     const unsigned char idx;
-} aw510k_led_type;
+} led_type;
 
-static const aw510k_led_type led_names[] =
+static const led_type led_names[] =
 {
     /* Key Label                Zone,                                      Index  */
     { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
@@ -175,7 +173,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 {
     controller                      = controller_ptr;
 
-    name                            = controller->GetDeviceName();
+    name                            = "Alienware AW510K Keyboard Device";
     vendor                          = "Alienware";
     type                            = DEVICE_TYPE_KEYBOARD;
     description                     = "Alienware AW510K Keyboard Device";
@@ -277,7 +275,16 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 
 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    Shutdown();
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
 
     delete controller;
 }
@@ -300,7 +307,14 @@ void RGBController_AlienwareAW510K::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 7;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
         }
 
         zones.push_back(new_zone);
@@ -319,6 +333,13 @@ void RGBController_AlienwareAW510K::SetupZones()
     SetupColors();
 }
 
+void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
 {
     std::vector<SelectedKeys>   frame_buf_keys;
@@ -372,21 +393,21 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
     std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }
 
-void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
 {
     controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }
 
-void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
+void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)
     {
-        UpdateLEDsInternal();
+        UpdateLEDs();
         return;
     }
 

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.h          |
+|                                           |
+|  Generic RGB Interface for Alienware      |
+|  AW510K keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW510KController.h"
+
+class RGBController_AlienwareAW510K : public RGBController
+{
+public:
+    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
+    ~RGBController_AlienwareAW510K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW510KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController.cpp

@@ -1,183 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW3423DWFController.cpp                          |
-|                                                           |
-|   Driver for the 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 <bitset>
-#include <chrono>
-#include <cstring>
-#include <thread>
-
-#include "AlienwareAW3423DWFController.h"
-#include "StringUtils.h"
-
-AlienwareAW3423DWFController::AlienwareAW3423DWFController(hid_device *dev_handle, const char *path) : dev(dev_handle), location(path){}
-
-void AlienwareAW3423DWFController::SendControlPacket(const unsigned char *data, size_t length)
-{
-    unsigned char buffer[256] = {0x00};
-    memcpy(buffer + 1, data, length);
-
-    hid_write(dev, buffer, length + 1);
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
-{
-    uint8_t buffer[193];
-
-    memset(buffer, 0, 193);
-
-    hid_get_input_report(dev, buffer, 193);
-
-    return std::vector<unsigned char>(buffer + 1, buffer + 18);
-}
-
-void AlienwareAW3423DWFController::PerformLogin()
-{
-    unsigned char init_packet[64] =
-    {
-        0x40, 0xE1, 0x01
-    };
-    SendControlPacket(init_packet, 4);
-
-    std::vector<unsigned char> response = GetReportResponse();
-
-    std::vector<unsigned char> key = GenerateKey(response);
-
-    unsigned char login_packet[192] = {0x00};
-    login_packet[0] = 0x40;
-    login_packet[1] = 0xE1;
-    login_packet[2] = 0x02;
-    memcpy(login_packet + 64, key.data(), key.size());
-
-    SendControlPacket(login_packet, 192);
-}
-
-void AlienwareAW3423DWFController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
-{
-    unsigned char led_id_2 = (led_id == 0x01) ? 0xf6 : (led_id == 0x02) ? 0xf5
-                                                   : (led_id == 0x08)   ? 0xff
-                                                                        : 0xfc;
-    PerformLogin();
-
-    unsigned char color_packet[192] = {0x00};
-
-    color_packet[0]  = 0x40;
-    color_packet[1]  = 0xC6;
-    color_packet[6]  = 0x0A;
-    color_packet[8]  = 0x6E;
-    color_packet[10] = 0x82;
-    color_packet[64] = 0x51;
-    color_packet[65] = 0x87;
-    color_packet[66] = 0xD0;
-    color_packet[67] = 0x04;
-
-    color_packet[68] = led_id;
-    color_packet[69] = r;
-    color_packet[70] = g;
-    color_packet[71] = b;
-    color_packet[72] = 0x64;
-    color_packet[73] = led_id_2;
-
-    SendControlPacket(color_packet, 192);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(200));
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GenerateKey(
-    const std::vector<unsigned char> &response)
-{
-    std::vector<unsigned char> syn_key(8, 0);
-
-    const std::vector<unsigned char> oem_key = {
-        0xf5, 0x3f, 0xc1, 0x39, 0x44, 0x3a, 0x31, 0x79, 0x0d, 0xb1, 0x82, 0x76
-    };
-
-    size_t sk_idx = 0, ok_idx = 0;
-    while(ok_idx < oem_key.size() && sk_idx < 8)
-    {
-        unsigned char ok_sub_len = (oem_key[ok_idx] & 1) + ((oem_key[ok_idx] & 0x10) >> 4);
-
-        for(unsigned int i = 0; i < ok_sub_len && sk_idx < 8; i++)
-        {
-            syn_key[sk_idx] = oem_key[ok_idx + 1] ^ oem_key[ok_idx];
-            ok_idx++;
-            sk_idx++;
-        }
-        ok_idx++;
-    }
-
-    std::vector<unsigned char> out_buffer;
-
-    uint16_t v15 = static_cast<uint16_t>(response[15]) |
-                   (static_cast<uint16_t>(response[0]) << 8);
-    bool parity_odd = (std::bitset<16>(v15).count() % 2 != 0);
-
-    if(parity_odd)
-    {
-        size_t end = std::min<size_t>(8, response.size());
-        out_buffer = std::vector<unsigned char>(response.begin(), response.begin() + end);
-
-        if(response.size() > 14)
-        {
-            unsigned char idx = response[14] & 0x07;
-            if((idx + 8) < (unsigned char)response.size())
-            {
-                out_buffer[idx] ^= response[idx + 8];
-            }
-        }
-    }
-    else
-    {
-        size_t start = std::min<size_t>(8, response.size());
-        size_t end = std::min<size_t>(start + 8, response.size());
-        out_buffer = std::vector<unsigned char>(response.begin() + start, response.begin() + end);
-
-        if(response.size() > 6)
-        {
-            unsigned char idx = response[6] & 0x07;
-            if(idx < response.size())
-            {
-                out_buffer[idx] ^= response[idx];
-            }
-        }
-    }
-
-    for(size_t i = 0; i < 8 && i < out_buffer.size(); i++)
-    {
-        syn_key[i] ^= out_buffer[i];
-    }
-
-    return syn_key;
-}
-
-AlienwareAW3423DWFController::~AlienwareAW3423DWFController()
-{
-    if(dev)
-    {
-        hid_close(dev);
-        dev = nullptr;
-    }
-}
-
-std::string AlienwareAW3423DWFController::GetLocation()
-{
-    return "HID: " + location;
-}
-
-std::string AlienwareAW3423DWFController::GetSerialString()
-{
-    wchar_t serial[256];
-    if(hid_get_serial_number_string(dev, serial, 256) >= 0)
-    {
-        std::wstring ws(serial);
-        return StringUtils::wstring_to_string(ws);
-    }
-    return "";
-}

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController.h

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW3423DWFController.h                            |
-|                                                           |
-|   Driver for the 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               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <hidapi.h>
-#include <vector>
-#include <string>
-
-class AlienwareAW3423DWFController
-{
-public:
-    AlienwareAW3423DWFController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW3423DWFController();
-
-    std::string GetLocation();
-    std::string GetSerialString();
-    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
-
-private:
-    hid_device* dev;
-    std::string location;
-
-    static const std::vector<std::vector<unsigned char>> OEM_KEYS;
-
-    void PerformLogin();
-    std::vector<unsigned char> GenerateKey(const std::vector<unsigned char>& response);
-    void SendControlPacket(const unsigned char* data, size_t length);
-    std::vector<unsigned char> GetReportResponse();
-};

Controllers/AlienwareMonitorController/AlienwareMonitorController.cpp

@@ -1,146 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorController.cpp                            |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <chrono>
-#include <cstring>
-#include <thread>
-
-#include "AlienwareMonitorController.h"
-
-AlienwareMonitorController::AlienwareMonitorController(hid_device *dev_handle, const char *path, std::string dev_name)
-{
-    dev         = dev_handle;
-    location    = path;
-    name        = dev_name;
-
-    Initialize();
-}
-
-AlienwareMonitorController::~AlienwareMonitorController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareMonitorController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareMonitorController::GetName()
-{
-    return(name);
-}
-
-std::string AlienwareMonitorController::GetSerialString()
-{
-    return("");
-}
-
-void fillInChecksum(unsigned char *packet)
-{
-    unsigned char checksum = 110;
-
-    for(unsigned int index = 5; index <= 13; index++)
-    {
-      checksum ^= packet[index];
-    }
-
-    packet[14] = checksum;
-}
-
-void AlienwareMonitorController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
-{
-    unsigned char packet[65];
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[0] = 0x00;
-    packet[1] = 0x92;
-    packet[2] = 0x37;
-    packet[3] = 0x0a;
-    packet[4] = 0x00;
-    packet[5] = 0x51;
-    packet[6] = 0x87;
-    packet[7] = 0xd0;
-    packet[8] = 0x04;
-
-    packet[9] = led_id;
-    packet[10] = r;
-    packet[11] = g;
-    packet[12] = b;
-    packet[13] = 0x64;
-
-    fillInChecksum(packet);
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-}
-
-void AlienwareMonitorController::Initialize()
-{
-    unsigned char packet[65];
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[0] = 0x00;
-    packet[1] = 0x95;
-    packet[2] = 0x00;
-    packet[3] = 0x00;
-    packet[4] = 0x00;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[0] = 0x00;
-    packet[1] = 0x92;
-    packet[2] = 0x37;
-    packet[3] = 0x08;
-    packet[4] = 0x00;
-    packet[5] = 0x51;
-    packet[6] = 0x85;
-    packet[7] = 0x01;
-    packet[8] = 0xFE;
-    packet[9] = 0x03;
-    packet[10] = 0x00;
-    packet[11] = 0x06;
-    packet[12] = 0x40;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-
-    memset(packet, 0x00, sizeof(packet));
-
-    packet[0] = 0x00;
-    packet[1] = 0x93;
-    packet[2] = 0x37;
-    packet[3] = 0x12;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-}

Controllers/AlienwareMonitorController/AlienwareMonitorController.h

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorController.h                              |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <hidapi.h>
-#include <vector>
-#include <string>
-
-class AlienwareMonitorController
-{
-public:
-AlienwareMonitorController(hid_device* dev_handle, const char* path, std::string dev_name);
-    ~AlienwareMonitorController();
-
-    std::string GetLocation();
-    std::string GetName();
-    std::string GetSerialString();
-    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
-
-private:
-    hid_device* dev;
-    std::string location;
-    std::string name;
-
-    void Initialize();
-};

Controllers/AlienwareMonitorController/AlienwareMonitorControllerDetect.cpp

@@ -1,69 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorControllerDetect.cpp                      |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
-#include "AlienwareAW3423DWFController.h"
-#include "AlienwareMonitorController.h"
-#include "DetectionManager.h"
-#include "RGBController_AlienwareAW3423DWF.h"
-#include "RGBController_AlienwareMonitor.h"
-
-/*---------------------------------------------------------*\
-| Alienware Vendor ID                                       |
-\*---------------------------------------------------------*/
-#define ALIENWARE_VID                               0x187C
-
-/*---------------------------------------------------------*\
-| 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;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
-        RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
-
-        detected_controllers.push_back(rgb_controller);
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
-REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -1,136 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW3423DWF.cpp                      |
-|                                                           |
-|   RGBController for the 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 "RGBController_AlienwareAW3423DWF.h"
-
-/**------------------------------------------------------------------*\
-    @name AW3423DWF
-    @category Accessory
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAlienwareAW3423DWFControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    name                    = "Alienware AW3423DWF";
-    vendor                  = "Alienware";
-    type                    = DEVICE_TYPE_MONITOR;
-    description             = "Alienware AW3423DWF Monitor Device";
-    location                = controller->GetLocation();
-    serial                  = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    active_mode             = 0;
-
-    SetupZones();
-}
-
-RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_AlienwareAW3423DWF::SetupZones()
-{
-    zone Logo;
-    Logo.name               = "Logo";
-    Logo.type               = ZONE_TYPE_SINGLE;
-    Logo.leds_min           = 1;
-    Logo.leds_max           = 1;
-    Logo.leds_count         = 1;
-    zones.push_back(Logo);
-
-    led Logo_LED;
-    Logo_LED.name           = "Logo";
-    Logo_LED.value          = 0x01;
-    leds.push_back(Logo_LED);
-
-    zone Number;
-    Number.name             = "Number";
-    Number.type             = ZONE_TYPE_SINGLE;
-    Number.leds_min         = 1;
-    Number.leds_max         = 1;
-    Number.leds_count       = 1;
-    zones.push_back(Number);
-
-    led Number_LED;
-    Number_LED.name         = "Number";
-    Number_LED.value        = 0x02;
-    leds.push_back(Number_LED);
-
-    zone PowerButton;
-    PowerButton.name        = "Power Button";
-    PowerButton.type        = ZONE_TYPE_SINGLE;
-    PowerButton.leds_min    = 1;
-    PowerButton.leds_max    = 1;
-    PowerButton.leds_count  = 1;
-    zones.push_back(PowerButton);
-
-    led PowerButton_LED;
-    PowerButton_LED.name    = "Power Button";
-    PowerButton_LED.value   = 0x08;
-    leds.push_back(PowerButton_LED);
-
-    SetupColors();
-}
-
-void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
-{
-    /*-----------------------------------------------------*\
-    | If all three colors are the same value, speed up the  |
-    | direct mode by using the ALL target (0x0B) instead of |
-    | setting each LED individually.                        |
-    \*-----------------------------------------------------*/
-    if((colors[0] == colors[1]) && (colors[1] == colors[2]))
-    {
-        unsigned char red = RGBGetRValue(colors[0]);
-        unsigned char grn = RGBGetGValue(colors[0]);
-        unsigned char blu = RGBGetBValue(colors[0]);
-        controller->SendColor(0x0B, red, grn, blu);
-    }
-    else
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            DeviceUpdateSingleLED(led_idx);
-        }
-    }
-}
-
-void RGBController_AlienwareAW3423DWF::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-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);
-}
-
-void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()
-{
-}

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.h

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW3423DWF.h                        |
-|                                                           |
-|   RGBController for the 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               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "AlienwareAW3423DWFController.h"
-#include "RGBController.h"
-
-class RGBController_AlienwareAW3423DWF : public RGBController
-{
-public:
-    explicit RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr);
-    ~RGBController_AlienwareAW3423DWF();
-
-    void        SetupZones();
-
-    void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW3423DWFController* controller;
-};