openrgb_qmk_testing

.gitignore

@@ -6,4 +6,3 @@ qrc_*
 OpenRGB
 Makefile
 OpenRGB-x86_64.AppImage
-.qmake.stash

60-openrgb.rules

@@ -68,7 +68,6 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c12", TAG+="uacces
 #       Corsair LS100                                           #
 #       Corsair 1000D Obsidian                                  #
 #       Corsair Spec Omega RGB                                  #
-#       Corsair LT100                                           #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1a", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c0b", TAG+="uaccess"
@@ -76,7 +75,6 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c10", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1e", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d00", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d04", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Corsair Peripheral Devices                                   #
@@ -136,28 +134,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uacces
 #                                                               #
 #  Keyboards:                                                   #
 #       HyperX Alloy Elite                                      #
-#                                                               #
-#  Mice:                                                        #
-#       HyperX Pulsefire Surge                                  #
-#                                                               #
-#  Mousemats:                                                   #
-#       HyperX Fury Ultra                                       #
 #---------------------------------------------------------------#
 SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Logitech Peripheral Devices                                  #
 #                                                               #
-#   Keyboards:                                                  #
-#       Logitech G213                                           #
-#       Logitech G512                                           #
-#       Logitech G512 RGB                                       #
-#       Logitech G610                                           #
-#       Logitech G810 #1                                        #
-#       Logitech G810 #2                                        #
-#                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
 #       Logitech G203 Lightsync                                 #
@@ -166,29 +148,28 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uacces
 #       Logitech G502 Proteus Spectrum                          #
 #       Logitech G Lightspeed Wireless Gaming Mouse             #
 #       Logitech G Pro Wireless Gaming Mouse (Wired)            #
-#                                                               #
-#  Mousemats:                                                   #
 #       Logitech G Powerplay Mousepad with Lightspeed           #
 #                                                               #
+#   Keyboards:                                                  #
+#       Logitech G512                                           #
+#       Logitech G512 RGB                                       #
+#       Logitech G810 #1                                        #
+#       Logitech G810 #2                                        #
 #---------------------------------------------------------------#
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
-
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
-
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
 
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
+
 #---------------------------------------------------------------#
 #  MSI Mysticlight                                              #
 #---------------------------------------------------------------#
@@ -273,7 +254,6 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0c45", ATTR{idProduct}=="652f", TAG+="uacces
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc30", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc39", TAG+="uaccess"
-SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc4d", TAG+="uaccess"
 
 #---------------------------------------------------------------#
 #  Gigabyte/Aorus RGB Fusion 2 USB                              #

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -2,8 +2,8 @@
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
+#include <vector>
 #include <hidapi/hidapi.h>
-
 #define AMD_WRAITH_PRISM_VID 0x2516
 #define AMD_WRAITH_PRISM_PID 0x0051
 
@@ -15,16 +15,40 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    info = hid_enumerate(AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+
+    //Look for AMD Wraith Prism
+    while(info)
     {
-        AMDWraithPrismController* controller = new AMDWraithPrismController(dev, info->path);
-        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        if((info->vendor_id == AMD_WRAITH_PRISM_VID)
+         &&(info->product_id == AMD_WRAITH_PRISM_PID)
+#if USE_HID_USAGE
+         &&(info->interface_number == 1)
+         &&(info->usage_page == 0xFF00))
+#else
+         &&(info->interface_number == 1))
+#endif
+        {
+            dev = hid_open_path(info->path);
+        
+            if( dev )
+            {
+                AMDWraithPrismController* controller = new AMDWraithPrismController(dev, info->path);
+
+                RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+        info = info->next;
     }
 }
 
-REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);
+REGISTER_DETECTOR("AMD Wraith Prism", DetectAMDWraithPrismControllers);

Controllers/AorusCPUCoolerController/AorusCPUCoolerControllerDetect.cpp

@@ -0,0 +1,87 @@
+#include "Detector.h"
+#include "RGBController.h"
+#include "ATC800Controller.h"
+#include "RGBController_AorusATC800.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Vendor ID                                             |
+\*-----------------------------------------------------*/
+#define HOLTEK_VID                            0x1044
+
+/*-----------------------------------------------------*\
+| Controller product ids                                |
+\*-----------------------------------------------------*/
+#define ATC_800_CONTROLLER_PID                0x7A42
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    char            usb_interface;
+    device_type     type;
+    const char *    name;
+} device;
+
+#define NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const device device_list[] =
+{
+    { HOLTEK_VID,             ATC_800_CONTROLLER_PID,                  0,  DEVICE_TYPE_KEYBOARD,   "Aorus ATC800 CPU Cooler"                             },
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAorusCPUCoolerControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if a Aorus RGB CPU Cooler exists there.               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAorusCPUCoolerControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_init();
+
+    for(unsigned int device_idx = 0; device_idx < NUM_DEVICES; device_idx++)
+    {
+        hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE                    
+            &&(info->interface_number == device_list[device_idx].usb_interface)
+            &&(info->usage_page == 0xFF01)
+            &&(info->usage == 1))
+#else
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+            {
+                hid_device* dev = hid_open_path(info->path);
+
+                if(dev)
+                {
+                    switch(device_list[device_idx].usb_pid)
+                    {
+                    case ATC_800_CONTROLLER_PID:
+                        {
+                            ATC800Controller* controller = new ATC800Controller(dev, info->path);
+
+                            RGBController_AorusATC800* rgb_controller = new RGBController_AorusATC800(controller);
+
+                            rgb_controller->name = device_list[device_idx].name;
+                            rgb_controllers.push_back(rgb_controller);
+                        }
+                        break;
+                    }
+                }
+            }
+        info = info->next;
+        }
+        hid_free_enumeration(info);
+    }
+}
+
+REGISTER_DETECTOR("Aorus CPU Coolers", DetectAorusCPUCoolerControllers);

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -1,31 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraCoreController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraCore.h"
-#include <hidapi/hidapi.h>
-
-#define AURA_CORE_VID 0x0B05
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraCoreControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AuraCoreController* controller = new AuraCoreController(dev);
-        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -1,76 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraAddressableController.h"
-#include "AsusAuraMainboardController.h"
-#include "AsusAuraMouseController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraUSB.h"
-#include "RGBController_AsusAuraMouse.h"
-#include <stdexcept>
-#include <hidapi/hidapi.h>
-
-#define AURA_USB_VID                            0x0B05
-#define AURA_TERMINAL_PID                       0x1889
-#define AURA_ADDRESSABLE_1_PID                  0x1867
-#define AURA_ADDRESSABLE_2_PID                  0x1872
-#define AURA_ADDRESSABLE_3_PID                  0x18A3
-#define AURA_ADDRESSABLE_4_PID                  0x18A5
-#define AURA_MOTHERBOARD_1_PID                  0x18F3
-#define AURA_MOTHERBOARD_2_PID                  0x1939
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        try
-        {
-            AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
-            rgb_controller->name = name;
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        catch(std::runtime_error&)
-        {
-            // reading the config table failed
-        }
-    }
-}
-
-void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        AuraMouseController* controller = new AuraMouseController(dev, info->path);
-        RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",     DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",      DetectAsusAuraUSBAddressable,  AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",      DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",   DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,   0, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",        DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,        2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice,         AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);

Controllers/AuraCoreController/AuraCoreController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraCoreController.cpp               | 
+|  AuraCoreController.cpp                   | 
 |                                           |
 |  Driver for ASUS ROG Aura Core RGB        |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 4/13/2020   |
 \*-----------------------------------------*/
 
-#include "AsusAuraCoreController.h"
+#include "AuraCoreController.h"
 #include <cstring>
 
 AuraCoreController::AuraCoreController(hid_device* dev_handle)

Controllers/AuraCoreController/AuraCoreController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraCoreController.h                 |
+|  AuraCoreController.h                     |
 |                                           |
 |  Definitions and types for ASUS ROG Aura  |
 |  Core RGB lighting controller             |

Controllers/AuraCoreController/AuraCoreControllerDetect.cpp

