openrgb_qmk_testing

Fix Linux build not compiling
Implemented a qmk rgb matrix controller
2020-11-23 02:05:33 -06:00 · 2020-11-12 20:16:03 +02:00 · 2020-11-11 04:14:40 +02:00
160 changed files with 2617 additions and 2697 deletions
@@ -6,4 +6,3 @@ qrc_*
 OpenRGB
 Makefile
 OpenRGB-x86_64.AppImage
-.qmake.stash
@@ -134,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                                 #
@@ -164,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                                              #
 #---------------------------------------------------------------#
@@ -84,4 +84,4 @@ void DetectAorusCPUCoolerControllers(std::vector<RGBController*>& rgb_controller
    }
 }

-REGISTER_DETECTOR("Gigabyte Aorus CPU Coolers", DetectAorusCPUCoolerControllers);
+REGISTER_DETECTOR("Aorus CPU Coolers", DetectAorusCPUCoolerControllers);
@@ -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)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraCoreController.h                 |
+|  AuraCoreController.h                     |
 |                                           |
 |  Definitions and types for ASUS ROG Aura  |
 |  Core RGB lighting controller             |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "AsusAuraCoreController.h"
+#include "AuraCoreController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraCore.h"
+#include "RGBController_AuraCore.h"
 #include <vector>
 #include <hidapi/hidapi.h>

@@ -23,7 +23,7 @@ static const unsigned short pid_table[] =
 *                                                                                          *
 \******************************************************************************************/

-void DetectAsusAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device* dev;

@@ -45,4 +45,4 @@ void DetectAsusAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
    }
 }

-REGISTER_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers);
+REGISTER_DETECTOR("ASUS Aura Core", DetectAuraCoreControllers);
@@ -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)
 {
@@ -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
 {
@@ -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)
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraGPUController.h                  |
+|  AuraGPUController.h                      |
 |                                           |
 |  Definitions for ASUS Aura RGB on GPUs    |
 |                                           |
@@ -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);
@@ -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()
 {
@@ -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
 {
@@ -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                 */
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraSMBusController.h                |
+|  AuraSMBusController.h                    |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |
@@ -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);
@@ -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()
 {
@@ -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
 {
@@ -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)
@@ -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>
@@ -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)
@@ -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>
@@ -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>

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

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AsusAuraUSBController.h                  |
+|  AuraUSBController.h                      |
 |                                           |
 |  Definitions and types for ASUS Aura      |
 |  USB RGB lighting controller              |
@@ -1,10 +1,10 @@
 #include "Detector.h"
-#include "AsusAuraAddressableController.h"
-#include "AsusAuraMainboardController.h"
-#include "AsusAuraMouseController.h"
+#include "AuraAddressableController.h"
+#include "AuraMainboardController.h"
+#include "AuraMouseController.h"
 #include "RGBController.h"
-#include "RGBController_AsusAuraUSB.h"
-#include "RGBController_AsusAuraMouse.h"
+#include "RGBController_AuraUSB.h"
+#include "RGBController_AuraMouse.h"
 #include <vector>
 #include <stdexcept>
 #include <hidapi/hidapi.h>
@@ -63,7 +63,7 @@ static const aura_device mouse_device_list[] =
    { AURA_USB_VID,     AURA_ROG_GLADIUS_II_ORIGIN_PID, 2,  "ASUS ROG Gladius II Origin"    },
 };

-void DetectAsusAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
+void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device_info* info = NULL;

@@ -167,4 +167,4 @@ void DetectAsusAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)

 }  /* DetectAuraUSBControllers() */

-REGISTER_DETECTOR("ASUS Aura USB", DetectAsusAuraUSBControllers);
+REGISTER_DETECTOR("ASUS Aura USB", DetectAuraUSBControllers);
@@ -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)
 {
@@ -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
 {
@@ -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)
 {
@@ -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

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

@@ -74,7 +74,7 @@ void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
        {
            if (dev_type == DEVICE_TYPE_MOUSEMAT)
            {
-                CMMP750Controller* controller                   = new CMMP750Controller(dev, info->path);
+                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);
            }
@@ -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;
+    }
 }
@@ -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))
        {
@@ -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();
@@ -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]));
@@ -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;

@@ -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 ) )
        {
@@ -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;
 };
@@ -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;
@@ -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;

