Store name in AsusAuraUSBControllers to avoid setting it in detectors

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.cpp

@@ -13,10 +13,11 @@
 #include "AsusAuraHeadsetStandController.h"
 #include "StringUtils.h"
 
-AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
+AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
 }
 
 AuraHeadsetStandController::~AuraHeadsetStandController()
@@ -29,6 +30,11 @@ std::string AuraHeadsetStandController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraHeadsetStandController::GetName()
+{
+    return(name);
+}
+
 std::string AuraHeadsetStandController::GetSerialString()
 {
     wchar_t serial_string[128];

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.h

@@ -33,10 +33,11 @@ enum
 class AuraHeadsetStandController
 {
 public:
-    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
+    AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name);
     virtual ~AuraHeadsetStandController();
 
     std::string GetDeviceLocation();
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion();
 
@@ -60,4 +61,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -26,7 +26,7 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 {
     controller                      = controller_ptr;
 
-    name        = "ASUS Aura Headset Stand";
+    name                            = controller->GetName();
     vendor                          = "ASUS";
     type                            = DEVICE_TYPE_HEADSET_STAND;
     description                     = "ASUS Aura Headset Stand Device";

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.cpp

@@ -13,10 +13,11 @@
 #include "AsusAuraKeyboardController.h"
 #include "StringUtils.h"
 
-AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
+AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
 }
 
 AuraKeyboardController::~AuraKeyboardController()
@@ -29,6 +30,11 @@ std::string AuraKeyboardController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraKeyboardController::GetNameString()
+{
+    return(name);
+}
+
 std::string AuraKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.h

@@ -19,10 +19,11 @@
 class AuraKeyboardController
 {
 public:
-    AuraKeyboardController(hid_device* dev_handle, const char* path);
+    AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
     virtual ~AuraKeyboardController();
 
     std::string GetDeviceLocation();
+    std::string GetNameString();
     std::string GetSerialString();
 
     void        SendDirect
@@ -34,4 +35,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -361,7 +361,7 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
     controller          = controller_ptr;
     layout              = keyboard_layout;
 
-    name        = "ASUS Aura Keyboard";
+    name                = controller->GetNameString();
     vendor              = "ASUS";
     type                = DEVICE_TYPE_KEYBOARD;
     description         = "ASUS Aura Keyboard Device";

Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.cpp

@@ -14,11 +14,12 @@
 #include "LogManager.h"
 #include "StringUtils.h"
 
-AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
+AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
+    name        = dev_name;
 }
 
 AuraMonitorController::~AuraMonitorController()
@@ -31,6 +32,11 @@ std::string AuraMonitorController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraMonitorController::GetNameString()
+{
+    return(name);
+}
+
 std::string AuraMonitorController::GetSerialString()
 {
     wchar_t serial_string[128];

Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.h

@@ -27,10 +27,11 @@ enum
 class AuraMonitorController
 {
 public:
-    AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid);
+    AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
     virtual ~AuraMonitorController();
 
     std::string GetDeviceLocation();
+    std::string GetNameString();
     std::string GetSerialString();
 
     void        BeginUpdate();
@@ -42,4 +43,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -26,7 +26,7 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 {
     controller          = controller_ptr;
 
-    name        = "ASUS Aura Monitor";
+    name                = controller->GetNameString();
     vendor              = "ASUS";
     type                = DEVICE_TYPE_MONITOR;
     description         = "ASUS Aura Monitor Device";

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.cpp

@@ -15,11 +15,12 @@
 
 #define HID_MAX_STR 255
 
-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
+AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
+    name        = dev_name;
 }
 
 AuraMouseController::~AuraMouseController()
@@ -32,30 +33,9 @@ std::string AuraMouseController::GetDeviceLocation()
     return("HID: " + location);
 }
 
-std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+std::string AuraMouseController::GetName()
 {
-    /*---------------------------------------------------------------*\
+    return(name);
-    | Cleans garbage at the end of serial numbers                     |
-    | (apparently 2 characters too much, but maybe variable)          |
-    | Limited to new devices, old ones don't even have serial numbers |
-    \*---------------------------------------------------------------*/
-    std::string result;
-    for(wchar_t c : wstr)
-    {
-        /*-----------------------------------------------------*\
-        | Forbid anything besides digits and upper case letters |
-        \*-----------------------------------------------------*/
-        bool isUpperCaseLetter = (c >= 64 && c <= 90);
-        bool isDigit           = (c >= 48 && c <= 57);
-        if(!isUpperCaseLetter && !isDigit)
-        {
-            break;
-        }
-
-        result += (char)c;
-    }
-
-    return(result);
 }
 
 std::string AuraMouseController::GetSerialString()
@@ -125,6 +105,32 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
     return str;
 }
 