@@ -0,0 +1,48 @@
+#include "Detector.h"
+#include "AuraCoreController.h"
+#include "RGBController.h"
+#include "RGBController_AuraCore.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define AURA_CORE_VID 0x0B05
+
+#define NUM_PIDS 3
+static const unsigned short pid_table[] =
+    {
+    0x1854,
+    0x1869,
+    0x1866
+    };
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraCoreControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for Asus ROG Aura Core RGB controller
+    hid_init();
+
+    for(int pid_idx = 0; pid_idx < NUM_PIDS; pid_idx++)
+    {
+        dev = hid_open(AURA_CORE_VID, pid_table[pid_idx], 0);
+
+        if( dev )
+        {
+            AuraCoreController* controller = new AuraCoreController(dev);
+
+            RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}
+
+REGISTER_DETECTOR("ASUS Aura Core", DetectAuraCoreControllers);

Controllers/AuraCoreController/RGBController_AuraCore.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraCore.cpp           |
+|  RGBController_AuraCore.cpp               |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 4/17/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraCore.h"
+#include "RGBController_AuraCore.h"
 
 RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
 {

Controllers/AuraCoreController/RGBController_AuraCore.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraCore.h             |
+|  RGBController_AuraCore.h                 |
 |                                           |
 |  Generic RGB Interface for ROG Aura Core  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AsusAuraCoreController.h"
+#include "AuraCoreController.h"
 
 class RGBController_AuraCore : public RGBController
 {

Controllers/AuraGPUController/AuraGPUController.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUController.cpp                |
+|  AuraGPUController.cpp                    |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/
 
-#include "AsusAuraGPUController.h"
+#include "AuraGPUController.h"
 #include <cstring>
 
 AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)

Controllers/AuraGPUController/AuraGPUController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUController.h                  |
+|  AuraGPUController.h                      |
 |                                           |
 |  Definitions for ASUS Aura RGB on GPUs    |
 |                                           |

Controllers/AuraGPUController/AuraGPUControllerDetect.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUControllerDetect.cpp          |
+|  AuraGPUControllerDetect.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB on GPUs         |
 |                                           |
@@ -7,9 +7,9 @@
 \*-----------------------------------------*/
 
 #include "Detector.h"
-#include "AsusAuraGPUController.h"
+#include "AuraGPUController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraGPU.h"
+#include "RGBController_AuraGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -38,7 +38,7 @@ static const unsigned char aura_gpu_addresses[] =
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -63,7 +63,7 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
     AuraGPUController* new_aura_gpu;
     RGBController_AuraGPU* new_controller;
@@ -73,7 +73,7 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std
         // Add Aura-enabled GPU controllers
         for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
         {
-            if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
             {
                 new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
                 new_controller = new RGBController_AuraGPU(new_aura_gpu);
@@ -85,4 +85,4 @@ void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std
     }
 } /* DetectAuraGPUControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAuraGPUControllers);

Controllers/AuraGPUController/RGBController_AuraGPU.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
+|  RGBController_AuraGPU.h                  |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
 |  Jan Rettig (Klapstuhl) 14.02.2020        |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraGPU.h"
+#include "RGBController_AuraGPU.h"
 
 int RGBController_AuraGPU::GetDeviceMode()
 {

Controllers/AuraGPUController/RGBController_AuraGPU.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
+|  RGBController_AuraGPU.h                  |
 |                                           |
 |  Generic RGB Interface for Asus Aura GPU  |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AsusAuraGPUController.h"
+#include "AuraGPUController.h"
 
 class RGBController_AuraGPU : public RGBController
 {

Controllers/AuraSMBusController/AuraSMBusController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraSMBusController.cpp              |
+|  AuraSMBusController.cpp                  |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
-#include "AsusAuraSMBusController.h"
+#include "AuraSMBusController.h"
 #include <cstring>
 
 static const char* aura_channels[] =                /* Aura channel strings                 */

Controllers/AuraSMBusController/AuraSMBusController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
+|  AuraSMBusController.h                    |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |

Controllers/AuraSMBusController/AuraSMBusControllerDetect.cpp

@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "AsusAuraSMBusController.h"
+#include "AuraSMBusController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraSMBus.h"
+#include "RGBController_AuraSMBus.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -64,7 +64,7 @@ static const unsigned char aura_mobo_addresses[] =
 *                                                                                          *
 \******************************************************************************************/
 
-void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
+void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
 {
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -83,7 +83,7 @@ void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_regis
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -122,7 +122,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
     AuraSMBusController* new_aura;
     RGBController_AuraSMBus* new_controller;
@@ -159,15 +159,15 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
 
                 if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
                 {
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                    AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
+                    AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
+                    AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
                 }
             }
 
             // Add Aura-enabled controllers at their remapped addresses
             for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
             {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
+                if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
                 {
                     new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
                     new_controller = new RGBController_AuraSMBus(new_aura);
@@ -183,7 +183,7 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
         {
             for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
             {
-                if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+                if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
                 {
                     new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
                     new_controller = new RGBController_AuraSMBus(new_aura);
@@ -197,4 +197,4 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
 
 }   /* DetectAuraSMBusControllers() */
 
-REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);
+REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAuraSMBusControllers);

Controllers/AuraSMBusController/RGBController_AuraSMBus.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraSMBus.cpp          |
+|  RGBController_AuraSMBus.cpp              |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/13/2019   |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraSMBus.h"
+#include "RGBController_AuraSMBus.h"
 
 int RGBController_AuraSMBus::GetDeviceMode()
 {

Controllers/AuraSMBusController/RGBController_AuraSMBus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraSMBus.h            |
+|  RGBController_AuraSMBus.h                |
 |                                           |
 |  Generic RGB Interface for OpenAuraSDK    |
 |  Asus Aura SMBus driver                   |
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "RGBController.h"
-#include "AsusAuraSMBusController.h"
+#include "AuraSMBusController.h"
 
 class RGBController_AuraSMBus : public RGBController
 {

Controllers/AuraUSBController/AuraAddressableController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraAddressableController.cpp        |
+|  AuraAddressableController.cpp            |
 |                                           |
 |  Driver for ASUS Aura RGB Addressable     |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
-#include "AsusAuraAddressableController.h"
+#include "AuraAddressableController.h"
 #include <cstring>
 
 AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)

Controllers/AuraUSBController/AuraAddressableController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraAddressableController.h          |
+|  AuraAddressableController.h              |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  Addressable RGB lighting controller      |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
-#include "AsusAuraUSBController.h"
+#include "AuraUSBController.h"
 
 #include <string>
 #include <hidapi/hidapi.h>

Controllers/AuraUSBController/AuraMainboardController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraMainboardController.cpp          |
+|  AuraMainboardController.cpp              |
 |                                           |
 |  Driver for ASUS Aura RGB USB mainboard   |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/
 
-#include "AsusAuraMainboardController.h"
+#include "AuraMainboardController.h"
 #include <cstring>
 
 AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)

Controllers/AuraUSBController/AuraMainboardController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraMainboardController.h            |
+|  AuraMainboardController.h                |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB Mainboard RGB lighting controller    |
@@ -8,7 +8,7 @@
 \*-----------------------------------------*/
 
 #include "RGBController.h"
-#include "AsusAuraUSBController.h"
+#include "AuraUSBController.h"
 
 #include <string>
 #include <hidapi/hidapi.h>

Controllers/AuraUSBController/AuraMouseController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraMouseController.cpp              |
+|  AuraMouseController.cpp                  |
 |                                           |
 |  Driver for ASUS Aura RGB USB             |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 10/23/2020  |
 \*-----------------------------------------*/
 
-#include "AsusAuraMouseController.h"
+#include "AuraMouseController.h"
 
 #include <cstring>
 

Controllers/AuraUSBController/AuraMouseController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraMouseController.h                |
+|  AuraMouseController.h                    |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |

Controllers/AuraUSBController/AuraUSBController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraUSBController.cpp                |
+|  AuraUSBController.cpp                    |
 |                                           |
 |  Driver for ASUS Aura RGB USB             |
 |  lighting controller                      |
@@ -7,7 +7,7 @@
 |  Martin Hartl (inlart) 4/25/2020          |
 \*-----------------------------------------*/
 
-#include "AsusAuraUSBController.h"
+#include "AuraUSBController.h"
 #include <cstring>
 #include <stdexcept>
 

Controllers/AuraUSBController/AuraUSBController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraUSBController.h                  |
+|  AuraUSBController.h                      |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |

Controllers/AuraUSBController/AuraUSBControllerDetect.cpp

@@ -0,0 +1,170 @@
+#include "Detector.h"
+#include "AuraAddressableController.h"
+#include "AuraMainboardController.h"
+#include "AuraMouseController.h"
+#include "RGBController.h"
+#include "RGBController_AuraUSB.h"
+#include "RGBController_AuraMouse.h"
+#include <vector>
+#include <stdexcept>
+#include <hidapi/hidapi.h>
+
+#define AURA_USB_VID                            0x0B05
+#define AURA_TERMINAL_PID                       0x1889
+#define AURA_ADDRESSABLE_1_PID                  0x1867
+#define AURA_ADDRESSABLE_2_PID                  0x1872
+#define AURA_ADDRESSABLE_3_PID                  0x18A3
+#define AURA_ADDRESSABLE_4_PID                  0x18A5
+#define AURA_MOTHERBOARD_1_PID                  0x18F3
+#define AURA_MOTHERBOARD_2_PID                  0x1939
+#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
+#define AURA_ROG_GLADIUS_II_PID                 0x1845
+#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned short  usb_interface;
+    const char *    name;
+} aura_device;
+
+#define ADDRESSABLE_NUM_DEVICES (sizeof(addressable_device_list) / sizeof(addressable_device_list[ 0 ]))
+
+static const aura_device addressable_device_list[] =
+{
+/*---------------------------------------------------------------------------------*\
+| ASUS AURA Addressable                                                             |
+\*---------------------------------------------------------------------------------*/
+    { AURA_USB_VID,     AURA_TERMINAL_PID,          0,  "ASUS ROG AURA Terminal"    },
+    { AURA_USB_VID,     AURA_ADDRESSABLE_1_PID,     0,  "ASUS Aura Addressable"     },
+    { AURA_USB_VID,     AURA_ADDRESSABLE_2_PID,     0,  "ASUS Aura Addressable"     },
+    { AURA_USB_VID,     AURA_ADDRESSABLE_3_PID,     0,  "ASUS Aura Addressable"     },
+    { AURA_USB_VID,     AURA_ADDRESSABLE_4_PID,     0,  "ASUS Aura Addressable"     },
+};
+
+#define MOTHERBOARD_NUM_DEVICES (sizeof(motherboard_device_list) / sizeof(motherboard_device_list[ 0 ]))
+
+static const aura_device motherboard_device_list[] =
+{
+/*---------------------------------------------------------------------------------*\
+| ASUS AURA Motherboard                                                             |
+\*---------------------------------------------------------------------------------*/
+    { AURA_USB_VID,     AURA_MOTHERBOARD_1_PID,     0,  "ASUS Aura Motherboard"     },
+    { AURA_USB_VID,     AURA_MOTHERBOARD_2_PID,     0,  "ASUS Aura Motherboard"     },
+};
+
+#define MOUSE_NUM_DEVICES (sizeof(mouse_device_list) / sizeof(mouse_device_list[ 0 ]))
+
+static const aura_device mouse_device_list[] =
+{
+    { AURA_USB_VID,     AURA_ROG_GLADIUS_II_CORE_PID,   0,  "ASUS ROG Gladius II Core"      },
+    { AURA_USB_VID,     AURA_ROG_GLADIUS_II_PID,        2,  "ASUS ROG Gladius II"           },
+    { AURA_USB_VID,     AURA_ROG_GLADIUS_II_ORIGIN_PID, 2,  "ASUS ROG Gladius II Origin"    },
+};
+
+void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info = NULL;
+
+    hid_init();
+
+    /*ASUS AURA Addressable*/
+    for(unsigned int pid_idx = 0; pid_idx < ADDRESSABLE_NUM_DEVICES; pid_idx++)
+    {
+        info = hid_enumerate(addressable_device_list[pid_idx].usb_vid, addressable_device_list[pid_idx].usb_pid);
+
+        while(info)
+        {
+            hid_device* dev = NULL;
+
+            if((info->vendor_id  == addressable_device_list[pid_idx].usb_vid)
+             &&(info->product_id == addressable_device_list[pid_idx].usb_pid))
+            {
+                dev = hid_open_path(info->path);
+
+                if(dev)
+                {
+                    AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
+                    RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+                    rgb_controller->name = addressable_device_list[pid_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
+    }
+
+    info = NULL;
+
+    /*ASUS AURA Motherboard*/
+    for(unsigned int pid_idx = 0; pid_idx < MOTHERBOARD_NUM_DEVICES; pid_idx++)
+    {
+        info = hid_enumerate(motherboard_device_list[pid_idx].usb_vid, motherboard_device_list[pid_idx].usb_pid);
+
+        while(info)
+        {
+            hid_device* dev = NULL;
+
+            if((info->vendor_id  == motherboard_device_list[pid_idx].usb_vid)
+             &&(info->product_id == motherboard_device_list[pid_idx].usb_pid))
+            {
+                dev = hid_open_path(info->path);
+
+                if(dev)
+                {
+                    try
+                    {
+                        AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
+                        RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+                        rgb_controller->name = motherboard_device_list[pid_idx].name;
+                        rgb_controllers.push_back(rgb_controller);
+                    }
+                    catch(std::runtime_error&)
+                    {
+                        // reading the config table failed
+                    }
+                }
+            }
+
+            info = info->next;
+        }
+    }
+
+    /*ASUS AURA Mouse*/
+    for(unsigned int pid_idx = 0; pid_idx < MOUSE_NUM_DEVICES; pid_idx++)
+    {
+        info = hid_enumerate(mouse_device_list[pid_idx].usb_vid, mouse_device_list[pid_idx].usb_pid);
+
+        while(info)
+        {
+            hid_device* dev = NULL;
+
+            if((info->vendor_id  == mouse_device_list[pid_idx].usb_vid)
+             &&(info->product_id == mouse_device_list[pid_idx].usb_pid)
+#ifdef USE_HID_USAGE
+             &&(info->interface_number == mouse_device_list[pid_idx].usb_interface )
+             &&(info->usage_page == 0xFF01))
+#else
+             &&(info->interface_number == mouse_device_list[pid_idx].usb_interface ))
+#endif
+            {
+                dev = hid_open_path(info->path);
+
+                if(dev)
+                {
+                    AuraMouseController* controller = new AuraMouseController(dev, info->path);
+                    RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
+                    rgb_controller->name = mouse_device_list[pid_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
+    }
+
+}  /* DetectAuraUSBControllers() */
+
+REGISTER_DETECTOR("ASUS Aura USB", DetectAuraUSBControllers);

Controllers/AuraUSBController/RGBController_AuraMouse.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.cpp          |
+|  RGBController_AuraMouse.cpp              |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 10/25/2020  |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraMouse.h"
+#include "RGBController_AuraMouse.h"
 
 RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
 {

Controllers/AuraUSBController/RGBController_AuraMouse.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.h            |
+|  RGBController_AuraMouse.h                |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -9,7 +9,7 @@
 
 #pragma once
 #include "RGBController.h"
-#include "AsusAuraMouseController.h"
+#include "AuraMouseController.h"
 
 class RGBController_AuraMouse : public RGBController
 {

Controllers/AuraUSBController/RGBController_AuraUSB.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.cpp            |
+|  RGBController_AuraUSB.cpp                |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 1/18/2020   |
 \*-----------------------------------------*/
 
-#include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AuraUSB.h"
 
 RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr)
 {

Controllers/AuraUSBController/RGBController_AuraUSB.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.h              |
+|  RGBController_AuraUSB.h                  |
 |                                           |
 |  Generic RGB Interface for Asus Aura      |
 |  USB controller driver                    |
@@ -9,7 +9,7 @@
 
 #pragma once
 #include "RGBController.h"
-#include "AsusAuraUSBController.h"
+#include "AuraUSBController.h"
 
 #define AURA_ADDRESSABLE_MAX_LEDS       120
 

Controllers/CoolerMasterController/CMMP750Controller.cpp

@@ -27,25 +27,20 @@ static unsigned char speed_mode_data[][9] =
     { 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath                */
 };
 
-CMMP750Controller::CMMP750Controller(hid_device* dev_handle, char *_path)
+CMMP750Controller::CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
 {
-    dev             = dev_handle;
-    location        = _path;
+    std::size_t tmp_size    = wcslen(_vendor);
+    dev                     = dev_handle;
+    location                = _path;
 
-    const int szTemp = 256;
-    wchar_t tmpName[szTemp];
-
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name        = std::string(wName.begin(), wName.end());
-
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName  = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    wName  = std::wstring(tmpName);
-    serial = std::string(wName.begin(), wName.end());
+    for(std::size_t i = 0; (i < tmp_size) && (i < CM_DEVICE_NAME_SIZE); i++)
+    {
+        device_name[i] = (char)_vendor[i];
+    }
+    for(std::size_t j = 0; (j < wcslen(_vendor)) && (tmp_size + j < CM_DEVICE_NAME_SIZE); j++)
+    {
+        device_name[tmp_size + j] = (char)_device_name[j];
+    }
 
     GetStatus();        //When setting up device get current status
 }
@@ -87,12 +82,12 @@ void CMMP750Controller::GetStatus()
     }
 }
 
-std::string CMMP750Controller::GetDeviceName()
+char* CMMP750Controller::GetDeviceName()
 {
     return device_name;
 }
 
-std::string CMMP750Controller::GetSerial()
+char* CMMP750Controller::GetSerial()
 {
     return serial;
 }

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -60,11 +60,11 @@ enum
 class CMMP750Controller
 {
 public:
-    CMMP750Controller(hid_device* dev_handle, char *_path);
+    CMMP750Controller(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
     ~CMMP750Controller();
 
-    std::string GetDeviceName();
-    std::string GetSerial();
+    char* GetDeviceName();
+    char* GetSerial();
     std::string GetLocation();
 
     unsigned char GetMode();
@@ -76,8 +76,8 @@ public:
     void SetColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
-    std::string             device_name;
-    std::string             serial;
+    char                    device_name[32];
+    char                    serial[32];
     std::string             location;
     hid_device*             dev;
 

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -12,6 +12,24 @@
 #define COOLERMASTER_MP750_MEDIUM_PID   0x0105
 #define COOLERMASTER_ARGB_PID           0x1011
 
+#define COOLERMASTER_NUM_DEVICES (sizeof(cm_pids) / sizeof(cm_pids[ 0 ]))
+
+struct coolermaster_device
+{
+    unsigned int    product_id;
+    unsigned short  interface;
+    unsigned int    usage_page;
+    unsigned int    usage;
+    device_type     type;
+};
+
+static const coolermaster_device cm_pids[] =
+{  // PID,                              Interface,  Usage_Page, Usage,  Device_Type
+    { COOLERMASTER_MP750_XL_PID,        0x00,       0xFF00,     0x01,   DEVICE_TYPE_MOUSEMAT  },    //Coolermaster MP750 (Extra Large)
+    { COOLERMASTER_MP750_MEDIUM_PID,    0x00,       0xFF00,     0x01,   DEVICE_TYPE_MOUSEMAT  },    //Coolermaster MP750 (Medium)
+    { COOLERMASTER_ARGB_PID,            0x00,       0xFF00,     0x01,   DEVICE_TYPE_LEDSTRIP  }     //Coolermaster ARGB Controller
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCoolerMasterControllers                                                          *
@@ -20,33 +38,60 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCoolerMasterMousemats(hid_device_info* info, const std::string&)
+void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
-        RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
+    hid_device_info* info;
 
-void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
+    //Look for the passed in cm_pids
+    hid_init();
+    info = hid_enumerate(COOLERMASTER_VID, 0x0);
+
+    while(info)
     {
-        for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
+        hid_device* dev = NULL;
+        device_type dev_type;
+
+        if(info->vendor_id == COOLERMASTER_VID)
         {
-            CMARGBController* controller = new CMARGBController(dev, info->path, i);
-            RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
-            // Constructor sets the name
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            for(unsigned int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
+            {
+                if((info->product_id        == cm_pids[cm_pid_idx].product_id)
+#ifdef USE_HID_USAGE
+                    &&(info->usage             == cm_pids[cm_pid_idx].usage)     //Usage and usage page required to get the correct interface
+                    &&(info->usage_page        == cm_pids[cm_pid_idx].usage_page))
+#else
+                    &&(info->interface_number  == cm_pids[cm_pid_idx].interface))
+#endif  //USE_HID_USAGE
+                {
+                    dev         = hid_open_path(info->path);
+                    dev_type    = cm_pids[cm_pid_idx].type;
+                    break;
+                }
+            }
         }
-    }
-}
 
-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 XL",     DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID,     0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 Medium", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_MEDIUM_PID, 0, 0xFF00, 1);
-REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB",         DetectCoolerMasterARGB,      COOLERMASTER_VID, COOLERMASTER_ARGB_PID,         0, 0xFF00, 1);
+        if(dev)
+        {
+            if (dev_type == DEVICE_TYPE_MOUSEMAT)
+            {
+                CMMP750Controller* controller                   = new CMMP750Controller(dev, info->manufacturer_string, info->product_string, info->path);
+                RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
+            else if(dev_type == DEVICE_TYPE_LEDSTRIP)
+            {
+                for(std::size_t i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
+                {
+                    CMARGBController* controller = new CMARGBController(dev, info->path, i);
+                    RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+        }
+        info = info->next;
+    }
+    hid_free_enumeration(info);
+
+}   /* DetectCoolerMasterControllers() */
+
+REGISTER_DETECTOR("Cooler Master", DetectCoolerMasterControllers);

Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp

@@ -18,7 +18,7 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
     type                = DEVICE_TYPE_MOUSEMAT;
     description         = cmmp750->GetDeviceName();
     version             = "1.0";
-    serial              = cmmp750->GetSerial();
+    serial              = "";
     location            = cmmp750->GetLocation();
 
     mode Static;
@@ -143,5 +143,25 @@ void RGBController_CMMP750Controller::SetCustomMode()
 
 void RGBController_CMMP750Controller::DeviceUpdateMode()
 {
-    cmmp750->SetMode(modes[active_mode].value, modes[active_mode].speed);
+    switch(modes[active_mode].value)
+    {
+        case MP750_MODE_STATIC:
+            cmmp750->SetMode(MP750_MODE_STATIC, modes[active_mode].speed);
+            break;
+        case MP750_MODE_BLINK:
+            cmmp750->SetMode(MP750_MODE_BLINK, modes[active_mode].speed);
+            break;
+        case MP750_MODE_BREATHING:
+            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
+            break;
+        case MP750_MODE_COLOR_CYCLE:
+            cmmp750->SetMode(MP750_MODE_COLOR_CYCLE, modes[active_mode].speed);
+            break;
+        case MP750_MODE_BREATH_CYCLE:
+            cmmp750->SetMode(MP750_MODE_BREATH_CYCLE, modes[active_mode].speed);
+            break;
+        default:
+            cmmp750->SetMode(MP750_MODE_BREATHING, modes[active_mode].speed);
+            break;
+    }
 }

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -11,8 +11,32 @@
 #include <string>
 #include <cstring>
 
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
 using namespace std::chrono_literals;
 
+THREAD keepalive_thread(void *param)
+{
+    CorsairLightingNodeController* corsair = static_cast<CorsairLightingNodeController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
 CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_handle, const char* path)
 {
     dev         = dev_handle;
@@ -26,20 +50,21 @@ CorsairLightingNodeController::CorsairLightingNodeController(hid_device* dev_han
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&CorsairLightingNodeController::KeepaliveThread, this);
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
 }
 
 CorsairLightingNodeController::~CorsairLightingNodeController()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
 }
 
 void CorsairLightingNodeController::KeepaliveThread()
 {
-    while(keepalive_thread_run.load())
+    while(1)
     {
         if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(5))
         {

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -112,8 +112,6 @@ private:
     hid_device*             dev;
     std::string             firmware_version;
     std::string             location;
-    std::thread*            keepalive_thread;
-    std::atomic<bool>       keepalive_thread_run;
     std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
 
     void            SendFirmwareRequest();

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -12,7 +12,26 @@
 #define CORSAIR_LS100_PID               0x0C1E
 #define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
 #define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
-#define CORSAIR_LT100_PID               0x0C23
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   channel_count;
+    const char *    name;
+} corsair_node_device;
+
+#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const corsair_node_device device_list[] =
+{
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_CORE_PID,     1,      "Corsair Lighting Node Core"    },
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_PRO_PID,      2,      "Corsair Lighting Node Pro"     },
+    { CORSAIR_VID,          CORSAIR_COMMANDER_PRO_PID,          2,      "Corsair Commander Pro"         },
+    { CORSAIR_VID,          CORSAIR_LS100_PID,                  1,      "Corsair LS100 Lighting Kit"    },
+    { CORSAIR_VID,          CORSAIR_1000D_OBSIDIAN_PID,         2,      "Corsair 1000D Obsidian"        },
+    { CORSAIR_VID,          CORSAIR_SPEC_OMEGA_RGB_PID,         2,      "Corsair SPEC OMEGA RGB"        }
+};
 
 /******************************************************************************************\
 *                                                                                          *
@@ -22,22 +41,42 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
+void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
     {
-        CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, info->path);
-        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Corsair Lighting Node Devices
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, info->path);
+
+                    RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
     }
 }   /* DetectCorsairLightingNodeControllers() */
 
-REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
-REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
-REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
-REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
-REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels
+REGISTER_DETECTOR("Corsair Lighting Node", DetectCorsairLightingNodeControllers);

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -60,10 +60,7 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
 
 CorsairPeripheralController::~CorsairPeripheralController()
 {
-    if(dev)
-    {
-        hid_close(dev);
-    }
+
 }
 
 device_type CorsairPeripheralController::GetDeviceType()

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -2,6 +2,7 @@
 #include "CorsairPeripheralController.h"
 #include "RGBController.h"
 #include "RGBController_CorsairPeripheral.h"
+#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -59,6 +60,56 @@
 \*-----------------------------------------------------*/
 #define CORSAIR_ST100_PID               0x0A34
 
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} corsair_node_device;
+
+#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const corsair_node_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+//  { CORSAIR_VID,          CORSAIR_K55_RGB_PID,                1,      "Corsair K55 RGB"                   }, //Not per-key, disabled for now
+    { CORSAIR_VID,          CORSAIR_K65_RGB_PID,                1,      "Corsair K65 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K65_LUX_RGB_PID,            1,      "Corsair K65 LUX RGB"               },
+    { CORSAIR_VID,          CORSAIR_K65_RGB_RAPIDFIRE_PID,      1,      "Corsair K65 RGB RAPIDFIRE"         },
+    { CORSAIR_VID,          CORSAIR_K68_RGB,                    1,      "Corsair K68 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_PID,                1,      "Corsair K70 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_LUX_RGB_PID,            1,      "Corsair K70 LUX RGB"               },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_RAPIDFIRE_PID,      1,      "Corsair K70 RGB RAPIDFIRE"         },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_PID,            1,      "Corsair K70 RGB MK.2"              },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_SE_PID,         1,      "Corsair K70 RGB MK.2 SE"           },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_LP_PID,         1,      "Corsair K70 RGB MK.2 Low Profile"  },
+    { CORSAIR_VID,          CORSAIR_K95_RGB_PID,                1,      "Corsair K95 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K95_PLATINUM_PID,           1,      "Corsair K95 RGB PLATINUM"          },
+    { CORSAIR_VID,          CORSAIR_STRAFE_PID,                 1,      "Corsair Strafe"                    },
+    { CORSAIR_VID,          CORSAIR_STRAFE_MK2_PID,             1,      "Corsair Strafe MK.2"               },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_GLAIVE_RGB_PRO_PID,         1,      "Corsair Glaive RGB PRO"            },
+    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PID,            1,      "Corsair Harpoon RGB"               },
+    { CORSAIR_VID,          CORSAIR_HARPOON_RGB_PRO_PID,        1,      "Corsair Harpoon RGB PRO"           },
+    { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
+    { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
+    { CORSAIR_VID,          CORSAIR_SCIMITAR_PRO_RGB_PID,       1,      "Corsair Scimitar PRO RGB"          },
+    { CORSAIR_VID,          CORSAIR_SABRE_RGB_PID,              1,      "Corsair Sabre RGB"                 },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Headset Stands                                                                                        |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_ST100_PID,                  0,      "Corsair ST100 RGB"                 }
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectCorsairPeripheralControllers                                                     *
@@ -67,58 +118,50 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string& name)
+void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
     {
-        CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
-        if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Corsair RGB Peripheral
+        while(info)
         {
-            RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
-            rgb_controller->name = name;
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete controller;
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+#ifdef USE_HID_USAGE
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->usage_page == 0xFFC2))
+#else
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    CorsairPeripheralController* controller = new CorsairPeripheralController(dev, info->path);
+
+                    if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+                    {
+                        RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+
+                        rgb_controller->name = device_list[device_idx].name;
+
+                        rgb_controllers.push_back(rgb_controller);
+                    }
+                }
+            }
+            info = info->next;
         }
     }
 }   /* DetectCorsairPeripheralControllers() */
 