@@ -4,24 +4,21 @@
 #include "RGBController_EKController.h"
 #include <hidapi/hidapi.h>

-#define EK_VID                  0x0483
+#define EK_VID                0x0483

-#define EK_LOOP_CONNECT_PID     0x5750
+#define EK_LOOP_CONNECT       0x5750

 #define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))

-struct ek_device
+enum
 {
-    unsigned int    product_id;
-    unsigned short  interface;
-    unsigned int    usage_page;
-    unsigned int    usage;
-    device_type     type;
+    EK_PID = 0,
+    EK_INTERFACE = 1
 };

-static const ek_device ek_pids[] =
-{  // PID,                  Interface,  Usage_Page, Usage,  Device_Type
-   { EK_LOOP_CONNECT_PID,   0x00,       0xFFA0,     0x01,   DEVICE_TYPE_LEDSTRIP  }      //EK Loop Connect
+static const unsigned int ek_pids[][2] =
+{  // PID,      Interface
+    { EK_LOOP_CONNECT,        0x00 }     //EK Loop Connect
 };

 /******************************************************************************************\
@@ -36,9 +33,9 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
 {
    hid_device_info* info = NULL;

-    //Look for the passed in ek_pids
+    //Look for the passed in cm_pids
    hid_init();
-    info = hid_enumerate(0, 0x0);
+    info = hid_enumerate(EK_VID, 0x0);

    while(info)
    {
@@ -47,13 +44,8 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
        {
            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].product_id)
-#ifdef USE_HID_USAGE
-                    &&(info->usage              == ek_pids[ek_pid_idx].usage)     //Usage and usage page required to get the correct interface
-                    &&(info->usage_page         == ek_pids[ek_pid_idx].usage_page))
-#else
-                    &&(info->interface_number   == ek_pids[ek_pid_idx].interface))
-#endif  //USE_HID_USAGE
+                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;
@@ -63,7 +55,7 @@ void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)

        if(dev)
        {
-            EKController* controller = new EKController(dev, info->path);
+            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);
        }
@@ -7,6 +7,7 @@
 |                                                                     |
 \*-------------------------------------------------------------------*/

+
 #include "RGBController_EKController.h"

 RGBController_EKController::RGBController_EKController(EKController* _dev)
@@ -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"       },
@@ -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));
@@ -38,7 +38,6 @@ public:

    std::string     GetDeviceLocation();

-    unsigned char   GetMode();
    unsigned char   GetRed();
    unsigned char   GetGreen();
    unsigned char   GetBlue();
@@ -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()
@@ -4,7 +4,7 @@
 |  Adam Honse (calcprogrammer1@gmail.com), 12/11/2016       |
 \*---------------------------------------------------------*/

-#include "NZXTHuePlusController.h"
+#include "HuePlusController.h"

 #include <fstream>
 #include <iostream>
@@ -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);
@@ -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)
@@ -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
 {
@@ -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);;
@@ -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;
 };
@@ -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);;
@@ -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;
 };
@@ -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);
@@ -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;
 };
@@ -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,15 +59,17 @@ 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()
@@ -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);
@@ -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;
 };
@@ -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,12 +41,7 @@
 #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

 typedef struct