+std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
+{
+    /*---------------------------------------------------------------*\
+    | Cleans garbage at the end of serial numbers                     |
+    | (apparently 2 characters too much, but maybe variable)          |
+    | Limited to new devices, old ones don't even have serial numbers |
+    \*---------------------------------------------------------------*/
+    std::string result;
+    for(wchar_t c : wstr)
+    {
+        /*-----------------------------------------------------*\
+        | Forbid anything besides digits and upper case letters |
+        \*-----------------------------------------------------*/
+        bool isUpperCaseLetter = (c >= 64 && c <= 90);
+        bool isDigit           = (c >= 48 && c <= 57);
+        if(!isUpperCaseLetter && !isDigit)
+        {
+            break;
+        }
+
+        result += (char)c;
+    }
+
+    return(result);
+}
+
 void AuraMouseController::SaveMode()
 {
     unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.h

@@ -21,14 +21,16 @@
 class AuraMouseController
 {
 public:
-    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
+    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
     virtual ~AuraMouseController();
 
     std::string GetDeviceLocation();
-    std::string CleanSerial(const std::wstring& wstr);
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion(bool wireless, int protocol);
 
+    std::string CleanSerial(const std::wstring& wstr);
+
     void        SaveMode();
     void        SendUpdate
                     (
@@ -52,4 +54,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -37,7 +37,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
     pid                             = controller->device_pid;
 
-    name                    = "ASUS Aura Mouse";
+    name                            = controller->GetName();
     vendor                          = "ASUS";
     type                            = DEVICE_TYPE_MOUSE;
     description                     = "ASUS Aura Mouse Device";

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.cpp

@@ -15,11 +15,12 @@
 #include "AsusAuraMouseGen1Controller.h"
 #include "StringUtils.h"
 
-AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
+AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
     device_pid  = pid;
+    name        = dev_name;
 }
 
 AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
@@ -32,6 +33,11 @@ std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AsusAuraMouseGen1Controller::GetName()
+{
+    return(name);
+}
+
 std::string AsusAuraMouseGen1Controller::GetSerialString()
 {
     wchar_t serial_string[HID_MAX_STR];

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.h

@@ -21,12 +21,14 @@
 class AsusAuraMouseGen1Controller
 {
 public:
-    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
+    AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
     virtual ~AsusAuraMouseGen1Controller();
 
     std::string GetDeviceLocation();
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion();
+
     int         GetActiveProfile();
 
     void        SendUpdate
@@ -41,6 +43,7 @@ public:
                     unsigned char   profile,
                     unsigned char   value
                     );
+
     void        SendDirectSpatha(std::vector<RGBColor> colors);
 
     void        ResetToSavedLighting();
@@ -50,4 +53,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -30,7 +30,7 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 {
     controller                  = controller_ptr;
 
-    name                        = "ASUS ROG Spatha";
+    name                        = controller->GetName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_MOUSE;
     description                 = "ASUS Aura Mouse Device";

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -26,7 +26,7 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 {
     controller                  = controller_ptr;
 
-    name                        = "ASUS ROG Strix Evolve";
+    name                        = controller->GetName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_MOUSE;
     description                 = "ASUS Aura Mouse Device";

Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.cpp

@@ -13,10 +13,11 @@
 #include "AsusAuraMousematController.h"
 #include "StringUtils.h"
 
-AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
+AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
 }
 
 AuraMousematController::~AuraMousematController()
@@ -29,6 +30,11 @@ std::string AuraMousematController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraMousematController::GetName()
+{
+    return(name);
+}
+
 std::string AuraMousematController::GetSerialString()
 {
     wchar_t serial_string[128];

Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h

@@ -31,10 +31,11 @@ enum
 class AuraMousematController
 {
 public:
-    AuraMousematController(hid_device* dev_handle, const char* path);
+    AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
     virtual ~AuraMousematController();
 
     std::string GetDeviceLocation();
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion();
 
@@ -57,4 +58,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -26,7 +26,7 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 {
     controller                  = controller_ptr;
 
-    name                        = "ASUS Aura Mousemat";
+    name                        = controller->GetName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_MOUSEMAT;
     description                 = "ASUS Aura Mousemat Device";

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

@@ -12,7 +12,7 @@
 
 #include "AsusAuraRyuoAIOController.h"
 
-AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
 {
     /*-----------------------------------------------------*\
     | Add addressable devices                               |

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.h

@@ -60,7 +60,7 @@ public:
         SPEED_FASTEST     = 0x00, // Fastest speed
     };
 
-    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
+    AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name);
     ~AsusAuraRyuoAIOController();
 
     std::string             GetLocation();

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -29,7 +29,7 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
     controller                  = controller_ptr;
     uint8_t speed               = controller->SPEED_NORMAL;
 
-    name                        = "ROG Ryuo AIO";
+    name                        = controller->GetDeviceName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_COOLER;
     description                 = "ASUS Liquid Cooler with 120mm and 240mm radiators.";

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.cpp

@@ -21,10 +21,11 @@
 
 #define HID_MAX_STR 128
 
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
+AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
     device_pid  = pid;
     rev_version = version;
 
@@ -41,6 +42,11 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string AuraTUFKeyboardController::GetName()
+{
+    return(name);
+}
+
 std::string AuraTUFKeyboardController::GetSerialString()
 {
     wchar_t serial_string[HID_MAX_STR];

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.h

@@ -67,12 +67,14 @@ struct led_color
 class AuraTUFKeyboardController
 {
 public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
+    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name);
     ~AuraTUFKeyboardController();
 
     std::string GetDeviceLocation();
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion();
+
     int         GetLayout();
     int         GetNumpadLocation();
     void        SaveMode();
@@ -127,6 +129,7 @@ public:
                     unsigned char           speed,
                     unsigned char           brightness
                     );
+
     void        UpdateQuicksandColors(std::vector<RGBColor> colors);
     void        UpdateMode(unsigned char mode);
     void        AwaitResponse(int ms);
@@ -138,6 +141,7 @@ public:
 private:
     hid_device*     dev;
     std::string     location;
+    std::string     name;
     unsigned short  rev_version;
 };
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -32,7 +32,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
     if(pid != AURA_ROG_CLAYMORE_PID)
     {
-        name        = "ASUS Aura Keyboard";
+        name                            = controller->GetName();
         vendor                          = "ASUS";
         type                            = DEVICE_TYPE_KEYBOARD;
         description                     = "ASUS Aura Keyboard Device";
@@ -51,6 +51,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 AURA_KEYBOARD_SPEED_MAX          = 2;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 1;
                 break;
+
             case AURA_ROG_STRIX_FLARE_PID:
             case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
             case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
@@ -60,6 +61,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 AURA_KEYBOARD_SPEED_MAX          = 0;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 8;
                 break;
+
             case AURA_ROG_AZOTH_USB_PID:
             case AURA_ROG_AZOTH_2_4_PID:
             case AURA_ROG_FALCHION_WIRED_PID:
@@ -79,10 +81,12 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
                 AURA_KEYBOARD_SPEED_MAX          = 0;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 30;
                 break;
+
             default:
                 AURA_KEYBOARD_SPEED_MIN          = 15;
                 AURA_KEYBOARD_SPEED_MAX          = 0;
                 AURA_KEYBOARD_SPEED_DEFAULT      = 8;
+                break;
         }
 
         mode Direct;
@@ -109,8 +113,10 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         Breathing.name                  = "Breathing";
         Breathing.value                 = AURA_KEYBOARD_MODE_BREATHING;
         Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
+        if(controller->is_per_led_keyboard)
-
+        {
+            Breathing.flags            |= MODE_FLAG_HAS_RANDOM_COLOR;
+        }
         Breathing.speed_min             = AURA_KEYBOARD_SPEED_MIN;
         Breathing.speed_max             = AURA_KEYBOARD_SPEED_MAX;
         Breathing.speed                 = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -140,8 +146,10 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
         Wave.name                       = "Rainbow Wave";
         Wave.value                      = AURA_KEYBOARD_MODE_WAVE;
         Wave.flags                      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
+        if(controller->is_per_led_keyboard)
-
+        {
+            Wave.flags                 |= MODE_FLAG_HAS_DIRECTION_UD;
+        }
         Wave.speed_min                  = AURA_KEYBOARD_SPEED_MIN;
         Wave.speed_max                  = AURA_KEYBOARD_SPEED_MAX;
         Wave.speed                      = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -268,7 +276,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
     else
     {
 
-        name        = "ASUS ROG Claymore";
+        name                            = controller->GetName();
         vendor                          = "ASUS";
         type                            = DEVICE_TYPE_KEYBOARD;
         description                     = "ASUS Aura Keyboard Device";

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -12,7 +12,7 @@
 #include <cstring>
 #include "AsusAuraAddressableController.h"
 
-AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
 {
     /*-----------------------------------------------------*\
     | Add addressable devices                               |

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -24,7 +24,7 @@ enum
 class AuraAddressableController : public AuraUSBController
 {
 public:
-    AuraAddressableController(hid_device* dev_handle, const char* path);
+    AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name);
     ~AuraAddressableController();
 
     void SetChannelLEDs

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -12,7 +12,7 @@
 #include <cstring>
 #include "AsusAuraMainboardController.h"
 
-AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
+AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name), mode(AURA_MODE_DIRECT)
 {
     unsigned char num_total_mainboard_leds  = config_table[0x1B];
     unsigned char num_rgb_headers           = config_table[0x1D];

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -26,7 +26,7 @@ enum
 class AuraMainboardController : public AuraUSBController
 {
 public:
-    AuraMainboardController(hid_device* dev_handle, const char* path);
+    AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name);
     ~AuraMainboardController();
 
     void SetChannelLEDs

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -14,10 +14,11 @@
 #include "LogManager.h"
 #include "StringUtils.h"
 
-AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
+AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
 
     GetFirmwareVersion();
     GetConfigTable();
@@ -40,7 +41,7 @@ std::string AuraUSBController::GetDeviceLocation()
 
 std::string AuraUSBController::GetDeviceName()
 {
-    return(device_name);
+    return(name);
 }
 
 std::string AuraUSBController::GetSerialString()
@@ -56,6 +57,11 @@ std::string AuraUSBController::GetSerialString()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
+std::string AuraUSBController::GetDeviceVersion()
+{
+    return(std::string(version));
+}
+
 const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
 {
     return(device_info);
@@ -89,11 +95,11 @@ void AuraUSBController::GetConfigTable()
     {
         memcpy(config_table, &usb_buf[4], 60);
 
-        LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name);
+        LOG_DEBUG("[%s] ASUS Aura USB config table:", version);
 
         for(int i = 0; i < 60; i+=6)
         {
-            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name,
+            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", version,
                                                             config_table[i + 0],
                                                             config_table[i + 1],
                                                             config_table[i + 2],
@@ -104,7 +110,7 @@ void AuraUSBController::GetConfigTable()
     }
     else
     {
-        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
+        LOG_INFO("[%s] Could not read config table, can not add device", version);
         delete this;
     }
 }
@@ -135,7 +141,7 @@ void AuraUSBController::GetFirmwareVersion()
     \*-----------------------------------------------------*/
     if(usb_buf[1] == 0x02)
     {
-        memcpy(device_name, &usb_buf[2], 16);
+        memcpy(version, &usb_buf[2], 16);
     }
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.h

@@ -64,7 +64,7 @@ struct AuraDeviceInfo
 class AuraUSBController
 {
 public:
-    AuraUSBController(hid_device* dev_handle, const char* path);
+    AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name);
     virtual ~AuraUSBController();
 
     unsigned int GetChannelCount();
@@ -72,6 +72,7 @@ public:
     std::string GetDeviceLocation();
     std::string GetDeviceName();
     std::string GetSerialString();
+    std::string GetDeviceVersion();
 
     const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
 
@@ -96,6 +97,8 @@ protected:
     unsigned char               config_table[60];
     std::vector<AuraDeviceInfo> device_info;
     std::string                 location;
+    std::string                 name;
+    char                        version[16];
 
     void SendDirect
         (
@@ -103,10 +106,8 @@ protected:
         unsigned char   led_count,
         RGBColor *      colors
         );
+
 private:
-    char                        device_name[16];
-
     void GetConfigTable();
-
     void GetFirmwareVersion();
 };

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp

@@ -26,7 +26,6 @@
 RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
     RGBController_AuraUSB(controller_ptr)
 {
-    name        = "ASUS Aura USB Mainboard";
     description = "ASUS Aura USB Mainboard Device";
 
     /*-------------------------------------------------------*\

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -28,13 +28,13 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
 {
     controller                  = controller_ptr;
 
-    name        = "ASUS Aura USB";
+    name                        = controller->GetDeviceName();
     vendor                      = "ASUS";
-    version     = controller->GetDeviceName();
     type                        = DEVICE_TYPE_MOTHERBOARD;
     description                 = "ASUS Aura USB Device";
     location                    = controller->GetDeviceLocation();
     serial                      = controller->GetSerialString();
+    version                     = controller->GetDeviceVersion();
 
     mode Direct;
     Direct.name                 = "Direct";

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -83,7 +83,6 @@
 /*-----------------------------------------------------------------*\
 |  MICE - defined in AsusAuraMouseDevices.h                         |
 \*-----------------------------------------------------------------*/
-
 #define AURA_ROG_STRIX_EVOLVE_PID                           0x185B
 #define AURA_ROG_SPATHA_WIRED_PID                           0x181C
 #define AURA_ROG_SPATHA_WIRELESS_PID                        0x1824
@@ -97,7 +96,6 @@
 /*-----------------------------------------------------------------*\
 | MONITORS                                                          |
 \*-----------------------------------------------------------------*/
-
 #define AURA_ROG_STRIX_XG27AQ_PID                           0x198C
 #define AURA_ROG_STRIX_XG27AQM_PID                          0x19BB
 #define AURA_ROG_STRIX_XG279Q_PID                           0x1919
@@ -108,7 +106,6 @@
 /*-----------------------------------------------------------------*\
 | HEADSET STANDS                                                    |
 \*-----------------------------------------------------------------*/
-
 #define AURA_ROG_THRONE_PID                                 0x18D9
 #define AURA_ROG_THRONE_QI_PID                              0x18C5
 #define AURA_ROG_THRONE_QI_GUNDAM_PID                       0x1994
@@ -148,9 +145,9 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
+        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, name);
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -162,9 +159,9 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
     if(dev)
     {
         DMIInfo                    dmi;
-        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
+        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
-        rgb_controller->name                                = "ASUS " + dmi.getMainboard() + " Addressable";
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -178,9 +175,9 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
         try
         {
             DMIInfo                      dmi;
-            AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
+            AuraMainboardController*     controller         = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
             RGBController_AuraMainboard* rgb_controller     = new RGBController_AuraMainboard(controller);
-            rgb_controller->name                            = "ASUS " + dmi.getMainboard();
+
             ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         catch(const std::runtime_error& ex)
@@ -197,10 +194,10 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraKeyboardController*       controller            = new AuraKeyboardController(dev, info->path);
+        AuraKeyboardController*       controller            = new AuraKeyboardController(dev, info->path, name);
         AuraKeyboardMappingLayoutType layout                = GetKeyboardMappingLayoutType(info->product_id);
         RGBController_AuraKeyboard*   rgb_controller        = new RGBController_AuraKeyboard(controller, layout);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -212,9 +209,9 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     if(dev)
     {
         uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid);
+        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid, name);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -225,9 +222,9 @@ void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraMousematController*     controller              = new AuraMousematController(dev, info->path);
+        AuraMousematController*     controller              = new AuraMousematController(dev, info->path, name);
         RGBController_AuraMousemat* rgb_controller          = new RGBController_AuraMousemat(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -238,9 +235,9 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AsusROGStrixLCController*     controller     = new AsusROGStrixLCController(dev, info->path);
+        AsusROGStrixLCController*     controller     = new AsusROGStrixLCController(dev, info->path, name);
         RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
-        rgb_controller->name                         = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -251,9 +248,9 @@ void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path);
+        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path, name);
         RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
-        rgb_controller->name                          = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -264,9 +261,9 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
         RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -277,9 +274,9 @@ void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
         RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -290,9 +287,9 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam
 
     if(dev)
     {
-        AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path);
+        AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path, name);
         RGBController_AuraHeadsetStand* rgb_controller      = new RGBController_AuraHeadsetStand(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -303,9 +300,9 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
 
     if(dev)
     {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
+        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
-        rgb_controller->name                                = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -316,9 +313,9 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path, info->product_id);
+        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path, info->product_id, name);
         RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
-        rgb_controller->name                            = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
@@ -329,9 +326,9 @@ void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
 
     if(dev)
     {
-        ROGAllyController*         controller           = new ROGAllyController(dev, info->path);
+        ROGAllyController*         controller           = new ROGAllyController(dev, info->path, name);
         RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
-        rgb_controller->name                            = name;
+
         ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }

Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.cpp

@@ -13,10 +13,11 @@
 #include "AsusROGAllyController.h"
 #include "StringUtils.h"
 
-ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
+ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name)
 {
     dev         = dev_handle;
     location    = path;
+    name        = dev_name;
 
     SendInitialization();
 }
@@ -31,6 +32,11 @@ std::string ROGAllyController::GetDeviceLocation()
     return("HID: " + location);
 }
 
+std::string ROGAllyController::GetName()
+{
+    return(name);
+}
+
 std::string ROGAllyController::GetSerialString()
 {
     wchar_t serial_string[128];

Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.h

@@ -40,10 +40,11 @@ enum
 class ROGAllyController
 {
 public:
-    ROGAllyController(hid_device* dev_handle, const char* path);
+    ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name);
     virtual ~ROGAllyController();
 
     std::string GetDeviceLocation();
+    std::string GetName();
     std::string GetSerialString();
     std::string GetVersion();
 
@@ -72,4 +73,5 @@ public:
 private:
     hid_device* dev;
     std::string location;
+    std::string name;
 };

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -26,7 +26,7 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 {
     controller                  = controller_ptr;
 
-    name                        = "ASUS ROG Ally";
+    name                        = controller->GetName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_GAMEPAD;
     description                 = "ASUS ROG Ally Device";

Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp

@@ -11,7 +11,7 @@
 
 #include "AsusROGStrixLCController.h"
 
-AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
+AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
 {
     /*-----------------------------------------------------*\
     | Add addressable devices                               |

Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h

@@ -58,7 +58,7 @@ enum
 class AsusROGStrixLCController : public AuraUSBController
 {
 public:
-    AsusROGStrixLCController(hid_device* dev_handle, const char* path);
+    AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name);
     ~AsusROGStrixLCController();
 
     std::string             GetLocation();

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -28,7 +28,7 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
     controller                  = controller_ptr;
     uint8_t speed               = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
 
-    name                        = "ROG Strix LC";
+    name                        = controller->GetDeviceName();
     vendor                      = "ASUS";
     type                        = DEVICE_TYPE_COOLER;
     description                 = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";