-/*-----------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
-//REGISTER_HID_DETECTOR_IP("Corsair K55 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID,           1, 0xFFC2); // Not per-key, disabled for now
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K68 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K68_RGB,               1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 LUX RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_LUX_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB RAPIDFIRE",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2",             DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 SE",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_SE_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K70 RGB MK.2 Low Profile", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K70_RGB_MK2_LP_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_RGB_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair K95 RGB PLATINUM",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K95_PLATINUM_PID,      1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe",                   DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_PID,            1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_STRAFE_MK2_PID,        1, 0xFFC2);
-/*-----------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                  |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO",           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID,    1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB",              DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID,       1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO",          DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID,   1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 PRO",                  DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_PRO_PID,           1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair M65 RGB Elite" ,           DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_M65_RGB_ELITE_PID,     1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Scimitar PRO RGB",         DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SCIMITAR_PRO_RGB_PID,  1, 0xFFC2);
-REGISTER_HID_DETECTOR_IP("Corsair Sabre RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_SABRE_RGB_PID,         1, 0xFFC2);
-/*-----------------------------------------------------------------------------------------------------*\
-| Mousemats                                                                                             |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair MM800 RGB Polaris",        DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_MM800_RGB_POLARIS_PID, 0, 0xFFC2);
-/*-----------------------------------------------------------------------------------------------------*\
-| Headset Stands                                                                                        |
-\*-----------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Corsair ST100 RGB",                DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID,             0, 0xFFC2);
+REGISTER_DETECTOR("Corsair Peripheral", DetectCorsairPeripheralControllers);

Controllers/CrucialController/CrucialController.cpp

@@ -15,9 +15,6 @@ CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id de
 {
     this->bus = bus;
     this->dev = dev;
-
-    // We don't know what mode the sticks are in until we set one.
-    this->last_mode = CRUCIAL_MODE_UNKNOWN;
 }
 
 CrucialController::~CrucialController()
@@ -47,11 +44,7 @@ unsigned int CrucialController::GetLEDCount()
 
 void CrucialController::SetMode(unsigned char mode)
 {
-    // Don't set a mode if we've already set the same one before.
-    // This is mostly useful for direct mode and updating colors often.
-    if (mode == last_mode) return;
     SendEffectMode(mode, 0x10);
-    last_mode = mode;
 }
 
 void CrucialController::SetAllColorsDirect(RGBColor* colors)
@@ -87,8 +80,6 @@ void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)
 
 void CrucialController::SendDirectColors(RGBColor* color_buf)
 {
-    SetMode(CRUCIAL_MODE_STATIC);
-
     //Red Channels
     CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
     CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));

Controllers/CrucialController/CrucialController.h

@@ -18,7 +18,6 @@ typedef unsigned short	crucial_register;
 
 enum
 {
-    CRUCIAL_MODE_UNKNOWN            = 0x00,     /* We don't know what the mode is   */
     CRUCIAL_MODE_SHIFT              = 0x1F,     /* Shift effect mode                */
     CRUCIAL_MODE_GRADIENT_SHIFT     = 0x2F,     /* Gradient shift mode              */
     CRUCIAL_MODE_FILL               = 0x3F,     /* Fill effect mode                 */
@@ -54,7 +53,6 @@ private:
     unsigned char           config_table[64];
     unsigned int            led_count;
     unsigned char           channel_cfg;
-    unsigned char           last_mode;
     i2c_smbus_interface *   bus;
     crucial_dev_id          dev;
 

Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp

@@ -2,6 +2,7 @@
 #include "DuckyKeyboardController.h"
 #include "RGBController.h"
 #include "RGBController_DuckyKeyboard.h"
+#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -15,6 +16,25 @@
 #define DUCKY_SHINE_7_ONE_2_RGB_PID     0x0348
 #define DUCKY_ONE_2_RGB_TKL_PID         0x0356
 
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} ducky_device;
+
+#define DUCKY_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const ducky_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { DUCKY_VID,            DUCKY_SHINE_7_ONE_2_RGB_PID,        1,      "Ducky Shine 7/Ducky One 2 RGB"     },
+    { DUCKY_VID,            DUCKY_ONE_2_RGB_TKL_PID,            1,      "Ducky One 2 RGB TKL"               },
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectDuckyKeyboardControllers                                                         *
@@ -23,17 +43,42 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectDuckyKeyboardControllers(hid_device_info* info, const std::string& name)
+void DetectDuckyKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < DUCKY_NUM_DEVICES; device_idx++)
     {
-        DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path);
-        RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Ducky RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    DuckyKeyboardController* controller = new DuckyKeyboardController(dev, info->path);
+
+                    RGBController_DuckyKeyboard* rgb_controller = new RGBController_DuckyKeyboard(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+            info = info->next;
+        }
     }
 }   /* DetectDuckyKeyboardControllers() */
 
-REGISTER_HID_DETECTOR_I("Ducky Shine 7/Ducky One 2 RGB", DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_SHINE_7_ONE_2_RGB_PID, 1);
-REGISTER_HID_DETECTOR_I("Ducky One 2 RGB TKL",           DetectDuckyKeyboardControllers, DUCKY_VID, DUCKY_ONE_2_RGB_TKL_PID,     1);
+REGISTER_DETECTOR("Ducky Keyboard", DetectDuckyKeyboardControllers);