@@ -66,12 +60,11 @@ static const logitech_device device_list[] =
    /*-------------------------------------------------------------------------------------------------------------------------------------------------*\
    | Keyboards                                                                                                                                         |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G213_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G213"                                     },
-    { 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_G610_PID,                      1,  DEVICE_TYPE_KEYBOARD,   "Logitech G610 Orion"                               },
    { 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                                                                                                                                              |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
@@ -81,14 +74,12 @@ static const logitech_device device_list[] =
    { 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_GPRO_WIRED_PID,                1,  DEVICE_TYPE_MOUSE,      "Logitech G Pro Gaming Mouse"                       },
-    { LOGITECH_VID,             LOGITECH_GPRO_HERO_WIRED_PID,           1,  DEVICE_TYPE_MOUSE,      "Logitech G Pro (HERO) Gaming Mouse"                },
    { 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                                                                                                                                         |
    \*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-    { LOGITECH_VID,             LOGITECH_G_LIGHTSPEED_POWERPLAY_PID,    2,  DEVICE_TYPE_MOUSEMAT,   "Logitech G Powerplay Mousepad with Lightspeed"     },
 };

 /******************************************************************************************\
@@ -134,79 +125,79 @@ void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
 #ifdef USE_HID_USAGE
                            switch(device_list[device_idx].usb_pid)
                            {
-                                case LOGITECH_G213_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)
                                    {
-                                        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;
-
-                                case LOGITECH_G512_PID:
-                                case LOGITECH_G512_RGB_PID:
-                                case LOGITECH_G610_PID:
-                                case LOGITECH_G810_1_PID:
-                                case LOGITECH_G810_2_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))
                                        {
-                                            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)
                                            {
-                                                hid_device* dev_usage_0x0604 = hid_open_path(tmp_info_0x0604->path);
+                                                LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);

-                                                if(dev_usage_0x0604)
-                                                {
-                                                    LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0604);
+                                                RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);

-                                                    RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
-
-                                                    rgb_controller->name = device_list[device_idx].name;
-                                                    rgb_controllers.push_back(rgb_controller);
-                                                }
+                                                rgb_controller->name = device_list[device_idx].name;
+                                                rgb_controllers.push_back(rgb_controller);
                                            }
-                                            tmp_info_0x0604 = tmp_info_0x0604->next;
                                        }
+                                        tmp_info_0x0604 = tmp_info_0x0604->next;
                                    }
-                                    break;
+                                }
+                                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_G213_PID:
-                                    {
-                                        LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);
+                            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_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);
+                                    RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;

-                                case LOGITECH_G512_PID:
-                                case LOGITECH_G512_RGB_PID:
-                                case LOGITECH_G610_PID:
-                                case LOGITECH_G810_1_PID:
-                                case LOGITECH_G810_2_PID:
-                                    {
-                                        LogitechG810Controller* controller = new LogitechG810Controller(dev_usage_0x0602, dev_usage_0x0602);
+                            case LOGITECH_G213_PID:
+                                {
+                                    LogitechG213Controller* controller = new LogitechG213Controller(dev_usage_0x0602);

-                                        RGBController_LogitechG810* rgb_controller = new RGBController_LogitechG810(controller);
+                                    RGBController_LogitechG213* rgb_controller = new RGBController_LogitechG213(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(rgb_controller);
+                                }
+                                break;
                            }
+
 #endif
                        }
                    }
@@ -241,114 +232,82 @@ void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers)
                        {
                            switch(device_list[device_idx].usb_pid)
                            {
-                                case LOGITECH_G203_PID:
-                                case LOGITECH_GPRO_WIRED_PID:
-                                case LOGITECH_GPRO_HERO_WIRED_PID:
-                                    {
-                                        LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);
+                            case LOGITECH_G203_PID:
+                                {
+                                    LogitechG203Controller* controller = new LogitechG203Controller(dev, info->path);

-                                        RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);
+                                    RGBController_LogitechG203* rgb_controller = new RGBController_LogitechG203(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    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);
+                            case LOGITECH_G203L_PID:
+                                {
+                                    LogitechG203LController* controller = new LogitechG203LController(dev, info->path);

-                                        RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);
+                                    RGBController_LogitechG203L* rgb_controller = new RGBController_LogitechG203L(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    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);
+                            case LOGITECH_G403_PID:
+                            case LOGITECH_G403H_PID:
+                                {
+                                    LogitechG403Controller* controller = new LogitechG403Controller(dev, info->path);

-                                        RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);
+                                    RGBController_LogitechG403* rgb_controller = new RGBController_LogitechG403(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    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);
+                            case LOGITECH_G502_PS_PID:
+                            case LOGITECH_G502H_PID:
+                                {
+                                    LogitechG502PSController* controller = new LogitechG502PSController(dev, info->path);

-                                        RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);
+                                    RGBController_LogitechG502PS* rgb_controller = new RGBController_LogitechG502PS(controller);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
+                                    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);

-                                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);

-                                        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);

-                                        rgb_controller->name = device_list[device_idx].name;
-                                        rgb_controllers.push_back(rgb_controller);
-                                    }
-                                    break;
-                            }
-                        }
-                    }
-                    info = info->next;
-                }
-                hid_free_enumeration(info);
-            }
-            break;
-        case DEVICE_TYPE_MOUSEMAT:
-            {
-                hid_device_info* info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+                                    RGBController_LogitechGProWireless* mouse_rgb_controller = new RGBController_LogitechGProWireless(mouse_controller);

-                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);
+                                    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);

-                        if(dev)
-                        {
-                            switch(device_list[device_idx].usb_pid)
-                            {
-                                case LOGITECH_G_LIGHTSPEED_POWERPLAY_PID:
-                                    {
-                                        //Add mouse
-                                        LogitechGProWirelessController* mouse_controller = new LogitechGProWirelessController(dev, info->path);
+                                    RGBController_LogitechGPowerPlay* mousemat_rgb_controller = new RGBController_LogitechGPowerPlay(mousemat_controller);

-                                        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;
+                                    mousemat_rgb_controller->name = device_list[device_idx].name;
+                                    rgb_controllers.push_back(mousemat_rgb_controller);
+                                }
+                                break;
                            }
                        }
                    }
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
 {
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
 {
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
 {
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
 {
@@ -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;
    }

    /*-----------------------------------------------------*\
@@ -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
 {   
@@ -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;
@@ -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();
@@ -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();
@@ -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;
@@ -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();
@@ -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();
@@ -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;
@@ -49,7 +49,6 @@ static const msi_gpu_pci_device device_list[] =
    { NVIDIA_VEN,   NVIDIA_RTX2080S_DEV,        MSI_SUB_VEN,    MSI_RTX2080S_GAMING_X_TRIO_SUB_DEV,     "MSI GeForce RTX 2080 Super Gaming X Trio"      },
    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       MSI_SUB_VEN,    MSI_RTX2080TI_GAMING_X_TRIO_SUB_DEV,    "MSI GeForce RTX 2080Ti Gaming X Trio"          },
    { NVIDIA_VEN,   NVIDIA_RTX2080TI_DEV,       MSI_SUB_VEN,    MSI_RTX2080TI_SEA_HAWK_EK_X_SUB_DEV,    "MSI GeForce RTX 2080Ti Sea Hawk EK X"          },
-    { NVIDIA_VEN,   NVIDIA_RTX3070_DEV,         MSI_SUB_VEN,    MSI_RTX3070_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3070 8GB Gaming X Trio"        },
    { NVIDIA_VEN,   NVIDIA_RTX3080_DEV,         MSI_SUB_VEN,    MSI_RTX3080_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3080 10GB Gaming X Trio"       },
    { NVIDIA_VEN,   NVIDIA_RTX3090_DEV,         MSI_SUB_VEN,    MSI_RTX3090_GAMING_X_TRIO_SUB_DEV,      "MSI GeForce RTX 3090 24GB Gaming X Trio"       },
 };
@@ -139,7 +139,10 @@ RGBController_NZXTKraken::RGBController_NZXTKraken(NZXTKrakenController* nzxtkra
    WaterCooler.speed_min  = NZXT_KRAKEN_SPEED_SLOWEST;
    WaterCooler.speed_max  = NZXT_KRAKEN_SPEED_FASTEST;
    WaterCooler.speed      = NZXT_KRAKEN_SPEED_NORMAL;
+    WaterCooler.colors_min = 1;
+    WaterCooler.colors_max = 1;
    WaterCooler.color_mode = MODE_COLORS_NONE;
+    WaterCooler.colors.resize(1);
    modes.push_back(WaterCooler);

    mode Loading;
@@ -1221,74 +1221,6 @@ static const razer_device cynosa_chroma_device =
    CYNOSA_CHROMA_KEYMAP_SIZE
 };

-/*-------------------------------------------------------------*\
-|  Razer Cynosa v2 1532:025E                                    |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       6 Rows, 22 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone cynosa_v2_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    22
-};
-
-static const razer_device cynosa_v2_device =
-{
-    "Razer Cynosa v2",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    22,
-    {
-        &cynosa_v2_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Cynosa Lite 1532:023F                                  |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone cynosa_lite_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device cynosa_lite_device =
-{
-    "Razer Cynosa Lite",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    1,
-    1,
-    {
-        &cynosa_lite_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Ornata Chroma                                          |
 |                                                               |
@@ -1678,39 +1610,6 @@ static const razer_device blade_stealth_late_2019_device =
    NULL,
    0
 };
-/*-------------------------------------------------------------*\
-|  Razer Blade Stealth (Early 2020) 1532:0252                   |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_stealth_early_2020_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device blade_stealth_early_2020_device =
-{
-    "Razer Blade Stealth (Early 2020)",
-    DEVICE_TYPE_KEYBOARD,
-    false,
-    1,
-    1,
-    {
-        &blade_stealth_late_2019_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};

 /*-------------------------------------------------------------*\
 |  Razer Blade (Late 2016)                                      |
@@ -1985,40 +1884,6 @@ static const razer_device blade_15_mid_2019_base_device =
    0
 };

-/*-------------------------------------------------------------*\
-|  Razer Blade 15 (Early 2020) Base Model 1532:0255             |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Linear                                                  |
-|       1 Row, 16 Columns                                       |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_15_early_2020_base_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_LINEAR,
-    1,
-    16
-};
-
-static const razer_device blade_15_early_2020_base_device =
-{
-    "Razer Blade 15 Base (Early 2020)",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    1,
-    16,
-    {
-        &blade_15_early_2020_base_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Blade 15 Studio Edition (2019)                         |
 |                                                               |
@@ -2222,40 +2087,6 @@ static const razer_device blade_pro_late_2019_device =
    0
 };

-/*-------------------------------------------------------------*\
-|  Razer Blade Advanced (2020) 1532:0253                        |
-|                                                               |
-|   Zone "Keyboard"                                             |
-|       Matrix                                                  |
-|       6 Rows, 16 Columns                                      |
-\*-------------------------------------------------------------*/
-static const razer_zone blade_15_advanced_2020_zone =
-{
-    "Keyboard",
-    ZONE_TYPE_MATRIX,
-    6,
-    16
-};
-
-static const razer_device blade_15_advanced_2020_device =
-{
-    "Razer Blade 15 Advanced (2020)",
-    DEVICE_TYPE_KEYBOARD,
-    true,
-    6,
-    16,
-    {
-        &blade_15_advanced_2020_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------------------*\
 |  MICE                                                                     |
 \*-------------------------------------------------------------------------*/
@@ -2640,146 +2471,6 @@ static const razer_device lancehead_te_device =
    0
 };

-/*-------------------------------------------------------------*\
-|  Razer Lancehead V2 (Wired) 1532:0070                         |
-|                                                               |
-|  Zone "Right"                                                 |
-|       Linear                                                  |
-|       8 LEDs                                                  |
-|                                                               |
-|  Zone "Left"                                                  |
-|       Linear                                                  |
-|       8 LEDs                                                  |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone lancehead_v2_wired_right_zone =
-{
-    "Right LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    8
-};
-
-static const razer_zone lancehead_v2_wired_left_zone =
-{
-    "Left LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    8
-};
-
-static const razer_zone lancehead_v2_wired_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone lancehead_v2_wired_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device lancehead_v2_wired_device =
-{
-    "Razer Lancehead Wireless (Wired)",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    18,
-    {
-        &lancehead_v2_wired_right_zone,
-        &lancehead_v2_wired_left_zone,
-        &lancehead_v2_wired_logo_zone,
-        &lancehead_v2_wired_scroll_wheel_zone,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Lancehead V2 (Wireless) 1532:006F                      |
-|                                                               |
-|  Zone "Right"                                                 |
-|       Linear                                                  |
-|       8 LEDs                                                  |
-|                                                               |
-|  Zone "Left"                                                  |
-|       Linear                                                  |
-|       8 LEDs                                                  |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Single                                                  |
-|       1 LED                                                   |
-|                                                               |
-|  Zone "Scroll Wheel"                                          |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone lancehead_v2_wireless_right_zone =
-{
-    "Right LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    8
-};
-
-static const razer_zone lancehead_v2_wireless_left_zone =
-{
-    "Left LED Strip",
-    ZONE_TYPE_LINEAR,
-    1,
-    8
-};
-
-static const razer_zone lancehead_v2_wireless_logo_zone =
-{
-    "Logo",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_zone lancehead_v2_wireless_scroll_wheel_zone =
-{
-    "Scroll Wheel",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device lancehead_v2_wireless_device =
-{
-    "Razer Lancehead Wireless (Receiver)",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    18,
-    {
-        &lancehead_v2_wireless_right_zone,
-        &lancehead_v2_wireless_left_zone,
-        &lancehead_v2_wireless_logo_zone,
-        &lancehead_v2_wireless_scroll_wheel_zone,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Mamba 2012 (Wired)                                     |
 |                                                               |
@@ -3324,98 +3015,30 @@ static const razer_device naga_trinity_device =
    0
 };

-/*-------------------------------------------------------------*\
-|  Razer Viper Mini 1532:008A                                   |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Matrix                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone viper_mini_logo_zone =
-{
-    "Logo",      //Matrix of one as per https://github.com/openrazer/openrazer/blob/master/daemon/openrazer_daemon/hardware/mouse.py#L27
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device viper_mini_device =
-{
-    "Razer Viper Mini",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    1,
-    {
-        &viper_mini_logo_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Viper Ultimate Wired 1532:007A                         |
 |                                                               |
 |  Zone "Logo"                                                  |
-|       Matrix                                                  |
-|       1 LED                                                   |
+|       Linear                                                  |
+|       20 LEDs                                                 |
 \*-------------------------------------------------------------*/
-static const razer_zone viper_ultimate_wired_logo_zone =
+static const razer_zone viper_ultimate_logo_zone =
 {
-    "Logo",      //Matrix of one as per https://github.com/openrazer/openrazer/blob/master/daemon/openrazer_daemon/hardware/mouse.py#L1690
-    ZONE_TYPE_SINGLE,
+    "Matrix Zone",      //Defined as a logo zone upstream
+    ZONE_TYPE_LINEAR,
    1,
-    1
+    20
 };

-static const razer_device viper_ultimate_wired_device =
+static const razer_device viper_ultimate_device =
 {
-    "Razer Viper Ultimate (Wired)",
+    "Razer Viper Ultimate",
    DEVICE_TYPE_MOUSE,
    true,
    1,
-    1,
+    20,
    {
-        &viper_ultimate_wired_logo_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Viper Ultimate Wireless 1532:007B                      |
-|                                                               |
-|  Zone "Logo"                                                  |
-|       Matrix                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone viper_ultimate_wireless_logo_zone =
-{
-    "Logo",      //Matrix of one as per https://github.com/openrazer/openrazer/blob/master/daemon/openrazer_daemon/hardware/mouse.py#L1690
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device viper_ultimate_wireless_device =
-{
-    "Razer Viper Ultimate (Wireless)",
-    DEVICE_TYPE_MOUSE,
-    true,
-    1,
-    1,
-    {
-        &viper_ultimate_wireless_logo_zone,
+        &viper_ultimate_logo_zone,
        NULL,
        NULL,
        NULL,
@@ -3790,74 +3413,6 @@ static const razer_device kraken_v2_device =
    0
 };

-/*-------------------------------------------------------------*\
-|  Razer Kraken Ultimate 1532:0527                              |
-|                                                               |
-|  Zone "Headset"                                               |
-|       Single                                                  |
-|       1 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone kraken_ultimate_zone =
-{
-    "Headset",
-    ZONE_TYPE_SINGLE,
-    1,
-    1
-};
-
-static const razer_device kraken_ultimate_device =
-{
-    "Razer Kraken Ultimate",
-    DEVICE_TYPE_HEADSET,
-    true,
-    1,
-    1,
-    {
-        &kraken_ultimate_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
-/*-------------------------------------------------------------*\
-|  Razer Kraken Kitty Edition 1532:0F19                         |
-|                                                               |
-|  Zone "Headset"                                               |
-|       Matrix                                                  |
-|       4 LED                                                   |
-\*-------------------------------------------------------------*/
-static const razer_zone kraken_kitty_zone =
-{
-    "Headset",
-    ZONE_TYPE_LINEAR,
-    1,
-    4
-};
-
-static const razer_device kraken_kitty_device =
-{
-    "Razer Kraken Kitty Edition",
-    DEVICE_TYPE_HEADSET,
-    true,
-    1,
-    4,
-    {
-        &kraken_kitty_zone,
-        NULL,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-    },
-    NULL,
-    0
-};
-
 /*-------------------------------------------------------------*\
 |  Razer Tiamat 7.1 V2                                          |
 |                                                               |
@@ -4217,8 +3772,6 @@ static const razer_device* device_list[] =
    &blackwidow_x_chroma_device,
    &blackwidow_x_chroma_te_device,
    &cynosa_chroma_device,
-    &cynosa_v2_device,
-    &cynosa_lite_device,
    &deathstalker_chroma_device,
    &huntsman_device,
    &huntsman_elite_device,
@@ -4233,7 +3786,6 @@ static const razer_device* device_list[] =
    &blade_stealth_late_2017_device,
    &blade_stealth_2019_device,
    &blade_stealth_late_2019_device,
-    &blade_stealth_early_2020_device,
    &blade_late_2016_device,
    &blade_qhd_device,
    &blade_15_2018_device,
@@ -4242,14 +3794,12 @@ static const razer_device* device_list[] =
    &blade_15_2019_advanced_device,
    &blade_15_mid_2019_mercury_device,
    &blade_15_mid_2019_base_device,
-    &blade_15_early_2020_base_device,
    &blade_15_studio_2019_device,
    &blade_pro_late_2016_device,
    &blade_pro_2017_device,
    &blade_pro_2017_fullhd_device,
    &blade_pro_17_2019_device,
    &blade_pro_late_2019_device,
-    &blade_15_advanced_2020_device,
 /*-----------------------------------------------------------------*\
 |  MICE                                                             |
 \*-----------------------------------------------------------------*/
@@ -4261,8 +3811,6 @@ static const razer_device* device_list[] =
    &deathadder_v2_device,
    &diamondback_chroma_device,
    &lancehead_te_device,
-    &lancehead_v2_wired_device,
-    &lancehead_v2_wireless_device,
    &mamba_2012_wired_device,
    &mamba_2012_wireless_device,
    &mamba_wired_device,
@@ -4275,9 +3823,7 @@ static const razer_device* device_list[] =
    &naga_epic_chroma_device,
    &naga_hex_v2_device,
    &naga_trinity_device,
-    &viper_mini_device,
-    &viper_ultimate_wired_device,
-    &viper_ultimate_wireless_device,
+    &viper_ultimate_device,
 /*-----------------------------------------------------------------*\
 |  KEYPADS                                                          |
 \*-----------------------------------------------------------------*/
@@ -4296,8 +3842,6 @@ static const razer_device* device_list[] =
 \*-----------------------------------------------------------------*/
    &kraken_chroma_device,
    &kraken_v2_device,
-    &kraken_ultimate_device,
-    &kraken_kitty_device,
    &tiamat_71_v2_device,
 /*-----------------------------------------------------------------*\
 |  OTHER                                                            |
@@ -25,7 +25,6 @@ PhilipsWizController::PhilipsWizController(std::string ip)
    /*-----------------------------------------------------------------*\
    | Start a thread to handle responses received from the Wiz device   |
    \*-----------------------------------------------------------------*/
-    ReceiveThreadRun = 1;
    ReceiveThread = new std::thread(&PhilipsWizController::ReceiveThreadFunction, this);

    /*-----------------------------------------------------------------*\
@@ -36,9 +35,7 @@ PhilipsWizController::PhilipsWizController(std::string ip)

 PhilipsWizController::~PhilipsWizController()
 {
-    ReceiveThreadRun = 0;
-    ReceiveThread->join();
-    delete ReceiveThread;
+
 }

 std::string PhilipsWizController::GetLocation()
@@ -93,7 +90,7 @@ void PhilipsWizController::ReceiveThreadFunction()
 {
    char recv_buf[1024];

-    while(ReceiveThreadRun.load())
+    while(1)
    {
        /*-----------------------------------------------------------------*\
        | Receive up to 1024 bytes from the device                          |
@@ -37,5 +37,4 @@ private:
    std::string         location;
    net_port            port;
    std::thread*        ReceiveThread;
-    std::atomic<bool>   ReceiveThreadRun;
 };
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.cpp      |
+|  PolychromeController.cpp                 |
 |                                           |
 |  Driver for for ASRock ASR LED and        |
 |  Polychrome RGB lighting controller       |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/14/2019  |
 \*-----------------------------------------*/

-#include "ASRockPolychromeSMBusController.h"
+#include "PolychromeController.h"
 #include <cstring>

 using namespace std::chrono_literals;
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.h        |
+|  PolychromeController.h                   |
 |                                           |
 |  Definitions and types for ASRock         |
 |  ASR LED and Polychrome RGB lighting      |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "ASRockPolychromeSMBusController.h"
+#include "PolychromeController.h"
 #include "RGBController.h"
-#include "RGBController_ASRockPolychromeSMBus.h"
+#include "RGBController_Polychrome.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
 #include <vector>
@@ -10,14 +10,14 @@

 /******************************************************************************************\
 *                                                                                          *
-*   TestForPolychromeSMBusController                                                       *
+*   TestForPolychromeController                                                            *
 *                                                                                          *
 *       Tests the given address to see if an ASRock Polychrome RGB controller exists there.*
 *       First does a quick write to test for a response                                    *
 *                                                                                          *
 \******************************************************************************************/

-bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address)
 {
    bool pass = false;

@@ -36,15 +36,15 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char ad
 *                                                                                          *
 *   DetectPolychromeControllers                                                            *
 *                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
+*       Detect ASRock Polychrome RGB controllers on the enumerated I2C busses at address   *
+*       0x6A.                                                                              *
 *                                                                                          *
 *           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
 *           dev - I2C address of Polychrome device                                         *
 *                                                                                          *
 \******************************************************************************************/

-void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
    PolychromeController* new_polychrome;
    RGBController_Polychrome* new_controller;
@@ -54,7 +54,7 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses,
        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
        {
            // Check for Polychrome controller at 0x6A
-            if (TestForPolychromeSMBusController(busses[bus], 0x6A))
+            if (TestForPolychromeController(busses[bus], 0x6A))
            {
                new_polychrome = new PolychromeController(busses[bus], 0x6A);

@@ -71,6 +71,6 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses,
        }
    }

-}   /* DetectSMBusPolychromeControllers() */
+}   /* DetectPolychromeControllers() */

-REGISTER_I2C_DETECTOR("ASRock Polychrome SMBus", DetectPolychromeSMBusControllers);
+REGISTER_I2C_DETECTOR("ASRock Polychrome", DetectPolychromeControllers);
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
+|  RGBController_Polychrome.cpp             |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/15/2019  |
 \*-----------------------------------------*/

-#include "RGBController_ASRockPolychromeSMBus.h"
+#include "RGBController_Polychrome.h"

 #define ASROCK_MAX_ZONES    4
 #define ASROCK_MAX_LEDS     22
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.h    |
+|  RGBController_Polychrome.h               |
 |                                           |
 |  Generic RGB Interface for OpenRGB        |
 |  ASRock ASR LED and Polychrome RGB Driver |
@@ -10,7 +10,7 @@
 #pragma once

 #include "RGBController.h"
-#include "ASRockPolychromeSMBusController.h"
+#include "PolychromeController.h"

 class RGBController_Polychrome : public RGBController
 {
@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  ThermaltakePoseidonZRGBController.cpp    |
+|  PoseidonZRGBController.cpp               |
 |                                           |
 |  Driver for Thermaltake Poseidon Z RGB    |
 |  Keyboard lighting controller             |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/25/2019  |
 \*-----------------------------------------*/

-#include "ThermaltakePoseidonZRGBController.h"
+#include "PoseidonZRGBController.h"

 #include <cstring>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  ThermaltakePoseidonZRGBController.h      |
+|  PoseidonZRGBController.h                 |
 |                                           |
 |  Definitions and types for Thermaltake    |
 |  Poseidon Z RGB Keyboard lighting         |
@@ -1,7 +1,7 @@
 #include "Detector.h"
-#include "ThermaltakePoseidonZRGBController.h"
+#include "PoseidonZRGBController.h"
 #include "RGBController.h"
-#include "RGBController_ThermaltakePoseidonZRGB.h"
+#include "RGBController_PoseidonZRGB.h"
 #include <vector>
 #include <hidapi/hidapi.h>

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_ThermaltakePoseidonZRGB.cpp|
+|  RGBController_PoseidonZRGB.cpp           |
 |                                           |
 |  Generic RGB Interface for Thermaltake    |
 |  Poseidon Z RGB Keyboard                  |
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 12/25/2019  |
 \*-----------------------------------------*/

-#include "RGBController_ThermaltakePoseidonZRGB.h"
+#include "RGBController_PoseidonZRGB.h"

 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Honse	70901d6ef6	openrgb_qmk_testing	2020-11-23 02:05:33 -06:00
Kasper	8dace12920	Fix Linux build not compiling	2020-11-12 20:16:03 +02:00
Kasper	f7af8a432e	Implemented a qmk rgb matrix controller	2020-11-11 04:14:40 +02:00