Controllers/E131Controller/RGBController_E131.cpp

@@ -261,21 +261,12 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
 
     if(keepalive_delay.count() > 0)
     {
-        keepalive_thread_run = 1;
-        keepalive_thread = new std::thread(&RGBController_E131::KeepaliveThreadFunction, this);
-    }
-    else
-    {
-        keepalive_thread_run = 0;
-        keepalive_thread = nullptr;
+        KeepaliveThread = new std::thread(&RGBController_E131::KeepaliveThreadFunction, this);
     }
 }
 
 RGBController_E131::~RGBController_E131()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
     \*---------------------------------------------------------*/
@@ -422,7 +413,7 @@ void RGBController_E131::DeviceUpdateMode()
 
 void RGBController_E131::KeepaliveThreadFunction()
 {
-    while(keepalive_thread_run.load())
+    while(1)
     {
         if((std::chrono::steady_clock::now() - last_update_time) > ( keepalive_delay * 0.95f ) )
         {

Controllers/E131Controller/RGBController_E131.h

@@ -78,8 +78,7 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-    std::thread *               keepalive_thread;
-    std::atomic<bool>           keepalive_thread_run;
+    std::thread *               KeepaliveThread;
     std::chrono::milliseconds                           keepalive_delay;
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/EKController/EKController.cpp

@@ -9,7 +9,7 @@
 
 #include "EKController.h"
 
-static unsigned char ek_colour_mode_data[][16] =
+static unsigned char colour_mode_data[][16] =
 {
     { 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
       0x00, 0x10, 0x20, 0x01, 0x01, 0x00, 0xFF, 0x64},          // Static
@@ -31,7 +31,7 @@ static unsigned char ek_colour_mode_data[][16] =
       0x00, 0x10, 0x20, 0x01, 0x09, 0x00, 0xFF, 0x64},          // Candle
 };
 
-static unsigned char ek_speed_mode_data[][9] =
+static unsigned char speed_mode_data[][9] =
 {
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // Static
     { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 },   // Breathing
@@ -44,24 +44,21 @@ static unsigned char ek_speed_mode_data[][9] =
     { 0x00, 0x0C, 0x19, 0x25, 0x32, 0x3E, 0x4B, 0x57, 0x64 }    // Candle
 };
 
-EKController::EKController(hid_device* dev_handle, char *_path)
+EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
 {
-    const int szTemp = 256;
-    wchar_t tmpName[szTemp];
+    std::size_t tmp_size = wcslen(_vendor);
 
     dev = dev_handle;
 
-    hid_get_manufacturer_string(dev, tmpName, szTemp);
-    std::wstring wName = std::wstring(tmpName);
-    device_name = std::string(wName.begin(), wName.end());
+    for(std::size_t i = 0; (i < tmp_size) && (i < EK_DEVICE_NAME_SIZE); i++)
+    {
+        device_name[i] = (char)_vendor[i];
+    }
 
-    hid_get_product_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
-
-    hid_get_serial_number_string(dev, tmpName, szTemp);
-    wName = std::wstring(tmpName);
-    serial = std::string(wName.begin(), wName.end());
+    for(std::size_t j = 0; (j < wcslen(_vendor)) && ((tmp_size + j) < EK_DEVICE_NAME_SIZE); j++)
+    {
+        device_name[tmp_size + j] = (char)_device_name[j];
+    }
 
     location = _path;
 
@@ -71,15 +68,18 @@ EKController::EKController(hid_device* dev_handle, char *_path)
 
 EKController::~EKController()
 {
-    hid_close(dev);
+    if(dev)
+    {
+        hid_close(dev);
+    }
 }
 
-std::string EKController::GetDeviceName()
+char* EKController::GetDeviceName()
 {
     return device_name;
 }
 
-std::string EKController::GetSerial()
+char* EKController::GetSerial()
 {
     return serial;
 }
@@ -113,14 +113,14 @@ void EKController::SendUpdate()
 
     for(std::size_t i = 0; i < EK_COLOUR_MODE_DATA_SIZE; i++)
     {
-        buffer[i] = ek_colour_mode_data[current_mode][i];
+        buffer[i] = colour_mode_data[current_mode][i];
     }
 
     //Set the relevant colour info
     buffer[EK_RED_BYTE]   = current_red;
     buffer[EK_GREEN_BYTE] = current_green;
     buffer[EK_BLUE_BYTE]  = current_blue;
-    buffer[EK_SPEED_BYTE] = ek_speed_mode_data[current_mode][current_speed];
+    buffer[EK_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
 
     buffer[10] = 0x10;
     buffer[47] = 0xFF;

Controllers/EKController/EKController.h

@@ -13,7 +13,7 @@
 #include <string>
 #include <hidapi/hidapi.h>
 
-#define EK_COLOUR_MODE_DATA_SIZE (sizeof(ek_colour_mode_data[0]) / sizeof(ek_colour_mode_data[0][0]))
+#define EK_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
 #define EK_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
 #define EK_PACKET_LENGTH    0x3F
 
@@ -55,19 +55,19 @@ enum
 class EKController
 {
 public:
-    EKController(hid_device* dev_handle, char *_path);
+    EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
     ~EKController();
 
-    std::string GetDeviceName();
-    std::string GetSerial();
+    char* GetDeviceName();
+    char* GetSerial();
     std::string GetLocation();
 
     void SetMode(unsigned char mode, unsigned char speed);
     void SetColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
-    std::string             device_name;
-    std::string             serial;
+    char                    device_name[32];
+    char                    serial[32];
     std::string             location;
     hid_device*             dev;
 

Controllers/EKController/EKControllerDetect.cpp

@@ -5,8 +5,22 @@
 #include <hidapi/hidapi.h>
 
 #define EK_VID                0x0483
+
 #define EK_LOOP_CONNECT       0x5750
 
+#define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))
+
+enum
+{
+    EK_PID = 0,
+    EK_INTERFACE = 1
+};
+
+static const unsigned int ek_pids[][2] =
+{  // PID,      Interface
+    { EK_LOOP_CONNECT,        0x00 }     //EK Loop Connect
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectEKControllers                                                                    *
@@ -15,17 +29,39 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectEKControllers(hid_device_info* info, const std::string&)
+void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
+    hid_device_info* info = NULL;
+
+    //Look for the passed in cm_pids
+    hid_init();
+    info = hid_enumerate(EK_VID, 0x0);
+
+    while(info)
     {
-        EKController* controller = new EKController(dev, info->path);
-        RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        hid_device* dev = NULL;
+        if(info->vendor_id == EK_VID)
+        {
+            for(unsigned int ek_pid_idx = 0; ek_pid_idx < EK_NUM_DEVICES; ek_pid_idx++)
+            {
+                if((info->product_id        == ek_pids[ek_pid_idx][EK_PID])
+                 &&(info->interface_number  == ek_pids[ek_pid_idx][EK_INTERFACE]))
+                {
+                    dev = hid_open_path(info->path);
+                    break;
+                }
+            }
+        }
+
+        if(dev)
+        {
+            EKController* controller = new EKController(dev, info->manufacturer_string, info->product_string, info->path);
+            RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
+            rgb_controllers.push_back(rgb_controller);
+        }
+        info = info->next;
     }
-    info = info->next;
+    hid_free_enumeration(info);
 }   /* DetectEKControllers() */
 
-REGISTER_HID_DETECTOR_IPU("EK Loop Connect", DetectEKControllers, EK_VID, EK_LOOP_CONNECT, 0, 0xFFA0, 1);
+REGISTER_DETECTOR("EK", DetectEKControllers);

Controllers/EKController/RGBController_EKController.cpp

@@ -7,6 +7,7 @@
 |                                                                     |
 \*-------------------------------------------------------------------*/
 
+
 #include "RGBController_EKController.h"
 
 RGBController_EKController::RGBController_EKController(EKController* _dev)

Controllers/EVGAGPUController/EVGAGPUControllerDetect.cpp

@@ -31,7 +31,6 @@ typedef struct
 static const gpu_pci_device device_list[] =
 {
     { NVIDIA_VEN,   NVIDIA_GTX1070_DEV,     EVGA_SUB_VEN,   EVGA_GTX1070_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1070 FTW"             },
-    { NVIDIA_VEN,   NVIDIA_GTX1080_DEV,     EVGA_SUB_VEN,   EVGA_GTX1080_FTW_SUB_DEV,       EVGA_RGB_V1,    "EVGA GeForce GTX 1080 FTW"             },
     { NVIDIA_VEN,   NVIDIA_RTX2070_OC_DEV,  EVGA_SUB_VEN,   EVGA_RTX2070_XC_OC_SUB_DEV,     EVGA_RGB_V2,    "EVGA GeForce RTX 2070 XC OC"           },
     { NVIDIA_VEN,   NVIDIA_RTX2070S_DEV,    EVGA_SUB_VEN,   EVGA_RTX2070S_XC_ULTRA_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2070 SUPER XC ULTRA"  },
     { NVIDIA_VEN,   NVIDIA_RTX2080_DEV,     EVGA_SUB_VEN,   EVGA_RTX2080_XC_GAMING_SUB_DEV, EVGA_RGB_V2,    "EVGA GeForce RTX 2080 XC GAMING"       },

Controllers/EVGAGPUController/EVGAGPUv1Controller.cpp

@@ -30,11 +30,6 @@ std::string EVGAGPUv1Controller::GetDeviceLocation()
     return("I2C: " + return_string);
 }
 
-unsigned char EVGAGPUv1Controller::GetMode()
-{
-    return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_MODE));
-}
-
 unsigned char EVGAGPUv1Controller::GetRed()
 {
     return(bus->i2c_smbus_read_byte_data(dev, EVGA_GPU_V1_REG_RED));

Controllers/EVGAGPUController/EVGAGPUv1Controller.h

@@ -38,7 +38,6 @@ public:
 
     std::string     GetDeviceLocation();
 
-    unsigned char   GetMode();
     unsigned char   GetRed();
     unsigned char   GetGreen();
     unsigned char   GetBlue();

Controllers/EVGAGPUController/RGBController_EVGAGPUv1.cpp

@@ -49,26 +49,8 @@ RGBController_EVGAGPUv1::RGBController_EVGAGPUv1(EVGAGPUv1Controller* evga_ptr)
 
     SetupZones();
 
-    // Initialize active mode and stored color
-
-    unsigned char raw_active_mode = evga->GetMode();
-
+    // Initialize active mode
     active_mode = 0;
-    for(unsigned int i = 0; i < modes.size(); i++)
-    {
-        if (modes[i].value == raw_active_mode)
-        {
-            active_mode = i;
-            break;
-        }
-    }
-
-    unsigned char r = evga->GetRed();
-    unsigned char g = evga->GetGreen();
-    unsigned char b = evga->GetBlue();
-
-    RGBColor color = ToRGBColor(r, g, b);
-    colors[0] = color;
 }
 
 void RGBController_EVGAGPUv1::SetupZones()

Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp

@@ -1,37 +0,0 @@
-#include "Detector.h"
-#include "RGBController.h"
-#include "ATC800Controller.h"
-#include "RGBController_AorusATC800.h"
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Vendor ID                                             |
-\*-----------------------------------------------------*/
-#define HOLTEK_VID                            0x1044
-
-/*-----------------------------------------------------*\
-| Controller product ids                                |
-\*-----------------------------------------------------*/
-#define ATC_800_CONTROLLER_PID                0x7A42
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAorusCPUCoolerControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if a Aorus RGB CPU Cooler exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteAorusCPUCoolerControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        ATC800Controller* controller = new ATC800Controller(dev, info->path);
-        RGBController_AorusATC800* rgb_controller = new RGBController_AorusATC800(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_IPU("Aorus CPU Coolers", DetectGigabyteAorusCPUCoolerControllers, HOLTEK_VID, ATC_800_CONTROLLER_PID, 0, 0xFF01, 1);

Controllers/GigabyteRGBFusion2USBController/GigabyteRGBFusion2USBControllerDetect.cpp

@@ -1,33 +0,0 @@
-#include "Detector.h"
-#include "GigabyteRGBFusion2USBController.h"
-#include "RGBController_GigabyteRGBFusion2USB.h"
-#include "dependencies/dmiinfo.h"
-
-#define IT8297_VID              0x048D
-#define IT8297_IFC              0
-#define IT8297_U                0xCC
-#define IT8297_UPG              0xFF89
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectGigabyteRGBFusion2USBControllers                                                 *
-*                                                                                          *
-*       Detect GigabyteRGB Fusion 2 devices that use IT8297 RGB controller                 *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectGigabyteRGBFusion2USBControllers(hid_device_info* info, const std::string&)
-{
-    DMIInfo     MB_info;
-    hid_device* dev = hid_open_path(info->path);
-    if (dev)
-    {
-        RGBFusion2USBController * controller = new RGBFusion2USBController(dev, info->path, MB_info.getMainboard());
-        RGBController_RGBFusion2USB * rgb_controller = new RGBController_RGBFusion2USB(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}   /* DetectRGBFusion2USBControllers() */
-
-REGISTER_HID_DETECTOR_IPU("Gigabyte RGB Fusion 2 USB", DetectGigabyteRGBFusion2USBControllers, IT8297_VID, 0x8297, IT8297_IFC, IT8297_UPG, IT8297_U);
-REGISTER_HID_DETECTOR_IPU("Gigabyte RGB Fusion 2 USB", DetectGigabyteRGBFusion2USBControllers, IT8297_VID, 0x5702, IT8297_IFC, IT8297_UPG, IT8297_U);

Controllers/HoltekController/HoltekControllerDetect.cpp

@@ -14,16 +14,76 @@
 \*-----------------------------------------------------*/
 #define HOLTEK_A070_PID               0xA070
 
-void DetectHoltekControllers(hid_device_info* info, const std::string& name)
+typedef struct
 {
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    device_type     type;
+    const char *    name;
+} holtek_device;
+
+#define HOLTEK_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const holtek_device device_list[] =
+{
+    /*-------------------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                          |
+    \*-------------------------------------------------------------------------------------------------------------*/
+    { HOLTEK_VID,             HOLTEK_A070_PID,      1,  DEVICE_TYPE_MOUSE,      "Holtek USB Gaming Mouse"         },
+};
+
+void DetectHoltekControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_init();
+
+    for(unsigned int device_idx = 0; device_idx < HOLTEK_NUM_DEVICES; device_idx++)
     {
-        HoltekA070Controller* controller = new HoltekA070Controller(dev, info->path);
-        RGBController_HoltekA070* rgb_controller = new RGBController_HoltekA070(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        switch(device_list[device_idx].type)
+        {
+        case DEVICE_TYPE_MOUSE:
+            {
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE                    
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF00)
+                    &&(info->usage == 2))
+#else
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+                    {
+                        hid_device* dev = hid_open_path(info->path);
+
+                        if(dev)
+                        {
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                            case HOLTEK_A070_PID:
+                                {
+                                    HoltekA070Controller* controller = new HoltekA070Controller(dev, info->path);
+
+                                    RGBController_HoltekA070* rgb_controller = new RGBController_HoltekA070(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
+            }
+            break;
+        }
+
     }
 }   /* DetectHoltekControllers() */
 
-REGISTER_HID_DETECTOR_IPU("Holtek USB Gaming Mouse", DetectHoltekControllers, HOLTEK_VID, HOLTEK_A070_PID, 1, 0xFF00, 2);
+REGISTER_DETECTOR("Holtek", DetectHoltekControllers);

Controllers/HuePlusController/HuePlusController.cpp

@@ -4,7 +4,7 @@
 |  Adam Honse (calcprogrammer1@gmail.com), 12/11/2016       |
 \*---------------------------------------------------------*/
 
-#include "NZXTHuePlusController.h"
+#include "HuePlusController.h"
 
 #include <fstream>
 #include <iostream>

Controllers/HuePlusController/HuePlusControllerDetect.cpp

@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "NZXTHuePlusController.h"
+#include "HuePlusController.h"
 #include "RGBController.h"
-#include "RGBController_NZXTHuePlus.h"
+#include "RGBController_HuePlus.h"
 #include "find_usb_serial_port.h"
 #include <vector>
 
@@ -10,13 +10,13 @@
 
 /******************************************************************************************\
 *                                                                                          *
-*   DetectNZXTHuePlusControllers                                                           *
+*   DetectHuePlusControllers                                                               *
 *                                                                                          *
-*       Detect devices supported by the NZXTHuePlus driver                                 *
+*       Detect devices supported by the HuePlus driver                                     *
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectNZXTHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
+void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
 {
     size_t i;
     HuePlusController* new_hueplus;
@@ -37,4 +37,4 @@ void DetectNZXTHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
     }
 }   /* DetectHuePlusControllers() */
 
-REGISTER_DETECTOR("NZXT Hue+", DetectNZXTHuePlusControllers);
+REGISTER_DETECTOR("NZXT Hue+", DetectHuePlusControllers);

Controllers/HuePlusController/RGBController_HuePlus.cpp

@@ -1,12 +1,12 @@
 /*-----------------------------------------*\
-|  RGBController_NZXTHuePlus.cpp            |
+|  RGBController_HuePlus.cpp                |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
 |  Adam Honse (CalcProgrammer1) 6/20/2019   |
 \*-----------------------------------------*/
 
-#include "RGBController_NZXTHuePlus.h"
+#include "RGBController_HuePlus.h"
 
 
 RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)

Controllers/HuePlusController/RGBController_HuePlus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_NZXTHuePlus.h              |
+|  RGBController_HuePlus.h                  |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
@@ -9,7 +9,7 @@
 #pragma once
 #include "RGBController.h"
 #include "serial_port.h"
-#include "NZXTHuePlusController.h"
+#include "HuePlusController.h"
 
 class RGBController_HuePlus : public RGBController
 {

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -4,6 +4,7 @@
 #include "RGBController.h"
 #include "RGBController_HyperXAlloyOrigins.h"
 #include "RGBController_HyperXKeyboard.h"
+#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -15,37 +16,97 @@
 #define HYPERX_ALLOY_ORIGINS_PID        0x16E5
 #define HYPERX_ALLOY_ORIGINS_CORE_PID   0x16E6
 
-void DetectHyperXKeyboards(hid_device_info* info, const std::string& name)
+typedef struct
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        HyperXKeyboardController* controller = new HyperXKeyboardController(dev, info->path);
-        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} hyperx_device;
 
-void DetectHyperXAlloyOrigins(hid_device_info* info, const std::string& name)
+#define HYPERX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const hyperx_device device_list[] =
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ELITE_PID,         2,  "HyperX Alloy Elite RGB"                    },
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_FPS_RGB_PID,       2,  "HyperX Alloy FPS RGB"                      },
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ORIGINS_PID,       3,  "HyperX Alloy Origins"                      },
+    { HYPERX_KEYBOARD_VID,  HYPERX_ALLOY_ORIGINS_CORE_PID,  3,  "HyperX Alloy Origins Core"                 },
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHyperXKeyboardControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if a HyperX Keyboard controller exists there.         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
     {
-        HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev, info->path);
-        RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
+        dev = NULL;
 
-REGISTER_HID_DETECTOR_IP("HyperX Alloy Elite RGB",    DetectHyperXKeyboards,    HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID,         2, 0xFF01);
-REGISTER_HID_DETECTOR_IP("HyperX Alloy FPS RGB",      DetectHyperXKeyboards,    HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID,       2, 0xFF01);
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
 
-#ifdef _WIN32
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,  3);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",      DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,       3);
+        //Look for HyperX RGB Peripheral
+        while(info)
+        {
+            if((device_list[device_idx].usb_pid != HYPERX_ALLOY_ORIGINS_PID)
+            &&(info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE
+            &&(info->interface_number == device_list[device_idx].usb_interface)
+            &&(info->usage_page == 0xFF01))
 #else
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins Core", DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_CORE_PID,  0);
-REGISTER_HID_DETECTOR_I("HyperX Alloy Origins",      DetectHyperXAlloyOrigins, HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID,       0);
-#endif
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXKeyboardController* controller = new HyperXKeyboardController(dev, info->path);
+
+                    RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            if((device_list[device_idx].usb_pid == HYPERX_ALLOY_ORIGINS_PID)
+            &&(info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev, info->path);
+
+                    RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
+    }
+}   /* DetectHyperXKeyboardControllers() */
+
+REGISTER_DETECTOR("HyperX Keyboard", DetectHyperXKeyboardControllers);

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.cpp

@@ -9,8 +9,32 @@
 
 #include "RGBController_HyperXAlloyOrigins.h"
 
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
 using namespace std::chrono_literals;
 
+THREAD keepalive_thread(void *param)
+{
+    RGBController_HyperXAlloyOrigins* controller = static_cast<RGBController_HyperXAlloyOrigins*>(param);
+    controller->KeepaliveThread();
+    THREADRETURN
+}
+
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
 
@@ -191,16 +215,16 @@ RGBController_HyperXAlloyOrigins::RGBController_HyperXAlloyOrigins(HyperXAlloyOr
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&RGBController_HyperXAlloyOrigins::KeepaliveThread, this);
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
 }
 
 RGBController_HyperXAlloyOrigins::~RGBController_HyperXAlloyOrigins()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
-
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
     \*---------------------------------------------------------*/
@@ -289,13 +313,13 @@ void RGBController_HyperXAlloyOrigins::DeviceUpdateMode()
 
 void RGBController_HyperXAlloyOrigins::KeepaliveThread()
 {
-    while(keepalive_thread_run.load())
+    while(1)
     {
         if(active_mode == 0)
         {
             if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
             {
-                DeviceUpdateLEDs();
+                UpdateLEDs();
             }
         }
         std::this_thread::sleep_for(10ms);;

Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.h

@@ -34,7 +34,6 @@ public:
     
 private:
     HyperXAlloyOriginsController*   hyperx;
-    std::thread*                    keepalive_thread;
-    std::atomic<bool>               keepalive_thread_run;
+
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/HyperXKeyboardController/RGBController_HyperXKeyboard.cpp

@@ -230,15 +230,15 @@ RGBController_HyperXKeyboard::RGBController_HyperXKeyboard(HyperXKeyboardControl
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = true;
-    keepalive_thread = new std::thread(&RGBController_HyperXKeyboard::KeepaliveThreadFunction, this);
+    KeepaliveThreadRunning = true;
+    KeepaliveThread = new std::thread(&RGBController_HyperXKeyboard::KeepaliveThreadFunction, this);
 }
 
 RGBController_HyperXKeyboard::~RGBController_HyperXKeyboard()
 {
-    keepalive_thread_run = false;
-    keepalive_thread->join();
-    delete keepalive_thread;
+    KeepaliveThreadRunning = false;
+    KeepaliveThread->join();
+    delete KeepaliveThread;
 
     /*---------------------------------------------------------*\
     | Delete the matrix map                                     |
@@ -345,13 +345,13 @@ void RGBController_HyperXKeyboard::DeviceUpdateMode()
 
 void RGBController_HyperXKeyboard::KeepaliveThreadFunction()
 {
-    while(keepalive_thread_run)
+    while(KeepaliveThreadRunning)
     {
         if(active_mode == 0)
         {
             if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
             {
-                DeviceUpdateLEDs();
+                UpdateLEDs();
             }
         }
         std::this_thread::sleep_for(10ms);;

Controllers/HyperXKeyboardController/RGBController_HyperXKeyboard.h

@@ -36,7 +36,9 @@ public:
     
 private:
     HyperXKeyboardController*   hyperx;
-    std::atomic<bool>   keepalive_thread_run;
-    std::thread*        keepalive_thread;
+
+    std::atomic<bool>   KeepaliveThreadRunning;
+    std::thread*        KeepaliveThread;
+
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/HyperXMouseController/HyperXMouseControllerDetect.cpp

@@ -2,24 +2,83 @@
 #include "HyperXPulsefireSurgeController.h"
 #include "RGBController.h"
 #include "RGBController_HyperXPulsefireSurge.h"
+#include <vector>
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
-| HyperX mouse vendor IDs                               |
+| HyperX keyboard vendor IDs                            |
 \*-----------------------------------------------------*/
 #define HYPERX_VID                  0x0951
 #define HYPERX_PULSEFIRE_SURGE_PID  0x16D3
 
-void DetectHyperXMouseControllers(hid_device_info* info, const std::string& name)
+typedef struct
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} hyperx_device;
+
+#define HYPERX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const hyperx_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { HYPERX_VID,           HYPERX_PULSEFIRE_SURGE_PID, 1,      "HyperX Pulsefire Surge"                    },
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHyperXMouseControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if a HyperX Mouse controller exists there.            *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectHyperXMouseControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
     {
-        HyperXPulsefireSurgeController* controller = new HyperXPulsefireSurgeController(dev, info->path);
-        RGBController_HyperXPulsefireSurge* rgb_controller = new RGBController_HyperXPulsefireSurge(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for HyperX RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id        == device_list[device_idx].usb_vid)
+             &&(info->product_id       == device_list[device_idx].usb_pid)
+    #ifdef USE_HID_USAGE
+            &&(info->interface_number == device_list[device_idx].usb_interface)
+            &&(info->usage_page       == 0xFF01))
+    #else
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+    #endif
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXPulsefireSurgeController* controller = new HyperXPulsefireSurgeController(dev, info->path);
+
+                    RGBController_HyperXPulsefireSurge* rgb_controller = new RGBController_HyperXPulsefireSurge(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
     }
 }   /* DetectHyperXMouseControllers() */
 
-REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Surge", DetectHyperXMouseControllers, HYPERX_VID, HYPERX_PULSEFIRE_SURGE_PID, 1, 0xFF01);
+REGISTER_DETECTOR("HyperX Mouse", DetectHyperXMouseControllers);

Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.cpp

@@ -9,8 +9,32 @@
 
 #include "RGBController_HyperXPulsefireSurge.h"
 
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
 using namespace std::chrono_literals;
 
+THREAD keepalive_thread(void *param)
+{
+    RGBController_HyperXPulsefireSurge* controller = static_cast<RGBController_HyperXPulsefireSurge*>(param);
+    controller->KeepaliveThread();
+    THREADRETURN
+}
+
 RGBController_HyperXPulsefireSurge::RGBController_HyperXPulsefireSurge(HyperXPulsefireSurgeController* hyperx_ptr)
 {
     hyperx = hyperx_ptr;
@@ -35,15 +59,17 @@ RGBController_HyperXPulsefireSurge::RGBController_HyperXPulsefireSurge(HyperXPul
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&RGBController_HyperXPulsefireSurge::KeepaliveThread, this);
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
 };
 
 RGBController_HyperXPulsefireSurge::~RGBController_HyperXPulsefireSurge()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
+
 }
 
 void RGBController_HyperXPulsefireSurge::SetupZones()
@@ -130,13 +156,13 @@ void RGBController_HyperXPulsefireSurge::DeviceUpdateMode()
 
 void RGBController_HyperXPulsefireSurge::KeepaliveThread()
 {
-    while(keepalive_thread_run.load())
+    while(1)
     {
         if(active_mode == 0)
         {
             if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
             {
-                DeviceUpdateLEDs();
+                UpdateLEDs();
             }
         }
         std::this_thread::sleep_for(10ms);

Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.h

@@ -34,7 +34,6 @@ public:
     
 private:
     HyperXPulsefireSurgeController* hyperx;
-    std::thread*                    keepalive_thread;
-    std::atomic<bool>               keepalive_thread_run;
+
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/HyperXMousematController/HyperXMousematControllerDetect.cpp

@@ -11,6 +11,24 @@
 #define HYPERX_VID                  0x0951
 #define HYPERX_FURY_ULTRA_PID       0x1705
 
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} hyperx_device;
+
+#define HYPERX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const hyperx_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { HYPERX_VID,           HYPERX_FURY_ULTRA_PID,      0,      "HyperX Fury Ultra"                         },
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectHyperXMousematControllers                                                        *
@@ -19,16 +37,43 @@
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectHyperXMousematControllers(hid_device_info* info, const std::string& name)
+void DetectHyperXMousematControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < HYPERX_NUM_DEVICES; device_idx++)
     {
-        HyperXMousematController* controller = new HyperXMousematController(dev, info->path);
-        RGBController_HyperXMousemat* rgb_controller = new RGBController_HyperXMousemat(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for HyperX RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id        == device_list[device_idx].usb_vid)
+             &&(info->product_id       == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+
+                if( dev )
+                {
+                    HyperXMousematController* controller = new HyperXMousematController(dev, info->path);
+
+                    RGBController_HyperXMousemat* rgb_controller = new RGBController_HyperXMousemat(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    
+                    rgb_controllers.push_back(rgb_controller);
+                }
+            }
+
+            info = info->next;
+        }
     }
 }   /* DetectHyperXMousematControllers() */
 
-REGISTER_HID_DETECTOR_I("HyperX Fury Ultra", DetectHyperXMousematControllers, HYPERX_VID, HYPERX_FURY_ULTRA_PID, 0);
+REGISTER_DETECTOR("HyperX Mousemat", DetectHyperXMousematControllers);

Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp

@@ -9,8 +9,32 @@
 
 #include "RGBController_HyperXMousemat.h"
 
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
 using namespace std::chrono_literals;
 
+THREAD keepalive_thread(void *param)
+{
+    RGBController_HyperXMousemat* controller = static_cast<RGBController_HyperXMousemat*>(param);
+    controller->KeepaliveThread();
+    THREADRETURN
+}
+
 RGBController_HyperXMousemat::RGBController_HyperXMousemat(HyperXMousematController* hyperx_ptr)
 {
     hyperx = hyperx_ptr;
@@ -35,37 +59,39 @@ RGBController_HyperXMousemat::RGBController_HyperXMousemat(HyperXMousematControl
     | to not revert back into rainbow mode.  Start a thread |
     | to continuously send a keepalive packet every 5s      |
     \*-----------------------------------------------------*/
-    keepalive_thread_run = 1;
-    keepalive_thread = new std::thread(&RGBController_HyperXMousemat::KeepaliveThread, this);
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
 };
 
 RGBController_HyperXMousemat::~RGBController_HyperXMousemat()
 {
-    keepalive_thread_run = 0;
-    keepalive_thread->join();
-    delete keepalive_thread;
+
 }
 
 void RGBController_HyperXMousemat::SetupZones()
 {
-    zone underglow;
-    underglow.name       = "Underglow";
-    underglow.type       = ZONE_TYPE_LINEAR;
-    underglow.leds_min   = 15;
-    underglow.leds_max   = 15;
-    underglow.leds_count = 15;
-    underglow.matrix_map = NULL;
-    zones.push_back(underglow);
-
     zone led_strip;
     led_strip.name       = "LED Strip";
     led_strip.type       = ZONE_TYPE_LINEAR;
-    led_strip.leds_min   = 5;
-    led_strip.leds_max   = 5;
-    led_strip.leds_count = 5;
+    led_strip.leds_min   = 32;
+    led_strip.leds_max   = 32;
+    led_strip.leds_count = 32;
     led_strip.matrix_map = NULL;
     zones.push_back(led_strip);
 
+    zone logo;
+    logo.name       = "Logo";
+    logo.type       = ZONE_TYPE_SINGLE;
+    logo.leds_min   = 1;
+    logo.leds_max   = 1;
+    logo.leds_count = 1;
+    logo.matrix_map = NULL;
+    zones.push_back(logo);
+
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
@@ -130,13 +156,13 @@ void RGBController_HyperXMousemat::DeviceUpdateMode()
 
 void RGBController_HyperXMousemat::KeepaliveThread()
 {
-    while(keepalive_thread_run.load())
+    while(1)
     {
         if(active_mode == 0)
         {
             if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50))
             {
-                DeviceUpdateLEDs();
+                UpdateLEDs();
             }
         }
         std::this_thread::sleep_for(10ms);

Controllers/HyperXMousematController/RGBController_HyperXMousemat.h

@@ -34,7 +34,6 @@ public:
     
 private:
     HyperXMousematController* hyperx;
-    std::thread*              keepalive_thread;
-    std::atomic<bool>         keepalive_thread_run;
+
     std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
 };

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -26,12 +26,11 @@
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define LOGITECH_G213_PID                       0xC336
+#define LOGITECH_G810_1_PID                     0xC337
+#define LOGITECH_G810_2_PID                     0xC331
 #define LOGITECH_G512_PID                       0xC342
 #define LOGITECH_G512_RGB_PID                   0xC33C
-#define LOGITECH_G610_PID                       0xC333
-#define LOGITECH_G810_1_PID                     0xC331
-#define LOGITECH_G810_2_PID                     0xC337
+#define LOGITECH_G213_PID                       0xC336
 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
@@ -42,191 +41,284 @@
 #define LOGITECH_G502_PS_PID                    0xC332
 #define LOGITECH_G502H_PID                      0xC08B
 #define LOGITECH_G_LIGHTSPEED_WIRELESS_PID      0xC539
-#define LOGITECH_GPRO_WIRED_PID                 0xC085
-#define LOGITECH_GPRO_HERO_WIRED_PID            0xC08C
 #define LOGITECH_GPRO_WIRELESS_PID              0xC088
-/*-----------------------------------------------------*\
-| Mousemat product IDs                                  |
-\*-----------------------------------------------------*/
 #define LOGITECH_G_LIGHTSPEED_POWERPLAY_PID     0xC53A
 
-void DetectLogitechKeyboardG810(hid_device_info* info, const std::string& name)
+typedef struct
 {
-    /*-------------------------------------------------------------------------------------------------*\
-    | Logitech keyboards use two different usages, one for 20-byte packets and one for 64-byte packets  |
-    | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
-    \*-------------------------------------------------------------------------------------------------*/
-#ifdef _WIN32
-     hid_device* dev_usage_0x0602 = nullptr;
-     hid_device* dev_usage_0x0604 = nullptr;
-     hid_device_info* info_temp = info;
-     while(info_temp)
-     {
-         if(info_temp->vendor_id        == info->vendor_id        // constant LOGITECH_VID
-         && info_temp->product_id       == info->product_id       // NON-constant
-         && info_temp->interface_number == info->interface_number // constant 1
-         && info_temp->usage_page       == info->usage_page)      // constant 0xFF43
-         {
-             if(info_temp->usage == 0x0602)
-             {
-                dev_usage_0x0602 = hid_open_path(info_temp->path);
-             }
-             else if(info_temp->usage == 0x0604)
-             {
-                 dev_usage_0x0604 = hid_open_path(info_temp->path);
-             }
-         }
-         if(dev_usage_0x0602 && dev_usage_0x0604)
-         {
-             break;
-         }
-         info_temp = info_temp->next;
-     }
-     if(dev_usage_0x0602 && dev_usage_0x0604)
-     {
-         LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
-         RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-         rgb_controller->name = name;
-         ResourceManager::get()->RegisterRGBController(rgb_controller);
-     }
-     else
-     {
-         // Not all of them could be opened, do some cleanup
-         if(dev_usage_0x0602)
-         {
-             hid_close(dev_usage_0x0602);
-         }
-         if(dev_usage_0x0604)
-         {
-             hid_close(dev_usage_0x0604);
-         }
-     }
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    device_type     type;
+    const char *    name;
+} logitech_device;
+
+#define LOGITECH_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const logitech_device device_list[] =
+{
+    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                                                                         |
+    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+    { LOGITECH_VID,             LOGITECH_G810_1_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
+    { LOGITECH_VID,             LOGITECH_G810_2_PID,                    1,  DEVICE_TYPE_KEYBOARD,   "Logitech G810 Orion Spectrum"                      },
+    { LOGITECH_VID,             LOGITECH_G512_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512"                                     },
+    { LOGITECH_VID,             LOGITECH_G512_RGB_PID,                  1,  DEVICE_TYPE_KEYBOARD,   "Logitech G512 RGB"                                 },
+    { LOGITECH_VID,             LOGITECH_G213_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G213"                                     },
+    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                                                              |
+    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+    { LOGITECH_VID,             LOGITECH_G203_PID,                      1,  DEVICE_TYPE_MOUSE,      "Logitech G203 Prodigy"                             },
+    { LOGITECH_VID,             LOGITECH_G203L_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G203 Lightsync"                           },
+    { LOGITECH_VID,             LOGITECH_G403_PID,                      1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Prodigy"                             },
+    { LOGITECH_VID,             LOGITECH_G403H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G403 Hero"                                },
+    { LOGITECH_VID,             LOGITECH_G502_PS_PID,                   1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Proteus Spectrum"                    },
+    { LOGITECH_VID,             LOGITECH_G502H_PID,                     1,  DEVICE_TYPE_MOUSE,      "Logitech G502 Hero"                                },
+    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_WIRELESS_PID,     2,  DEVICE_TYPE_MOUSE,      "Logitech G Lightspeed Wireless Gaming Mouse"       },
+    { LOGITECH_VID,             LOGITECH_GPRO_WIRELESS_PID,             2,  DEVICE_TYPE_MOUSE,      "Logitech G Pro Wireless Gaming Mouse (Wired)"      },
+    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,    2,  DEVICE_TYPE_MOUSE,      "Logitech G Powerplay Mousepad with Lightspeed"     },
+    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                                                                         |
+    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectLogitechControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if a Logitech RGB Keyboard controller exists there.   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_init();
+
+    for(unsigned int device_idx = 0; device_idx < LOGITECH_NUM_DEVICES; device_idx++)
+    {
+        switch(device_list[device_idx].type)
+        {
+        /*-------------------------------------------------------------------------------------------------*\
+        | Logitech keyboards use two different usages, one for 20-byte packets and one for 64-byte packets  |
+        | Usage 0x0602 for 20 byte, usage 0x0604 for 64 byte, both are on usage page 0xFF43                 |
+        \*-------------------------------------------------------------------------------------------------*/
+        case DEVICE_TYPE_KEYBOARD:
+            {
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF43)
+                    &&(info->usage == 0x0602))
 #else
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG810Controller* controller = new LogitechG810Controller(dev, dev);
-        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
 #endif
-}
+                    {
+                        hid_device* dev_usage_0x0602 = hid_open_path(info->path);
+
+                        if(dev_usage_0x0602)
+                        {
+#ifdef USE_HID_USAGE
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                            case LOGITECH_G810_1_PID:
+                            case LOGITECH_G810_2_PID:
+                            case LOGITECH_G512_PID:
+                            case LOGITECH_G512_RGB_PID:
+                                {
+                                    hid_device_info* tmp_info_0x0604 = info;
+
+                                    while(tmp_info_0x0604)
+                                    {
+                                        if((tmp_info_0x0604->vendor_id == device_list[device_idx].usb_vid)
+                                        &&(tmp_info_0x0604->product_id == device_list[device_idx].usb_pid)
+                                        &&(tmp_info_0x0604->interface_number == device_list[device_idx].usb_interface)
+                                        &&(tmp_info_0x0604->usage_page == 0xFF43)
+                                        &&(tmp_info_0x0604->usage == 0x0604))
+                                        {
+                                            hid_device* dev_usage_0x0604 = hid_open_path(tmp_info_0x0604->path);
+
+                                            if(dev_usage_0x0604)
+                                            {
+                                                LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
+
+                                                RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+
+                                                rgb_controller->name = device_list[device_idx].name;
+                                                rgb_controllers.push_back(rgb_controller);
+                                            }
+                                        }
+                                        tmp_info_0x0604 = tmp_info_0x0604->next;
+                                    }
+                                }
+                                break;
+
+                            case LOGITECH_G213_PID:
+                                {
+                                    LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);
+
+                                    RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            }
+#else
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                            case LOGITECH_G810_1_PID:
+                            case LOGITECH_G810_2_PID:
+                            case LOGITECH_G512_PID:
+                            case LOGITECH_G512_RGB_PID:                            
+                                {
+                                    LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0602);
+
+                                    RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            case LOGITECH_G213_PID:
+                                {
+                                    LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);
+
+                                    RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+                            }
+
+#endif
+                        }
+                    }
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
+            }
+            break;
+
+        /*-------------------------------------------------------------------------------------------------*\
+        | Logitech mice use a single usage on page 0xFF00                                                   |
+        \*-------------------------------------------------------------------------------------------------*/
+        case DEVICE_TYPE_MOUSE:
+            {
+                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+                while(info)
+                {
+                    if((info->vendor_id == device_list[device_idx].usb_vid)
+                    &&(info->product_id == device_list[device_idx].usb_pid)
+#ifdef USE_HID_USAGE                    
+                    &&(info->interface_number == device_list[device_idx].usb_interface)
+                    &&(info->usage_page == 0xFF00)
+                    &&(info->usage == 2))
+#else
+                    &&(info->interface_number == device_list[device_idx].usb_interface))
+#endif
+                    {
+                        hid_device* dev = hid_open_path(info->path);
+
+                        if(dev)
+                        {
+                            switch(device_list[device_idx].usb_pid)
+                            {
+                            case LOGITECH_G203_PID:
+                                {
+                                    LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);
+
+                                    RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            case LOGITECH_G203L_PID:
+                                {
+                                    LogitechG203LController* controller = new LogitechG203LController(dev, info->path);
+
+                                    RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            case LOGITECH_G403_PID:
+                            case LOGITECH_G403H_PID:
+                                {
+                                    LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);
+
+                                    RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+
+                            case LOGITECH_G502_PS_PID:
+                            case LOGITECH_G502H_PID:
+                                {
+                                    LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);
+
+                                    RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+                            
+                            case LOGITECH_GPRO_WIRELESS_PID:
+                            case LOGITECH_G_LIGHTSPEED_WIRELESS_PID:
+                                {
+                                    LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev, info->path);
+
+                                    RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);
+
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
+                            case LOGITECH_G_LIGHTSPEED_POWERPLAY_PID:
+                                {
+                                    //Add mouse
+                                    LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);
+
+                                    RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
+
+                                    mouse_rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(mouse_rgb_controller);
+                                    
+                                    //Add Powerplay mousemat
+                                    LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev, info->path);
+
+                                    RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
+
+                                    mousemat_rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(mousemat_rgb_controller);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    info = info->next;
+                }
+                hid_free_enumeration(info);
+            }
+            break;
+        }
 
-void DetectLogitechKeyboardG213(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG213Controller* controller = new LogitechG213Controller(dev);
-        RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-}
+}   /* DetectLogitechControllers() */
 
-void DetectLogitechMouseG203(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);
-        RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG203L(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG203LController* controller = new LogitechG203LController(dev, info->path);
-        RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG403(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);
-        RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseG502PS(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);
-        RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseGPRO(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        LogitechGProWirelessController* controller = new LogitechGProWirelessController(dev, info->path);
-        RGBController_LogitechGProWireless* rgb_controller = new RGBController_LogitechGProWireless(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectLogitechMouseGLS(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        //Add mouse
-        LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);
-        RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);
-        mouse_rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(mouse_rgb_controller);
-
-        //Add Powerplay mousemat
-        LogitechGPowerPlayController* mousemat_controller = new LogitechGPowerPlayController(dev, info->path);
-        RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);
-        mousemat_rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(mousemat_rgb_controller);
-    }
-}
-
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G213",                                 DetectLogitechKeyboardG213, LOGITECH_VID, LOGITECH_G213_PID,                   1, 0xFF43, 0x0602);
-REGISTER_HID_DETECTOR_IP ("Logitech G512",                                 DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_PID,                   1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                             DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_RGB_PID,               1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                           DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_PID,                   1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_1_PID,                 1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_2_PID,                 1, 0xFF43);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                                                              |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Prodigy",                         DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_G203_PID,                   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                       DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203L_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Prodigy",                         DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_PID,                   1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G403 Hero",                            DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403H_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Proteus Spectrum",                DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_PS_PID,                1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G502 Hero",                            DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502H_PID,                  1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Gaming Mouse",                   DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_GPRO_WIRED_PID,             1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro (HERO) Gaming Mouse",            DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_GPRO_HERO_WIRED_PID,        1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Lightspeed Wireless Gaming Mouse",   DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_LIGHTSPEED_WIRELESS_PID,  2, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IPU("Logitech G Pro Wireless Gaming Mouse (Wired)",  DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_GPRO_WIRELESS_PID,          2, 0xFF00, 2);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Mousemats                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G Powerplay Mousepad with Lightspeed", DetectLogitechMouseGLS,     LOGITECH_VID, LOGITECH_G_LIGHTSPEED_POWERPLAY_PID, 2, 0xFF00, 2);
+REGISTER_DETECTOR("Logitech", DetectLogitechControllers);

Controllers/LogitechController/LogitechG203Controller.cpp

@@ -60,15 +60,15 @@ void LogitechG203Controller::SendMouseMode
     speed = 100 * speed;
     if(mode == LOGITECH_G203_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G203_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        usb_buf[0x0C]   = 0x64;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechG203Controller.h

@@ -24,7 +24,7 @@ enum
 
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+| Values are mutipled by 100 later to give lots of GUI steps.                                   |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {

Controllers/LogitechController/LogitechG403Controller.cpp

@@ -62,15 +62,15 @@ void LogitechG403Controller::SendMouseMode
     speed = 100 * speed;
     if(mode == LOGITECH_G403_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G403_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        usb_buf[0x0C]   = 0x64;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechG403Controller.h

@@ -24,7 +24,7 @@ enum
 
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+| Values are mutipled by 100 later to give lots of GUI steps.                                   |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {

Controllers/LogitechController/LogitechG502PSController.cpp

@@ -62,17 +62,17 @@ void LogitechG502PSController::SendMouseMode
     speed = 100 * speed;
     if(mode == LOGITECH_G502_PS_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G502_PS_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        usb_buf[0x0C]   = 0x64;
     }else if(mode == LOGITECH_G502_PS_MODE_STATIC){
-        usb_buf[0x09]       = 0x02;
+        usb_buf[0x09]   = 0x02;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechG502PSController.h

@@ -25,7 +25,7 @@ enum
 
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+| Values are mutipled by 100 later to give lots of GUI steps.                                   |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {

Controllers/LogitechController/LogitechG810Controller.cpp

@@ -147,18 +147,18 @@ void LogitechG810Controller::SendMode
     usb_buf[0x07]           = green;
     usb_buf[0x08]           = blue;
 
-    speed = 100 * speed;
+    speed = 1000 + 4750 * (LOGITECH_G810_SPEED_FASTEST - speed);
     if(mode == LOGITECH_G810_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G810_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        usb_buf[0x0C]   = 0x64;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechG810Controller.h

@@ -37,15 +37,13 @@ enum
     LOGITECH_G810_MODE_WAVE              = 0x04,
 };
 
-/*---------------------------------------------------------------------------------------------*\
-| Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
-\*---------------------------------------------------------------------------------------------*/
 enum
 {
-    LOGITECH_G810_SPEED_SLOWEST          = 0xC8,     /* Slowest speed                       */
-    LOGITECH_G810_SPEED_NORMAL           = 0x32,     /* Normal speed                        */
-    LOGITECH_G810_SPEED_FASTEST          = 0x0A,     /* Fastest speed                       */
+    LOGITECH_G810_SPEED_SLOWEST          = 0x00, /* Slowest speed                */
+    LOGITECH_G810_SPEED_SLOW             = 0x01, /* Slow speed                   */
+    LOGITECH_G810_SPEED_NORMAL           = 0x02, /* Normal speed                 */
+    LOGITECH_G810_SPEED_FAST             = 0x03, /* Fast speed                   */
+    LOGITECH_G810_SPEED_FASTEST          = 0x04, /* Fastest speed                */
 };
 
 class LogitechG810Controller

Controllers/LogitechController/LogitechGPowerPlayController.cpp

@@ -67,17 +67,17 @@ void LogitechGPowerPlayController::SendMouseMatMode
     }
     if(mode == LOGITECH_G_POWERPLAY_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        //usb_buf[0x0D]       = brightness;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        //usb_buf[0x0D]   = brightness;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G_POWERPLAY_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        //usb_buf[0x0C]       = brightness;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        //usb_buf[0x0C]   = brightness;
+        usb_buf[0x0C]   = 0x64;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechGPowerPlayController.h

@@ -24,7 +24,7 @@ enum
 
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+| Values are mutipled by 100 later to give lots of GUI steps.                                   |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {

Controllers/LogitechController/LogitechGProWirelessController.cpp

@@ -63,21 +63,21 @@ void LogitechGProWirelessController::SendMouseMode
     speed = 100 * speed;
     if(mode == LOGITECH_G_PRO_WIRELESS_MODE_STATIC)
     {
-        usb_buf[0x09]       = 0x02;
+        usb_buf[0x09]   = 0x02;
     }
     if(mode == LOGITECH_G_PRO_WIRELESS_MODE_CYCLE)
     {
-        usb_buf[0x0B]       = speed >> 8;
-        usb_buf[0x0C]       = speed & 0xFF;
-        //usb_buf[0x0D]       = brightness;
-        usb_buf[0x0D]       = 0x64;
+        usb_buf[0x0B]   = speed >> 8;
+        usb_buf[0x0C]   = speed & 0xFF;
+        //usb_buf[0x0D]   = brightness;
+        usb_buf[0x0D]   = 0x64;
     }
     else if(mode == LOGITECH_G_PRO_WIRELESS_MODE_BREATHING)
     {
-        usb_buf[0x09]       = speed >> 8;
-        usb_buf[0x0A]       = speed & 0xFF;
-        //usb_buf[0x0C]       = brightness;
-        usb_buf[0x0C]       = 0x64;
+        usb_buf[0x09]   = speed >> 8;
+        usb_buf[0x0A]   = speed & 0xFF;
+        //usb_buf[0x0C]   = brightness;
+        usb_buf[0x0C]   = 0x64;
     }
 
     /*-----------------------------------------------------*\

Controllers/LogitechController/LogitechGProWirelessController.h

@@ -24,7 +24,7 @@ enum
 
 /*---------------------------------------------------------------------------------------------*\
 | Speed is 1000 for fast and 20000 for slow.                                                    |
-| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+| Values are mutipled by 100 later to give lots of GUI steps.                                   |
 \*---------------------------------------------------------------------------------------------*/
 enum
 {   

Controllers/LogitechController/RGBController_LogitechG203.cpp

@@ -19,37 +19,37 @@ RGBController_LogitechG203::RGBController_LogitechG203(LogitechG203Controller* l
     location    = logitech->GetDeviceLocation();
 
     mode Static;
-    Static.name                     = "Static";
-    Static.value                    = LOGITECH_G203_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode               = MODE_COLORS_PER_LED;
+    Static.name       = "Static";
+    Static.value      = LOGITECH_G203_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
     
     mode Off;
-    Off.name                        = "Off";
-    Off.value                       = LOGITECH_G203_MODE_OFF;
-    Off.flags                       = 0;
-    Off.color_mode                  = MODE_COLORS_NONE;
+    Off.name       = "Off";
+    Off.value      = LOGITECH_G203_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Cycle;
-    Cycle.name                      = "Cycle";
-    Cycle.value                     = LOGITECH_G203_MODE_CYCLE;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed_min                 = LOGITECH_G203_SPEED_SLOWEST;
-    Cycle.speed_max                 = LOGITECH_G203_SPEED_FASTEST;
-    Cycle.speed                     = LOGITECH_G203_SPEED_NORMAL;
+    Cycle.name       = "Cycle";
+    Cycle.value      = LOGITECH_G203_MODE_CYCLE;
+    Cycle.flags      = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.speed_min  = LOGITECH_G203_SPEED_SLOWEST;
+    Cycle.speed_max  = LOGITECH_G203_SPEED_FASTEST;
+    Cycle.speed      = LOGITECH_G203_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = LOGITECH_G203_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed_min             = LOGITECH_G203_SPEED_SLOWEST;
-    Breathing.speed_max             = LOGITECH_G203_SPEED_FASTEST;
-    Breathing.speed                 = LOGITECH_G203_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = LOGITECH_G203_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed_min  = LOGITECH_G203_SPEED_SLOWEST;
+    Breathing.speed_max  = LOGITECH_G203_SPEED_FASTEST;
+    Breathing.speed      = LOGITECH_G203_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();
@@ -58,12 +58,12 @@ RGBController_LogitechG203::RGBController_LogitechG203(LogitechG203Controller* l
 void RGBController_LogitechG203::SetupZones()
 {
     zone g203_zone;
-    g203_zone.name                  = "Mouse";
-    g203_zone.type                  = ZONE_TYPE_SINGLE;
-    g203_zone.leds_min              = 1;
-    g203_zone.leds_max              = 1;
-    g203_zone.leds_count            = 1;
-    g203_zone.matrix_map            = NULL;
+    g203_zone.name           = "Mouse";
+    g203_zone.type           = ZONE_TYPE_SINGLE;
+    g203_zone.leds_min       = 1;
+    g203_zone.leds_max       = 1;
+    g203_zone.leds_count     = 1;
+    g203_zone.matrix_map     = NULL;
     zones.push_back(g203_zone);
 
     led g203_led;

Controllers/LogitechController/RGBController_LogitechG203L.cpp

@@ -166,4 +166,4 @@ void RGBController_LogitechG203L::DeviceUpdateMode()
     {
         logitech->SetMode(modes[active_mode].value, modes[active_mode].speed, val, dir, red, grn, blu);
     }
-}
+}

Controllers/LogitechController/RGBController_LogitechG213.cpp

@@ -37,10 +37,10 @@ RGBController_LogitechG213::RGBController_LogitechG213(LogitechG213Controller* l
     description = "Logitech G213 Keyboard Device";
 
     mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = 0xFFFF;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
     SetupZones();

Controllers/LogitechController/RGBController_LogitechG403.cpp

@@ -19,37 +19,37 @@ RGBController_LogitechG403::RGBController_LogitechG403(LogitechG403Controller* l
     location    = logitech->GetDeviceLocation();
 
     mode Static;
-    Static.name                     = "Static";
-    Static.value                    = LOGITECH_G403_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode               = MODE_COLORS_PER_LED;
+    Static.name       = "Static";
+    Static.value      = LOGITECH_G403_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Off;
-    Off.name                        = "Off";
-    Off.value                       = LOGITECH_G403_MODE_OFF;
-    Off.flags                       = 0;
-    Off.color_mode                  = MODE_COLORS_NONE;
+    Off.name       = "Off";
+    Off.value      = LOGITECH_G403_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Cycle;
-    Cycle.name                      = "Cycle";
-    Cycle.value                     = LOGITECH_G403_MODE_CYCLE;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed_min                 = LOGITECH_G403_SPEED_SLOWEST;
-    Cycle.speed_max                 = LOGITECH_G403_SPEED_FASTEST;
-    Cycle.speed                     = LOGITECH_G403_SPEED_NORMAL;
+    Cycle.name       = "Cycle";
+    Cycle.value      = LOGITECH_G403_MODE_CYCLE;
+    Cycle.flags      = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.speed_min  = LOGITECH_G403_SPEED_SLOWEST;
+    Cycle.speed_max  = LOGITECH_G403_SPEED_FASTEST;
+    Cycle.speed      = LOGITECH_G403_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = LOGITECH_G403_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed_min             = LOGITECH_G403_SPEED_SLOWEST;
-    Breathing.speed_max             = LOGITECH_G403_SPEED_FASTEST;
-    Breathing.speed                 = LOGITECH_G403_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = LOGITECH_G403_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed_min  = LOGITECH_G403_SPEED_SLOWEST;
+    Breathing.speed_max  = LOGITECH_G403_SPEED_FASTEST;
+    Breathing.speed      = LOGITECH_G403_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();

Controllers/LogitechController/RGBController_LogitechG502PS.cpp

@@ -13,43 +13,43 @@ RGBController_LogitechG502PS::RGBController_LogitechG502PS(LogitechG502PSControl
 {
     logitech = logitech_ptr;
 
-    name                            = "Logitech Mouse Device";
-    type                            = DEVICE_TYPE_MOUSE;
-    description                     = "Logitech Mouse Device";
-    location                        = logitech->GetDeviceLocation();
+    name        = "Logitech Mouse Device";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "Logitech Mouse Device";
+    location    = logitech->GetDeviceLocation();
 
     mode Static;
-    Static.name                     = "Static";
-    Static.value                    = LOGITECH_G502_PS_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode               = MODE_COLORS_PER_LED;
+    Static.name       = "Static";
+    Static.value      = LOGITECH_G502_PS_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Off;
-    Off.name                        = "Off";
-    Off.value                       = LOGITECH_G502_PS_MODE_OFF;
-    Off.flags                       = 0;
-    Off.color_mode                  = MODE_COLORS_NONE;
+    Off.name       = "Off";
+    Off.value      = LOGITECH_G502_PS_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Cycle;
-    Cycle.name                      = "Cycle";
-    Cycle.value                     = LOGITECH_G502_PS_MODE_CYCLE;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed_min                 = LOGITECH_G502_PS_SPEED_SLOWEST;
-    Cycle.speed_max                 = LOGITECH_G502_PS_SPEED_FASTEST;
-    Cycle.speed                     = LOGITECH_G502_PS_SPEED_NORMAL;
+    Cycle.name       = "Cycle";
+    Cycle.value      = LOGITECH_G502_PS_MODE_CYCLE;
+    Cycle.flags      = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.speed_min  = LOGITECH_G502_PS_SPEED_SLOWEST;
+    Cycle.speed_max  = LOGITECH_G502_PS_SPEED_FASTEST;
+    Cycle.speed      = LOGITECH_G502_PS_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = LOGITECH_G502_PS_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode            = MODE_COLORS_PER_LED;
-    Breathing.speed_min             = LOGITECH_G502_PS_SPEED_SLOWEST;
-    Breathing.speed_max             = LOGITECH_G502_PS_SPEED_FASTEST;
-    Breathing.speed                 = LOGITECH_G502_PS_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = LOGITECH_G502_PS_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed_min  = LOGITECH_G502_PS_SPEED_SLOWEST;
+    Breathing.speed_max  = LOGITECH_G502_PS_SPEED_FASTEST;
+    Breathing.speed      = LOGITECH_G502_PS_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();
@@ -58,12 +58,12 @@ RGBController_LogitechG502PS::RGBController_LogitechG502PS(LogitechG502PSControl
 void RGBController_LogitechG502PS::SetupZones()
 {
     zone G502_PS_side_zone;
-    G502_PS_side_zone.name          = "DPI";
-    G502_PS_side_zone.type          = ZONE_TYPE_SINGLE;
-    G502_PS_side_zone.leds_min      = 1;
-    G502_PS_side_zone.leds_max      = 1;
-    G502_PS_side_zone.leds_count    = 1;
-    G502_PS_side_zone.matrix_map    = NULL;
+    G502_PS_side_zone.name           = "DPI";
+    G502_PS_side_zone.type           = ZONE_TYPE_SINGLE;
+    G502_PS_side_zone.leds_min       = 1;
+    G502_PS_side_zone.leds_max       = 1;
+    G502_PS_side_zone.leds_count     = 1;
+    G502_PS_side_zone.matrix_map     = NULL;
     zones.push_back(G502_PS_side_zone);
 
     led G502_PS_side_led;
@@ -71,12 +71,12 @@ void RGBController_LogitechG502PS::SetupZones()
     leds.push_back(G502_PS_side_led);
 
     zone G502_logo_zone;
-    G502_logo_zone.name             = "Logo";
-    G502_logo_zone.type             = ZONE_TYPE_SINGLE;
-    G502_logo_zone.leds_min         = 1;
-    G502_logo_zone.leds_max         = 1;
-    G502_logo_zone.leds_count       = 1;
-    G502_logo_zone.matrix_map       = NULL;
+    G502_logo_zone.name           = "Logo";
+    G502_logo_zone.type           = ZONE_TYPE_SINGLE;
+    G502_logo_zone.leds_min       = 1;
+    G502_logo_zone.leds_max       = 1;
+    G502_logo_zone.leds_count     = 1;
+    G502_logo_zone.matrix_map     = NULL;
     zones.push_back(G502_logo_zone);
 
     led G502_logo_led;

Controllers/LogitechController/RGBController_LogitechG810.cpp

@@ -174,50 +174,50 @@ RGBController_LogitechG810::RGBController_LogitechG810(LogitechG810Controller* l
     description = "Logitech Keyboard Device";
 
     mode Direct;
-    Direct.name                     = "Direct";
-    Direct.value                    = 0xFFFF;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    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                    = LOGITECH_G810_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.name       = "Static";
+    Static.value      = LOGITECH_G810_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 Off;
-    Off.name                        = "Off";
-    Off.value                       = LOGITECH_G810_MODE_OFF;
-    Off.flags                       = 0;
-    Off.color_mode                  = MODE_COLORS_NONE;
+    Off.name       = "Off";
+    Off.value      = LOGITECH_G810_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Cycle;
-    Cycle.name                      = "Cycle";
-    Cycle.value                     = LOGITECH_G810_MODE_CYCLE;
-    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
-    Cycle.color_mode                = MODE_COLORS_NONE;
-    Cycle.speed_min                 = LOGITECH_G810_SPEED_SLOWEST;
-    Cycle.speed_max                 = LOGITECH_G810_SPEED_FASTEST;
-    Cycle.speed                     = LOGITECH_G810_SPEED_NORMAL;
+    Cycle.name       = "Cycle";
+    Cycle.value      = LOGITECH_G810_MODE_CYCLE;
+    Cycle.flags      = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.speed_min  = LOGITECH_G810_SPEED_SLOWEST;
+    Cycle.speed_max  = LOGITECH_G810_SPEED_FASTEST;
+    Cycle.speed      = LOGITECH_G810_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = LOGITECH_G810_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.name       = "Breathing";
+    Breathing.value      = LOGITECH_G810_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             = LOGITECH_G810_SPEED_SLOWEST;
-    Breathing.speed_max             = LOGITECH_G810_SPEED_FASTEST;
-    Breathing.speed                 = LOGITECH_G810_SPEED_NORMAL;
+    Breathing.speed_min  = LOGITECH_G810_SPEED_SLOWEST;
+    Breathing.speed_max  = LOGITECH_G810_SPEED_FASTEST;
+    Breathing.speed      = LOGITECH_G810_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();

Controllers/LogitechController/RGBController_LogitechGPowerPlay.cpp

@@ -18,37 +18,37 @@ RGBController_LogitechGPowerPlay::RGBController_LogitechGPowerPlay(LogitechGPowe
     description = "Logitech G PowerPlay Wireless Charging System";
 
     mode Off;
-    Off.name                            = "Off";
-    Off.value                           = LOGITECH_G_POWERPLAY_MODE_OFF;
-    Off.flags                           = 0;
-    Off.color_mode                      = MODE_COLORS_PER_LED;
+    Off.name                = "Off";
+    Off.value               = LOGITECH_G_POWERPLAY_MODE_OFF;
+    Off.flags               = 0;
+    Off.color_mode          = MODE_COLORS_PER_LED;
     modes.push_back(Off);
 
     mode Static;
-    Static.name                         = "Static";
-    Static.value                        = LOGITECH_G_POWERPLAY_MODE_STATIC;
-    Static.flags                        = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode                   = MODE_COLORS_PER_LED;
+    Static.name             = "Static";
+    Static.value            = LOGITECH_G_POWERPLAY_MODE_STATIC;
+    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode       = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Cycle;
-    Cycle.name                          = "Cycle";
-    Cycle.value                         = LOGITECH_G_POWERPLAY_MODE_CYCLE;
-    Cycle.flags                         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Cycle.color_mode                    = MODE_COLORS_PER_LED;
-    Cycle.speed_min                     = LOGITECH_G_POWERPLAY_SPEED_SLOWEST;
-    Cycle.speed_max                     = LOGITECH_G_POWERPLAY_SPEED_FASTEST;
-    Cycle.speed                         = LOGITECH_G_POWERPLAY_SPEED_NORMAL;
+    Cycle.name              = "Cycle";
+    Cycle.value             = LOGITECH_G_POWERPLAY_MODE_CYCLE;
+    Cycle.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Cycle.color_mode        = MODE_COLORS_PER_LED;
+    Cycle.speed_min         = LOGITECH_G_POWERPLAY_SPEED_SLOWEST;
+    Cycle.speed_max         = LOGITECH_G_POWERPLAY_SPEED_FASTEST;
+    Cycle.speed             = LOGITECH_G_POWERPLAY_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name                      = "Breathing";
-    Breathing.value                     = LOGITECH_G_POWERPLAY_MODE_BREATHING;
-    Breathing.flags                     = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.color_mode                = MODE_COLORS_PER_LED;
-    Breathing.speed_min                 = LOGITECH_G_POWERPLAY_SPEED_SLOWEST;
-    Breathing.speed_max                 = LOGITECH_G_POWERPLAY_SPEED_FASTEST;
-    Breathing.speed                     = LOGITECH_G_POWERPLAY_SPEED_NORMAL;
+    Breathing.name          = "Breathing";
+    Breathing.value         = LOGITECH_G_POWERPLAY_MODE_BREATHING;
+    Breathing.flags         = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.color_mode    = MODE_COLORS_PER_LED;
+    Breathing.speed_min     = LOGITECH_G_POWERPLAY_SPEED_SLOWEST;
+    Breathing.speed_max     = LOGITECH_G_POWERPLAY_SPEED_FASTEST;
+    Breathing.speed         = LOGITECH_G_POWERPLAY_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();

Controllers/LogitechController/RGBController_LogitechGProWireless.cpp

@@ -13,43 +13,43 @@ RGBController_LogitechGProWireless::RGBController_LogitechGProWireless(LogitechG
 {
     logitech = logitech_ptr;
 
-    name                        = "Logitech G Pro Wireless Gaming Mouse";
-    type                        = DEVICE_TYPE_MOUSE;
-    description                 = "Logitech G Pro Wireless Gaming Mouse";
-    location                    = logitech->GetDeviceLocation();
+    name        = "Logitech G Pro Wireless Gaming Mouse";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "Logitech G Pro Wireless Gaming Mouse";
+    location    = logitech->GetDeviceLocation();
 
     mode Off;
-    Off.name                    = "Off";
-    Off.value                   = LOGITECH_G_PRO_WIRELESS_MODE_OFF;
-    Off.flags                   = 0;
-    Off.color_mode              = MODE_COLORS_NONE;
+    Off.name       = "Off";
+    Off.value      = LOGITECH_G_PRO_WIRELESS_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
-    Static.name                 = "Static";
-    Static.value                = LOGITECH_G_PRO_WIRELESS_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.name       = "Static";
+    Static.value      = LOGITECH_G_PRO_WIRELESS_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Static);
 
     mode Cycle;
-    Cycle.name                  = "Cycle";
-    Cycle.value                 = LOGITECH_G_PRO_WIRELESS_MODE_CYCLE;
-    Cycle.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Cycle.color_mode            = MODE_COLORS_NONE;
-    Cycle.speed_min             = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
-    Cycle.speed_max             = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
-    Cycle.speed                 = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
+    Cycle.name       = "Cycle";
+    Cycle.value      = LOGITECH_G_PRO_WIRELESS_MODE_CYCLE;
+    Cycle.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Cycle.color_mode = MODE_COLORS_NONE;
+    Cycle.speed_min  = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
+    Cycle.speed_max  = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
+    Cycle.speed      = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
     modes.push_back(Cycle);
 
     mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = LOGITECH_G_PRO_WIRELESS_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
-    Breathing.speed_min         = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
-    Breathing.speed_max         = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
-    Breathing.speed             = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
+    Breathing.name       = "Breathing";
+    Breathing.value      = LOGITECH_G_PRO_WIRELESS_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    Breathing.speed_min  = LOGITECH_G_PRO_WIRELESS_SPEED_SLOWEST;
+    Breathing.speed_max  = LOGITECH_G_PRO_WIRELESS_SPEED_FASTEST;
+    Breathing.speed      = LOGITECH_G_PRO_WIRELESS_SPEED_NORMAL;
     modes.push_back(Breathing);
 
     SetupZones();
@@ -58,12 +58,12 @@ RGBController_LogitechGProWireless::RGBController_LogitechGProWireless(LogitechG
 void RGBController_LogitechGProWireless::SetupZones()
 {
     zone GProWireless_primary_zone;
-    GProWireless_primary_zone.name          = "DPI";
-    GProWireless_primary_zone.type          = ZONE_TYPE_SINGLE;
-    GProWireless_primary_zone.leds_min      = 1;
-    GProWireless_primary_zone.leds_max      = 1;
-    GProWireless_primary_zone.leds_count    = 1;
-    GProWireless_primary_zone.matrix_map    = NULL;
+    GProWireless_primary_zone.name           = "DPI";
+    GProWireless_primary_zone.type           = ZONE_TYPE_SINGLE;
+    GProWireless_primary_zone.leds_min       = 1;
+    GProWireless_primary_zone.leds_max       = 1;
+    GProWireless_primary_zone.leds_count     = 1;
+    GProWireless_primary_zone.matrix_map     = NULL;
     zones.push_back(GProWireless_primary_zone);
 
     led GProWireless_primary_led;
@@ -71,12 +71,12 @@ void RGBController_LogitechGProWireless::SetupZones()
     leds.push_back(GProWireless_primary_led);
 
     zone GProWireless_logo_zone;
-    GProWireless_logo_zone.name             = "Logo";
-    GProWireless_logo_zone.type             = ZONE_TYPE_SINGLE;
-    GProWireless_logo_zone.leds_min         = 1;
-    GProWireless_logo_zone.leds_max         = 1;
-    GProWireless_logo_zone.leds_count       = 1;
-    GProWireless_logo_zone.matrix_map       = NULL;
+    GProWireless_logo_zone.name           = "Logo";
+    GProWireless_logo_zone.type           = ZONE_TYPE_SINGLE;
+    GProWireless_logo_zone.leds_min       = 1;
+    GProWireless_logo_zone.leds_max       = 1;
+    GProWireless_logo_zone.leds_count     = 1;
+    GProWireless_logo_zone.matrix_map     = NULL;
     zones.push_back(GProWireless_logo_zone);
 
     led GProWireless_logo_led;