SDK v6: Implement client and server flags to indicate capabilities and negotiate local client status

* Split detection system out into its own class, DetectionManager
    * Clean up ResourceManger's many callbacks into just two, one for detection and one general purpose

.gitlab-ci.yml

@@ -536,7 +536,10 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 arm
+  - eval $(/opt/homebrew/bin/brew shellenv)
+  - qmake OpenRGB.pro
+  - make -j16
+  - macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -552,7 +555,10 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 arm
+  - eval $(/opt/homebrew/bin/brew shellenv)
+  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
+  - make -j16
+  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -568,7 +574,10 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 intel
+  - eval $(/usr/local/bin/brew shellenv)
+  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
+  - arch -x86_64 make -j16
+  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -584,7 +593,10 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 intel
+  - eval $(/usr/local/bin/brew shellenv)
+  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
+  - arch -x86_64 make -j16
+  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"

.gitlab/CODEOWNERS

@@ -22,12 +22,13 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDRAMController/
+/Controllers/CorsairDominatorPlatinumController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
+/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/

CONTRIBUTING.md

@@ -69,7 +69,3 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 
 Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
 In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
-
-## AI Guidelines
-
-OpenRGB is an open source project developed by humans for humans.  As a general rule, AI generated submissions are not permitted.  The licensing behind AI generated code is problematic.  If you choose to use AI for assistance in your development process, we can't stop you, but do not credit the AI in commits (no AI authorship/co-authorship).  Ultimately, you as a human developer are responsible for the code you submit and it is expected that any code you submit you fully understand and have manually vetted before submission.  Merge requests that appear to be straight from an AI output, commits with AI tool authorship or co-authorship tags, or otherwise AI generated submissions are subject to closure.

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -173,8 +173,6 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 
 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -205,6 +203,7 @@ void RGBController_BloodyB820R::SetupZones()
     {
         led new_led;
         new_led.name        = led_names[led_index];
+        new_led.value       = led_index;
         leds.push_back(new_led);
     }
 

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -67,13 +67,13 @@ void BloodyMouseController::InitDevice()
     hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
 }
 
-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets)
+void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
 {
     uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
 
     for(uint8_t i = 0; i < colors.size(); i++)
     {
-        uint8_t offset                              = 3 * (offsets[i]) + BLOODYMOUSE_DATA_BYTE;
+        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
 
         buffer[offset]                              = RGBGetRValue(colors[i]);
         buffer[offset + 1]                          = RGBGetGValue(colors[i]);

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

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

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

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

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

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

Controllers/AMBXController/AMBXController.cpp

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

Controllers/AMBXController/AMBXController.h

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

Controllers/AMBXController/RGBController_AMBX.cpp

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

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -11,33 +11,6 @@
 
 #include "RGBController_AMDWraithPrism.h"
 
-/*---------------------------------------------------------*\
-| LED maps                                                  |
-\*---------------------------------------------------------*/
-const unsigned char led_values[] =
-{
-    // Logo
-    0x00,
-    // Fan
-    0x01,
-    // Ring
-    0x08,
-    0x07,
-    0x06,
-    0x05,
-    0x04,
-    0x03,
-    0x02,
-    0x10,
-    0x0F,
-    0x0E,
-    0x0D,
-    0x0C,
-    0x0B,
-    0x0A,
-    0x09
-};
-
 /**------------------------------------------------------------------*\
     @name AMD Wraith Prism
     @category Cooler
@@ -159,13 +132,19 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_AMDWraithPrism::SetupZones()
 {
+    /*-----------------------------------------------------*\
+    | LED maps                                              |
+    \*-----------------------------------------------------*/
+    const unsigned int logo_leds[1]  =  { 0x00 };
+    const unsigned int fan_leds[1]   =  { 0x01 };
+    const unsigned int ring_leds[15] =  { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10,
+                                          0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
+
     /*-----------------------------------------------------*\
     | Set up zones                                          |
     \*-----------------------------------------------------*/
@@ -200,6 +179,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led logo_led;
         logo_led.name       = "Logo LED";
+        logo_led.value      = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
@@ -207,6 +187,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led fan_led;
         fan_led.name        = "Fan LED";
+        fan_led.value       = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
@@ -214,6 +195,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     {
         led ring_led;
         ring_led.name       = "Ring LED";
+        ring_led.value      = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 
@@ -234,7 +216,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
         {
-            led_ids[leds_count]     = led_values[led_idx];
+            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
             color_buf[leds_count]   = colors[led_idx];
 
             leds_count++;
@@ -247,7 +229,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
         leds_count = 0;
         for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
         {
-            led_ids[leds_count]     = led_values[led_idx + 2];
+            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
             color_buf[leds_count]   = colors[led_idx + 2];
 
             leds_count++;

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -31,7 +31,7 @@ AOCKeyboardController::~AOCKeyboardController()
 
 std::string AOCKeyboardController::GetDeviceLocation()
 {
-    return("HID: " + location);
+    return("HID " + location);
 }
 
 std::string AOCKeyboardController::GetDeviceName()

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

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

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

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

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -27,7 +27,7 @@ AOCMouseController::~AOCMouseController()
 
 std::string AOCMouseController::GetDeviceLocation()
 {
-    return("HID: " + location);
+    return("HID " + location);
 }
 
 std::string AOCMouseController::GetDeviceName()

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -123,8 +123,6 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -27,7 +27,7 @@ AOCMousematController::~AOCMousematController()
 
 std::string AOCMousematController::GetDeviceLocation()
 {
-    return("HID: " + location);
+    return("HID " + location);
 }
 
 std::string AOCMousematController::GetDeviceName()

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -113,8 +113,6 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
     WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }
 
-void PolychromeUSBController::SetZoneSize(int zone, int new_size)
+void PolychromeUSBController::DeviceResizeZone(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -135,7 +135,7 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        SetZoneSize(int zone, int new_size);
+    void                                        DeviceResizeZone(int zone, int new_size);
     void                                        SetRGSwap(bool reset);
 
 protected:

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -185,25 +185,8 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     SetupZones();
 }
 
-RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_PolychromeUSB::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
@@ -214,64 +197,37 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
-
-            if(first_run)
-            {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = device_info.num_leds;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
 
+
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
             new_led.name = zones[channel_idx].name;
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_ch_idx + 1));
+            new_led.value = channel_idx;
 
             leds.push_back(new_led);
-            led_values.push_back(channel_idx);
         }
     }
 
@@ -296,7 +252,7 @@ void RGBController_PolychromeUSB::SetupZones()
      \*---------------------------------------------------------*/
      for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
      {
-         unsigned char led = (unsigned char)led_values[led_idx];
+         unsigned char led = (unsigned char)leds[led_idx].value;
 
          colors[led_idx] = zones_info[led].color;
      }
@@ -315,14 +271,10 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_PolychromeUSB::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
-    {
-        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
-
-        SetupZones();
-    }
+    zones[zone].leds_count = (unsigned char) new_size;
+    controller->DeviceResizeZone(zones_info[zone].zone, new_size);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -359,7 +311,7 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
 {
-    unsigned int  channel  = led_values[led];
+    unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;
 
     if(set_mode > modes.size())

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -19,11 +19,10 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
     RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
-    ~RGBController_PolychromeUSB();
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
@@ -33,7 +32,6 @@ public:
 
 private:
     PolychromeUSBController*        controller;
-    std::vector<unsigned int>       led_values;
     std::vector<PolychromeZoneInfo> zones_info;
 
     unsigned char GetDeviceMode(unsigned char zone);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.cpp

@@ -36,7 +36,7 @@ ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()
 
 std::string ASRockASRRGBSMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -113,8 +113,6 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB
 
 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -158,14 +156,16 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     \*---------------------------------------------------------*/
     leds.push_back(*new_led);
 
-    /*---------------------------------------------------------*\
-    | Initialize led_values vector                              |
-    \*---------------------------------------------------------*/
-    led_values.push_back(0);
-
     SetupColors();
 }
 
+void RGBController_ASRockASRRGBSMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)
@@ -189,9 +189,9 @@ void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(led_values[led] != 0)
+    if(leds[led].value != 0)
     {
-        led = led_values[led];
+        led = leds[led].value;
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -22,6 +22,8 @@ public:
 
     void        SetupZones();
 
+    void        DeviceResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);
@@ -30,5 +32,4 @@ public:
 
 private:
     ASRockASRRGBSMBusController* controller;
-    std::vector<unsigned int>    led_values;
 };

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -36,7 +36,7 @@ ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()
 
 std::string ASRockPolychromeV1SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -230,8 +230,6 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -285,22 +283,23 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
             led*    new_led         = new led();
 
             new_led->name           = polychrome_v1_zone_names[zone_idx];
+            new_led->value          = zone_idx;
 
             /*---------------------------------------------------------*\
             | Push new LED to LEDs vector                               |
             \*---------------------------------------------------------*/
             leds.push_back(*new_led);
             zoneIndexMap.push_back(zone_idx);
-            led_values.push_back(zone_idx);
         }
     }
 
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
+void RGBController_ASRockPolychromeV1SMBus::DeviceResizeZone(int zone, int new_size)
 {
-    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
+    LOG_TRACE("[%s] DeviceResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    controller-> SetARGBSize(new_size & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
@@ -32,9 +32,7 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV1SMBusController*  controller;
-    std::vector<unsigned int>           led_values;
-    std::vector<uint8_t>                zoneIndexMap;
-
-    uint8_t                             getModeIndex(uint8_t mode_value);
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
 };

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -37,7 +37,7 @@ ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()
 
 std::string ASRockPolychromeV2SMBusController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -185,8 +185,6 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR
 
 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -256,14 +254,11 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_led->name           = polychrome_v2_zone_names[zone_idx];
 
                 new_led->name.append(" " + std::to_string(led_idx + 1));
+                new_led->value = 0;
 
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
-                    led_values.push_back(0x19);
-                }
-                else
-                {
-                    led_values.push_back(0);
+                    new_led->value              = 0x19;
                 }
 
                 /*---------------------------------------------------------*\
@@ -284,7 +279,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -314,9 +309,9 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
     | If the LED value is non-zero, this LED overrides the LED  |
     | index                                                     |
     \*---------------------------------------------------------*/
-    if(led_values[led] != 0)
+    if(leds[led].value != 0)
     {
-        led = led_values[led];
+        led = leds[led].value;
     }
 
     controller->SetColorsAndSpeed(led, red, grn, blu);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
@@ -32,6 +32,5 @@ public:
     void        DeviceUpdateMode();
 
 private:
-    ASRockPolychromeV2SMBusController*  controller;
-    std::vector<unsigned int>           led_values;
+    ASRockPolychromeV2SMBusController* controller;
 };

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -85,31 +85,31 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                 // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
                 {
                     LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
 
                     u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
 
                     switch(version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
                                 LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -119,7 +119,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V1:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -129,7 +129,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V2:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -125,13 +125,6 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     controller->UpdateDim();
 }
 
-RGBController_Alienware::~RGBController_Alienware()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_Alienware::SetupZones()
 {
     /*-------------------------------------------------*\

Controllers/AlienwareController/RGBController_Alienware.h

@@ -19,7 +19,6 @@ class RGBController_Alienware : public RGBController
 {
 public:
     RGBController_Alienware(AlienwareController* controller_ptr);
-    ~RGBController_Alienware();
 
     void        SetupZones();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -278,8 +278,6 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 
 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -313,7 +311,7 @@ void RGBController_AlienwareAW410K::SetupZones()
     {
         led new_led;
         new_led.name  = led_names[led_idx].name;
-        led_values.push_back(led_names[led_idx].idx);
+        new_led.value = led_names[led_idx].idx;
         leds.push_back(new_led);
     }
 
@@ -329,14 +327,14 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
 
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        SelectedButtons key;
+            SelectedButtons key;
 
-        key.idx     = led_values[led_idx];
-        key.red     = RGBGetRValue(colors[led_idx]);
-        key.green   = RGBGetGValue(colors[led_idx]);
-        key.blue    = RGBGetBValue(colors[led_idx]);
+            key.idx     = (unsigned char)leds[led_idx].value;
+            key.red     = RGBGetRValue(colors[led_idx]);
+            key.green   = RGBGetGValue(colors[led_idx]);
+            key.blue    = RGBGetBValue(colors[led_idx]);
 
-        frame_buf_keys.push_back(key);
+            frame_buf_keys.push_back(key);
     }
 
     controller->SendInitialize();
@@ -358,7 +356,7 @@ void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
 
 void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW410K::DeviceUpdateMode()

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

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

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

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

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

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

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

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

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -55,8 +55,6 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
 
 RGBController_Arctic::~RGBController_Arctic()
 {
-    Shutdown();
-
     keepalive_thread_run = false;
     keepalive_thread.join();
     delete controller;
@@ -75,6 +73,7 @@ void RGBController_Arctic::SetupZones()
 
         led Led;
         Led.name    = LedZone.name + " LED";
+        Led.value   = channel;
 
         zones.push_back(LedZone);
         leds.push_back(Led);

Controllers/AresonController/RGBController_Areson.cpp

@@ -125,8 +125,6 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
 
 RGBController_Areson::~RGBController_Areson()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -45,13 +45,6 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
     SetupZones();
 }
 
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupKeyboard()
 {
     name                    = "ASUS Aura Keyboard";
@@ -177,6 +170,11 @@ void RGBController_AuraCore::SetupGA15DH()
     modes.push_back(Static);
 }
 
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    delete controller;
+}
+
 void RGBController_AuraCore::SetupZones()
 {
     zone auraZone;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

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

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

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

Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp

@@ -32,7 +32,7 @@ std::string AuraGPUController::GetDeviceName()
 
 std::string AuraGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -79,7 +79,7 @@ void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char va
 
 bool AuraGPUController::SaveOnlyApplies()
 {
-    switch (bus->info.pci_subsystem_device)
+    switch (bus->pci_subsystem_device)
     {
         case ASUS_VEGA64_STRIX:
             return false;

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -21,7 +21,7 @@
 
 bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
-    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
         return false;
     }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -124,8 +124,6 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
 
 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -112,8 +112,6 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

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

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h

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

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -45,8 +45,6 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 
 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h

@@ -22,7 +22,6 @@
 #define AURA_ROG_GLADIUS_II_WIRELESS_1_PID              0x189E
 #define AURA_ROG_GLADIUS_II_WIRELESS_2_PID              0x18A0
 #define AURA_ROG_GLADIUS_III_PID                        0x197B
-#define AURA_ROG_GLADIUS_III_CORE_PID                   0x1C8D
 #define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID           0x197D
 #define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID           0x197F
 #define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID            0x1981
@@ -218,20 +217,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
             { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
         }
     },
-    {
-        AURA_ROG_GLADIUS_III_CORE_PID, // ROG Gladius III Core
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            false,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
     {
         AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
         {

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

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

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h

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

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -116,8 +116,6 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 
 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -141,6 +139,7 @@ void RGBController_AsusROGSpatha::SetupZones()
         led spatha_led;
 
         spatha_led.name          = zones_names[i];
+        spatha_led.value         = 1;
 
         leds.push_back(spatha_led);
     }

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -79,8 +79,6 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 
 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -99,6 +97,7 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     led mouse_led;
 
     mouse_led.name          = "Underglow";
+    mouse_led.value         = 1;
 
     leds.push_back(mouse_led);
 

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -182,8 +182,6 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 
 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

@@ -19,10 +19,7 @@ AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, con
     |    Manually adding device info for now                |
     |    TODO: Implement config table accurately            |
     \*-----------------------------------------------------*/
-    uint8_t leds = (dev_name.find("Ryujin") != std::string::npos) ? 5 : 12;
-
-    device_info.push_back({0x00, 0x00, leds, 0, AuraDeviceType::FIXED});
-
+    device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
 }
 
 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -128,8 +128,6 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
 
 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -163,6 +161,7 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
 
             new_led.name = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -410,8 +410,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
 RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -520,7 +518,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     {
         led new_led;
         new_led.name  = keyboard[layout].led_names[led_id].name;
-        led_values.push_back(keyboard[layout].led_names[led_id].id);
+        new_led.value = keyboard[layout].led_names[led_id].id;
         leds.push_back(new_led);
     }
 
@@ -538,7 +536,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 
     for(size_t i = 0; i < colors.size(); i++)
     {
-        led_color_list.push_back({ led_values[i], colors[i] });
+        led_color_list.push_back({ leds[i].value, colors[i] });
     }
 
     controller->UpdateLeds(led_color_list);
@@ -560,7 +558,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateSingleLED(int led)
     unsigned char green = RGBGetGValue(colors[led]);
     unsigned char blue  = RGBGetBValue(colors[led]);
 
-    controller->UpdateSingleLed(led_values[led], red, green, blue);
+    controller->UpdateSingleLed(leds[led].value, red, green, blue);
 }
 
 static const uint8_t direction_map[2][6] =

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

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

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -119,8 +119,6 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
 
 RGBController_AuraUSB::~RGBController_AuraUSB()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -147,68 +145,41 @@ void RGBController_AuraUSB::SetupZones()
     | Set zones and leds                                |
     \*-------------------------------------------------*/
     int addressableCounter = 1;
-
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         AuraDeviceInfo device_info  = controller->GetAuraDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type == AuraDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = "Aura Mainboard";
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = "Aura Mainboard";
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = AURA_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].name       = "Aura Addressable ";
+            zones[channel_idx].name.append(std::to_string(addressableCounter));
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
+
+            addressableCounter++;
 
             if(first_run)
             {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+                zones[channel_idx].leds_count = 0;
             }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = "Addressable RGB Header ";
-                zones[channel_idx].name.append(std::to_string(addressableCounter));
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = 0;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
-
-            addressableCounter++;
         }
 
         unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
-
-        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             unsigned led_idx = led_ch_idx + 1;
             led new_led;
 
             new_led.name = zones[channel_idx].name;
-
             if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
             {
                 new_led.name.append(", RGB Header ");
@@ -218,7 +189,6 @@ void RGBController_AuraUSB::SetupZones()
             {
                 new_led.name.append(", LED ");
             }
-
             new_led.name.append(std::to_string(led_idx));
 
             new_led.value = channel_idx;
@@ -230,10 +200,17 @@ void RGBController_AuraUSB::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_AuraUSB::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
         SetupZones();
     }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -24,7 +24,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -120,7 +120,6 @@
 #define AURA_TERMINAL_PID                                   0x1889
 #define ROG_STRIX_LC120_PID                                 0x879E
 #define AURA_RYUO_AIO_PID                                   0x1887
-#define AURA_RYUJIN_AIO_PID                                 0x18AE
 #define ASUS_ROG_ALLY_PID                                   0x1ABE
 #define ASUS_ROG_ALLY_X_PID                                 0x1B4C
 
@@ -464,7 +463,6 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,               1,  0xFF13);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",                        DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,               2,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III",                                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_PID,                         0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Core",                           DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_CORE_PID,                    0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB",                   DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz",                DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID,            0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth",             DetectAsusAuraUSBMice,  AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID,             0,  0xFF01);
@@ -525,7 +523,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ",                             DetectAs
 REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",                     DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                          DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                          0x00FF, 1);
 REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO",                          DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUO_AIO_PID,                        0xFF72, 0x00A1);
-REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryujin AIO",                        DetectAsusAuraUSBRyuoAIO,       AURA_USB_VID, AURA_RYUJIN_AIO_PID,                     0xFF72, 0x00A1);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                            DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                          0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                         DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                       0);
 REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",                  DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,                0);

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -117,8 +117,6 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 
 RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -129,8 +129,6 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
 
 RGBController_AsusROGStrixLC::~RGBController_AsusROGStrixLC()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -164,6 +162,7 @@ void RGBController_AsusROGStrixLC::SetupZones()
 
             new_led.name    = zones[zone_idx].name;
             new_led.name.append(" LED " + std::to_string(lp_idx));
+            new_led.value   = lp_idx;
 
             leds.push_back(new_led);
         }

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.cpp

@@ -283,8 +283,6 @@ RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerbe
 
 RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp

@@ -165,8 +165,6 @@ RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagaris
 
 RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.cpp

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

Controllers/AsusMonitorController/AsusMonitorController.cpp

@@ -89,7 +89,7 @@ void AsusMonitorController::SetDirect(std::vector<RGBColor> colors)
     usb_buf[0x00] = 0xEC;
     usb_buf[0x01] = 0x40;
     usb_buf[0x02] = 0x84;
-    usb_buf[0x04] = (uint8_t)colors.size();
+    usb_buf[0x04] = colors.size();
 
     for(size_t i = 0; i < colors.size(); i++)
     {

Controllers/AsusMonitorController/RGBController_AsusMonitor.cpp

@@ -46,8 +46,6 @@ RGBController_AsusMonitor::RGBController_AsusMonitor(AsusMonitorController* cont
 
 RGBController_AsusMonitor::~RGBController_AsusMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.cpp

@@ -92,13 +92,6 @@ RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptop
     SetupZones();
 }
 
-RGBController_AsusTUFLaptopLinux::~RGBController_AsusTUFLaptopLinux()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_AsusTUFLaptopLinux::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.h

@@ -16,7 +16,6 @@ class RGBController_AsusTUFLaptopLinux : public RGBController
 {
 public:
     RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
-    ~RGBController_AsusTUFLaptopLinux();
 
     void SetupZones();
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Windows.cpp

@@ -85,8 +85,6 @@ RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopCont
 
 RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -44,88 +44,84 @@ RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* control
 
 RGBController_BlinkyTape::~RGBController_BlinkyTape()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_BlinkyTape::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Only set LED count on the first run               |
-    \*-------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
+    zones.clear();
     leds.clear();
-    colors.clear();
-    zones.resize(1);
 
-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
-    zones[0].leds_min                   = 0;
-    zones[0].leds_max                   = 512;
+    zone led_zone;
+    led_zone.name       = "LED Strip";
+    led_zone.type       = ZONE_TYPE_LINEAR;
+    led_zone.leds_min   = 0;
+    led_zone.leds_max   = 512;
+    led_zone.leds_count = 0;
+    zones.push_back(led_zone);
 
-    if(first_run)
-    {
-        zones[0].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-    {
-        zones[0].name                   = "Addressable RGB Header";
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-    {
-        zones[0].leds_count             = 0;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-    {
-        zones[0].type                   = ZONE_TYPE_LINEAR;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-    {
-        zones[0].matrix_map.width       = 0;
-        zones[0].matrix_map.height      = 0;
-        zones[0].matrix_map.map.resize(0);
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
-    for(size_t led_idx = leds.size(); led_idx < zones[0].leds_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = zones[0].name + ", LED ";
-        new_led.name.append(std::to_string(led_idx));
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
+    DeviceResizeZone(0, led_zone.leds_count);
 }
 
-void RGBController_BlinkyTape::DeviceConfigureZone(int zone_idx)
+void RGBController_BlinkyTape::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    /*-------------------------------------------------*\
+    | Explicitly cast these to avoid compiler warnings  |
+    \*-------------------------------------------------*/
+    const unsigned int zone_u       = static_cast<unsigned int>(zone);
+    const unsigned int new_size_u   = static_cast<unsigned int>(new_size);
+
+    /*-------------------------------------------------*\
+    | Check that the zone is in bounds                  |
+    \*-------------------------------------------------*/
+    if((zone_u > zones.size()) || (zone < 0))
     {
-        SetupZones();
+        return;
     }
+
+    /*-------------------------------------------------*\
+    | And that the new size is in bounds                |
+    \*-------------------------------------------------*/
+    if((new_size_u > zones.at(zone).leds_max) || (new_size_u < zones.at(zone).leds_min))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that there's actually a change                |
+    \*-------------------------------------------------*/
+    if(zones.at(zone).leds_count == new_size_u)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | If the new size is less than the current size,    |
+    | just chop off the end                             |
+    \*-------------------------------------------------*/
+    if(leds.size() > new_size_u)
+    {
+        leds.resize(new_size);
+    }
+
+    /*-------------------------------------------------*\
+    | Otherwise, add new LEDs to the end                |
+    \*-------------------------------------------------*/
+    if(leds.size() < new_size_u)
+    {
+        for(size_t led_idx = leds.size(); led_idx < new_size_u; led_idx++)
+        {
+            led new_led;
+            new_led.name = "LED ";
+            new_led.name.append(std::to_string(led_idx));
+
+            leds.push_back(new_led);
+        }
+    }
+
+    zones.at(zone).leds_count = new_size;
+
+    SetupColors();
 }
 
 void RGBController_BlinkyTape::DeviceUpdateLEDs()

Controllers/BlinkyTapeController/RGBController_BlinkyTape.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -312,8 +312,6 @@ RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardControl
 
 RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -10,9 +10,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <cstring>
 #include "ClevoKeyboardController.h"
-#include "StringUtils.h"
+#include <cstring>
 
 ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -41,7 +40,10 @@ std::string ClevoKeyboardController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string ClevoKeyboardController::GetFirmwareVersion()

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoKeyboardController.h"
 #include "DetectionManager.h"
+#include "ClevoKeyboardController.h"
 #include "RGBController_ClevoKeyboard.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -26,7 +26,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_KEYBOARD_PID_600B                 0x600B
 
-DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -199,8 +199,6 @@ RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController
 
 RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -241,9 +239,9 @@ void RGBController_ClevoKeyboard::SetupZones()
         led new_led;
 
         new_led.name    = new_kb.GetKeyNameAt(led_idx);
+        new_led.value   = new_kb.GetKeyValueAt(led_idx);
 
         leds.push_back(new_led);
-        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
     }
 
     SetupColors();
@@ -258,7 +256,7 @@ void RGBController_ClevoKeyboard::SetupZones()
 
     for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-        buffer_map[led_values[led_idx]] = &colors[led_idx];
+        buffer_map[leds[led_idx].value] = &colors[led_idx];
     }
 }
 

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.h

@@ -32,6 +32,5 @@ public:
 private:
     ClevoKeyboardController*        controller;
     std::vector<RGBColor*>          buffer_map;
-    std::vector<unsigned int>       led_values;
     RGBColor                        null_color;
 };

Controllers/ClevoLightbarController/ClevoLightbarController.cpp

@@ -10,9 +10,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <cstring>
 #include "ClevoLightbarController.h"
-#include "StringUtils.h"
+#include <cstring>
 
 ClevoLightbarController::ClevoLightbarController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -41,7 +40,10 @@ std::string ClevoLightbarController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string ClevoLightbarController::GetFirmwareVersion()

Controllers/ClevoLightbarController/ClevoLightbarControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoLightbarController.h"
 #include "DetectionManager.h"
+#include "ClevoLightbarController.h"
 #include "RGBController_ClevoLightbar.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -25,7 +25,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_LIGHTBAR_PID                      0x7001
 
-DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoLightbarController/RGBController_ClevoLightbar.cpp

@@ -121,8 +121,6 @@ RGBController_ClevoLightbar::RGBController_ClevoLightbar(ClevoLightbarController
 
 RGBController_ClevoLightbar::~RGBController_ClevoLightbar()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ColorfulGPUController/ColorfulGPUController.cpp

@@ -26,7 +26,7 @@ ColorfulGPUController::~ColorfulGPUController()
 
 std::string ColorfulGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");
@@ -45,7 +45,7 @@ void ColorfulGPUController::SetDirect(RGBColor color)
     uint8_t g = RGBGetGValue(color);
     uint8_t b = RGBGetBValue(color);
 
-    if(this->bus->info.pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
+    if(this->bus->pci_subsystem_device == COLORFUL_IGAME_RTX_4070_VULCAN_OCV)
     {
         uint8_t data_pkt[COLORFUL_PACKET_LENGTH_V2] = { 0xAA, 0xEF, 0x01, 0x04, 0x88, 0x26 };
         for(int i=6; i < COLORFUL_PACKET_LENGTH_V2 -2; i = i + 3)

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -1,4 +1,4 @@
-/*---------------------------------------------------------*\
+/*---------------------------------------------------------*\
 | ColorfulGPUControllerDetect.cpp                           |
 |                                                           |
 |   Detector for Colorful GPU                               |
@@ -52,7 +52,7 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V",    Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_GA106_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V",     DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV,      COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,          0x61);
+REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V",    DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2,        0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3070_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V",       DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV,    COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_3060TI_ADVANCED_OC,          0x61);
@@ -76,8 +76,3 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ultra W OC",             DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060_ULTRAW_OC,              0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,        0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC_2,      0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

@@ -44,8 +44,6 @@ RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * col
 
 RGBController_ColorfulGPU::~RGBController_ColorfulGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUController.cpp

@@ -24,7 +24,7 @@ ColorfulTuringGPUController::~ColorfulTuringGPUController()
 
 std::string ColorfulTuringGPUController::GetDeviceLocation()
 {
-    std::string return_string(bus->info.device_name);
+    std::string return_string(bus->device_name);
     char addr[5];
     snprintf(addr, 5, "0x%02X", dev);
     return_string.append(", address ");

Controllers/ColorfulTuringGPUController/ColorfulTuringGPUControllerDetect.cpp

@@ -17,7 +17,7 @@ DetectedControllers DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus,
 {
     DetectedControllers detected_controllers;
 
-    if(bus->info.port_id == 1)
+    if(bus->port_id == 1)
     {
         ColorfulTuringGPUController*     controller     = new ColorfulTuringGPUController(bus, i2c_addr, name);
         RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.cpp

@@ -75,8 +75,6 @@ RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringG
 
 RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMARGBController/CMARGBController.cpp

@@ -12,27 +12,16 @@
 #include "CMARGBController.h"
 #include "StringUtils.h"
 
-/*---------------------------------------------------------*\
-| Map to convert port index to port ID used in protocol     |
-\*---------------------------------------------------------*/
-static unsigned char cm_argb_port_index_to_id[5] =
+CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex)
 {
-    CM_ARGB_PORT_ARGB_1,
-    CM_ARGB_PORT_ARGB_2,
-    CM_ARGB_PORT_ARGB_3,
-    CM_ARGB_PORT_ARGB_4,
-    CM_ARGB_PORT_RGB
-};
+    dev                     = dev_handle;
+    location                = _path;
+    zone_index              = _zone_idx;
+    mutex_ptr               = cm_mutex;
 
-CMARGBController::CMARGBController(hid_device* dev_handle, char *path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    /*-----------------------------------------------------*\
-    | Get device name from HID manufacturer and product     |
-    | strings                                               |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Get device name from HID manufacturer and product strings |
+    \*---------------------------------------------------------*/
     wchar_t name_string[HID_MAX_STR];
 
     hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
@@ -40,11 +29,57 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *path)
 
     hid_get_product_string(dev, name_string, HID_MAX_STR);
     device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
+
+    GetStatus();
 }
 
 CMARGBController::~CMARGBController()
 {
-    hid_close(dev);
+    if(mutex_ptr.use_count() <= 1)
+    {
+        hid_close(dev);
+    }
+}
+
+void CMARGBController::GetStatus()
+{
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0B, 0x01 };
+    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
+    int rgb_offset                              = 0;
+    int zone;
+
+    if (argb_header_data[zone_index].digital)
+    {
+        zone                                    = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
+    }
+    else
+    {
+        zone                                    = 0x00;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
+        rgb_offset                              = 1;
+    }
+
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    /*---------------------------------------------------------*\
+    | If this is the group then just return the first status    |
+    \*---------------------------------------------------------*/
+    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+    current_mode                                = buffer[4 - rgb_offset];
+    bool_random                                 = ( buffer[5 - rgb_offset] == 0x00 );
+    current_speed                               = buffer[6 - rgb_offset];
+    current_brightness                          = buffer[7 - rgb_offset];
+    current_red                                 = buffer[8 - rgb_offset];
+    current_green                               = buffer[9 - rgb_offset];
+    current_blue                                = buffer[10 - rgb_offset];
 }
 
 std::string CMARGBController::GetDeviceName()
@@ -52,33 +87,6 @@ std::string CMARGBController::GetDeviceName()
     return(device_name);
 }
 
-std::string CMARGBController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CMARGBController::GetVersion()
-{
-    /*-----------------------------------------------------*\
-    | This device uses the serial value to determine the    |
-    | version.  It does not report a proper unique serial.  |
-    \*-----------------------------------------------------*/
-    std::string serial_string = GetSerial();
-
-    if(serial_string == CM_ARGB_FW0023)
-    {
-        return("0023");
-    }
-    else if(serial_string == CM_ARGB_FW0028)
-    {
-        return("0028");
-    }
-    else
-    {
-        return("Unsupported");
-    }
-}
-
 std::string CMARGBController::GetSerial()
 {
     wchar_t serial_string[HID_MAX_STR];
@@ -92,187 +100,118 @@ std::string CMARGBController::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-void CMARGBController::GetPortStatus
-    (
-    unsigned char   port_idx,
-    unsigned char*  port_mode,
-    unsigned char*  port_speed,
-    unsigned char*  port_brightness,
-    bool*           port_random,
-    unsigned char*  port_red,
-    unsigned char*  port_green,
-    unsigned char*  port_blue
-    )
+std::string CMARGBController::GetLocation()
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0B, 0x01};
-    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
-    int rgb_offset                              = 0;
-    int zone;
-
-    /*-----------------------------------------------------*\
-    | RGB port is handled differently from ARGB ports       |
-    \*-----------------------------------------------------*/
-    if(cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB)
-    {
-        zone                                    = cm_argb_port_index_to_id[port_idx];
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
-    }
-    else
-    {
-        zone                                    = 0x00;
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
-        rgb_offset                              = 1;
-    }
-
-    /*-----------------------------------------------------*\
-    | If this is the group then just return the first       |
-    | status                                                |
-    \*-----------------------------------------------------*/
-    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
-
-    /*-----------------------------------------------------*\
-    | Send the command and read the response                |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-    /*-----------------------------------------------------*\
-    | Read data out of response                             |
-    \*-----------------------------------------------------*/
-    *port_mode                                  = buffer[4 - rgb_offset];
-    *port_random                                = (buffer[5 - rgb_offset] == 0x00);
-    *port_speed                                 = buffer[6 - rgb_offset];
-    *port_brightness                            = buffer[7 - rgb_offset];
-    *port_red                                   = buffer[8 - rgb_offset];
-    *port_green                                 = buffer[9 - rgb_offset];
-    *port_blue                                  = buffer[10 - rgb_offset];
+    return("HID: " + location);
 }
 
-void CMARGBController::SetPortLEDCount(unsigned char port_idx, unsigned char led_count)
+unsigned char CMARGBController::GetZoneIndex()
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0D, 0x02};
+    return(zone_index);
+}
+
+unsigned char CMARGBController::GetMode()
+{
+    return(current_mode);
+}
+
+unsigned char CMARGBController::GetLedRed()
+{
+    return(current_red);
+}
+
+unsigned char CMARGBController::GetLedGreen()
+{
+    return(current_green);
+}
+
+unsigned char CMARGBController::GetLedBlue()
+{
+    return(current_blue);
+}
+
+unsigned char CMARGBController::GetLedSpeed()
+{
+    return(current_speed);
+}
+
+bool CMARGBController::GetRandomColours()
+{
+    return(bool_random);
+}
+
+void CMARGBController::SetLedCount(int zone, int led_count)
+{
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
     int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
 
-    buffer[CM_ARGB_ZONE_BYTE]                   = cm_argb_port_index_to_id[port_idx];
+    buffer[CM_ARGB_ZONE_BYTE]                   = zone;
     buffer[CM_ARGB_MODE_BYTE]                   = led_count;
-    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = 1;
+    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
+
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
 
-    /*-----------------------------------------------------*\
-    | Send the command                                      |
-    \*-----------------------------------------------------*/
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetPortMode
-    (
-    unsigned char   port_idx,
-    unsigned char   port_mode,
-    unsigned char   port_speed,
-    unsigned char   port_brightness,
-    bool            port_random,
-    unsigned char   port_red,
-    unsigned char   port_green,
-    unsigned char   port_blue
-    )
+void CMARGBController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours)
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00};
-    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
-    bool boolARGB_header                        = (cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB);
-    bool boolPassthru                           = (port_mode == CM_ARGB_MODE_PASSTHRU) || (port_mode == CM_RGB_MODE_PASSTHRU);
-    bool boolDirect                             = (port_mode == CM_ARGB_MODE_DIRECT);
-    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
-    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
+    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == brightness) && (ToRGBColor(current_red, current_green, current_blue) == colour));
 
-    if(boolDirect)
+    if (needs_update)
     {
-        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
-        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+        current_mode        = mode;
+        current_speed       = speed;
+        current_brightness  = brightness;
+        current_red         = RGBGetRValue(colour);
+        current_green       = RGBGetGValue(colour);
+        current_blue        = RGBGetBValue(colour);
+        bool_random         = random_colours;
 
-        /*-------------------------------------------------*\
-        | Send the command                                  |
-        \*-------------------------------------------------*/
-        hid_write(dev, buffer, buffer_size);
-
-        /*-------------------------------------------------*\
-        | Direct mode is now set up and no other mode       |
-        | packet is required                                |
-        \*-------------------------------------------------*/
-        return;
+        SendUpdate();
     }
-
-    buffer[CM_ARGB_FUNCTION_BYTE]               = function;
-
-    /*-----------------------------------------------------*\
-    | Send the command                                      |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
-
-    /*-----------------------------------------------------*\
-    | ARGB ports send command 0x0B, RGB port sends 0x04     |
-    \*-----------------------------------------------------*/
-    if(boolARGB_header)
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = 0x0B;
-        buffer[CM_ARGB_FUNCTION_BYTE]                       = (false) ? 0x01 : 0x02;
-        buffer[CM_ARGB_ZONE_BYTE]                           = cm_argb_port_index_to_id[port_idx];
-        buffer[CM_ARGB_MODE_BYTE]                           = port_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE]                   = port_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE]                          = port_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE]                     = port_brightness;
-        buffer[CM_ARGB_RED_BYTE]                            = port_red;
-        buffer[CM_ARGB_GREEN_BYTE]                          = port_green;
-        buffer[CM_ARGB_BLUE_BYTE]                           = port_blue;
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;
-        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = port_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = port_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = port_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = port_brightness;
-        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = port_red;
-        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = port_green;
-        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = port_blue;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send the command and wait for response                |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count)
+void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
 {
     const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
     unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x07, 0x02 };
     unsigned char packet_count          = 0;
     std::vector<uint8_t> colours;
 
-    /*-----------------------------------------------------*\
-    | Set up the RGB triplets to send                       |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------*\
+    | Set up the RGB triplets to send               |
+    \*---------------------------------------------*/
     for(unsigned int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
 
-        colours.push_back(RGBGetRValue(colour));
-        colours.push_back(RGBGetGValue(colour));
-        colours.push_back(RGBGetBValue(colour));
+        colours.push_back( RGBGetRValue(colour) );
+        colours.push_back( RGBGetGValue(colour) );
+        colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_ARGB_FUNCTION_BYTE]       = port_idx;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = zone_index - 1;
     buffer[CM_ARGB_ZONE_BYTE]           = led_count;
     unsigned char buffer_idx            = CM_ARGB_MODE_BYTE;
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_ARGB_COMMAND_BYTE)
     {
-        /*-------------------------------------------------*\
-        | Fill the write buffer till its full or the        |
-        | colour buffer is empty                            |
-        \*-------------------------------------------------*/
+        /*-----------------------------------------------------------------*\
+        | Fill the write buffer till its full or the colour buffer is empty |
+        \*-----------------------------------------------------------------*/
         buffer[CM_ARGB_REPORT_BYTE] = packet_count;
-        while((buffer_idx < buffer_size) && (it != colours.end()))
+        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
         {
             buffer[buffer_idx] = *it;
             buffer_idx++;
@@ -284,15 +223,76 @@ void CMARGBController::SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_c
             buffer[CM_ARGB_REPORT_BYTE] += 0x80;
         }
 
-        /*-------------------------------------------------*\
-        | Send the buffer                                   |
-        \*-------------------------------------------------*/
         hid_write(dev, buffer, buffer_size);
 
-        /*-------------------------------------------------*\
-        | Reset the write buffer                            |
-        \*-------------------------------------------------*/
+        /*-----------------------------------------------------------------*\
+        | Reset the write buffer                                            |
+        \*-----------------------------------------------------------------*/
         memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
 }
+
+void CMARGBController::SendUpdate()
+{
+    /*---------------------------------------------*\
+    | Guard the writes to the controller            |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
+    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
+    bool boolARGB_header                        = argb_header_data[zone_index].digital;
+    bool boolPassthru                           = ( current_mode == CM_ARGB_MODE_PASSTHRU ) || ( current_mode == CM_RGB_MODE_PASSTHRU );
+    bool boolDirect                             = ( current_mode == CM_ARGB_MODE_DIRECT );
+    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
+    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
+    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
+
+    if(boolDirect)
+    {
+        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
+        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+        /*-----------------------------------------------------------------*\
+        | Direct mode is now set up and no other mode packet is required    |
+        \*-----------------------------------------------------------------*/
+        return;
+    }
+
+    buffer[CM_ARGB_FUNCTION_BYTE]           = function;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+    if(boolARGB_header)
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;                                     //ARGB sends 0x0B (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
+        buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_MODE_BYTE]               = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE]       = bool_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE]              = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE]         = current_brightness;
+        buffer[CM_ARGB_RED_BYTE]                = current_red;
+        buffer[CM_ARGB_GREEN_BYTE]              = current_green;
+        buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
+    }
+    else
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;   //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = bool_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = current_brightness;
+        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
+        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
+        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
+    }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMARGBController/CMARGBController.h

@@ -16,20 +16,19 @@
 #include <array>
 #include <memory>
 #include <hidapi.h>
-#include "RGBController.h"
+#include "RGBController.h"  //Needed to set the direct mode
 
-#define CM_ARGB_COLOUR_MODE_DATA_SIZE   (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
-#define CM_ARGB_HEADER_DATA_SIZE        (sizeof(argb_header_data) / sizeof(argb_headers) )
-#define CM_ARGB_INTERRUPT_TIMEOUT       250
-#define CM_ARGB_PACKET_SIZE             65
-#define CM_ARGB_DEVICE_NAME_SIZE        (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define CM_RGB_OFFSET                   -2
-#define HID_MAX_STR                     255
+#define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_ARGB_INTERRUPT_TIMEOUT 250
+#define CM_ARGB_PACKET_SIZE 65
+#define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define CM_RGB_OFFSET -2
+#define HID_MAX_STR 255
 
-#define CM_ARGB_BRIGHTNESS_MAX          255
-#define CM_ARGB_FW0000                  std::string("A201804091608")
-#define CM_ARGB_FW0023                  std::string("A202011171238")
-#define CM_ARGB_FW0028                  std::string("A202105291658")
+#define CM_ARGB_BRIGHTNESS_MAX  255
+#define CM_ARGB_FW0023          std::string("A202011171238")
+#define CM_ARGB_FW0028          std::string("A202105291658")
 
 enum
 {
@@ -46,13 +45,22 @@ enum
     CM_ARGB_BLUE_BYTE           = 11
 };
 
-enum
+struct argb_headers
 {
-    CM_ARGB_PORT_ARGB_1         = 0x01,
-    CM_ARGB_PORT_ARGB_2         = 0x02,
-    CM_ARGB_PORT_ARGB_3         = 0x04,
-    CM_ARGB_PORT_ARGB_4         = 0x08,
-    CM_ARGB_PORT_RGB            = 0xFE,
+    const char*     name;
+    unsigned char   header;
+    bool            digital;
+    unsigned int    count;
+};
+
+static argb_headers argb_header_data[] =
+{
+    { "RGB Header",         0xFE, false,  1 },
+    { "Digital ARGB1",      0x01, true,  12 },
+    { "Digital ARGB2",      0x02, true,  12 },
+    { "Digital ARGB3",      0x04, true,  12 },
+    { "Digital ARGB4",      0x08, true,  12 },
+    //{ "All Digital ARGB",   0xFF, true,  12 }
 };
 
 enum
@@ -93,44 +101,40 @@ enum
 class CMARGBController
 {
 public:
-    CMARGBController(hid_device* dev_handle, char* path);
+    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex);
     ~CMARGBController();
 
     std::string GetDeviceName();
     std::string GetSerial();
     std::string GetLocation();
-    std::string GetVersion();
 
-    void GetPortStatus
-        (
-        unsigned char   port_idx,
-        unsigned char*  port_mode,
-        unsigned char*  port_speed,
-        unsigned char*  port_brightness,
-        bool*           port_random,
-        unsigned char*  port_red,
-        unsigned char*  port_green,
-        unsigned char*  port_blue
-        );
-
-    void SetPortLEDCount(unsigned char port_idx, unsigned char led_count);
-
-    void SetPortMode
-        (
-        unsigned char   port_idx,
-        unsigned char   port_mode,
-        unsigned char   port_speed,
-        unsigned char   port_brightness,
-        bool            port_random,
-        unsigned char   port_red,
-        unsigned char   port_green,
-        unsigned char   port_blue
-        );
-
-    void SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count);
+    unsigned char GetZoneIndex();
+    unsigned char GetMode();
+    unsigned char GetLedRed();
+    unsigned char GetLedGreen();
+    unsigned char GetLedBlue();
+    unsigned char GetLedSpeed();
+    bool GetRandomColours();
+    void SetLedCount(int zone, int led_count);
+    void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours);
+    void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 
 private:
-    hid_device*         dev;
-    std::string         device_name;
-    std::string         location;
+    std::string                 device_name;
+    std::string                 location;
+    hid_device*                 dev;
+    std::shared_ptr<std::mutex> mutex_ptr;
+
+    unsigned char               zone_index;
+    unsigned char               current_mode;
+    unsigned char               current_speed;
+
+    unsigned char               current_red;
+    unsigned char               current_green;
+    unsigned char               current_blue;
+    unsigned char               current_brightness;
+    bool                        bool_random;
+
+    void GetStatus();
+    void SendUpdate();
 };

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

@@ -27,594 +27,401 @@
 RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController* controller_ptr)
 {
     controller                      = controller_ptr;
+    unsigned char speed             = controller->GetLedSpeed();
 
-    name                            = controller->GetDeviceName();
+    name                            = argb_header_data[controller->GetZoneIndex()].name;
     vendor                          = "Cooler Master";
     type                            = DEVICE_TYPE_LEDSTRIP;
-    description                     = "Cooler Master ARGB Controller Device";
-    version                         = controller->GetVersion();
+    description                     = controller->GetDeviceName();
+    version                         = "3.0 for FW0028";
     serial                          = controller->GetSerial();
     location                        = controller->GetLocation();
 
-    SetupZones();
-    SetupModes();
-
-    /*-----------------------------------------------------*\
-    | Initialize the active mode to port 0                  |
-    \*-----------------------------------------------------*/
-    unsigned char   port_mode;
-    unsigned char   port_speed;
-    unsigned char   port_brightness;
-    bool            port_random;
-    unsigned char   port_red;
-    unsigned char   port_green;
-    unsigned char   port_blue;
-
-    controller->GetPortStatus(0, &port_mode, &port_speed, &port_brightness, &port_random, &port_red, &port_green, &port_blue);
-
-    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    if(argb_header_data[controller->GetZoneIndex()].digital)
     {
-        if(modes[mode_idx].value == port_mode)
+        mode Off;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_ARGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
+        modes.push_back(Off);
+
+        mode Reload;
+        Reload.name                 = "Reload";
+        Reload.value                = CM_ARGB_MODE_RELOAD;
+        Reload.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Reload.colors_min           = 1;
+        Reload.colors_max           = 1;
+        Reload.colors.resize(Reload.colors_max);
+        Reload.brightness_min       = 0;
+        Reload.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Reload.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Reload.speed                = speed;
+        modes.push_back(Reload);
+
+        mode Recoil;
+        Recoil.name                 = "Recoil";
+        Recoil.value                = CM_ARGB_MODE_RECOIL;
+        Recoil.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Recoil.colors_min           = 1;
+        Recoil.colors_max           = 1;
+        Recoil.colors.resize(Recoil.colors_max);
+        Recoil.brightness_min       = 0;
+        Recoil.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Recoil.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Recoil.speed                = speed;
+        modes.push_back(Recoil);
+
+        mode Breathing;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_ARGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
+        Breathing.colors.resize(Breathing.colors_max);
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = speed;
+        modes.push_back(Breathing);
+
+        mode Refill;
+        Refill.name                 = "Refill";
+        Refill.value                = CM_ARGB_MODE_REFILL;
+        Refill.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Refill.colors_min           = 1;
+        Refill.colors_max           = 1;
+        Refill.colors.resize(Refill.colors_max);
+        Refill.brightness_min       = 0;
+        Refill.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Refill.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Refill.speed                = speed;
+        modes.push_back(Refill);
+
+        mode Demo;
+        Demo.name                   = "Demo";
+        Demo.value                  = CM_ARGB_MODE_DEMO;
+        Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Demo.brightness_min         = 0;
+        Demo.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.speed_min              = CM_ARGB_SPEED_SLOWEST;
+        Demo.speed_max              = CM_ARGB_SPEED_FASTEST;
+        Demo.color_mode             = MODE_COLORS_NONE;
+        Demo.speed                  = speed;
+        modes.push_back(Demo);
+
+        mode Spectrum;
+        Spectrum.name               = "Spectrum";
+        Spectrum.value              = CM_ARGB_MODE_SPECTRUM;
+        Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Spectrum.brightness_min     = 0;
+        Spectrum.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        Spectrum.speed_max          = CM_ARGB_SPEED_FASTEST;
+        Spectrum.color_mode         = MODE_COLORS_NONE;
+        Spectrum.speed              = speed;
+        modes.push_back(Spectrum);
+
+        mode FillFlow;
+        FillFlow.name               = "Fill Flow";
+        FillFlow.value              = CM_ARGB_MODE_FILLFLOW;
+        FillFlow.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        FillFlow.brightness_min     = 0;
+        FillFlow.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        FillFlow.speed_max          = CM_ARGB_SPEED_FASTEST;
+        FillFlow.color_mode         = MODE_COLORS_NONE;
+        FillFlow.speed              = speed;
+        modes.push_back(FillFlow);
+
+        mode Rainbow;
+        Rainbow.name                = "Rainbow";
+        Rainbow.value               = CM_ARGB_MODE_RAINBOW;
+        Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Rainbow.brightness_min      = 0;
+        Rainbow.brightness_max      = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.brightness          = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.speed_min           = CM_ARGB_SPEED_SLOWEST;
+        Rainbow.speed_max           = CM_ARGB_SPEED_FASTEST;
+        Rainbow.color_mode          = MODE_COLORS_NONE;
+        Rainbow.speed               = speed;
+        modes.push_back(Rainbow);
+
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = CM_ARGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Static.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = speed;
+        modes.push_back(Static);
+
+        mode Direct;
+        Direct.name                 = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
+        Direct.value                = CM_ARGB_MODE_DIRECT;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
+
+        mode PassThru;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_ARGB_MODE_PASSTHRU;
+        PassThru.flags              = 0;
+        PassThru.color_mode         = MODE_COLORS_NONE;
+        modes.push_back(PassThru);
+    }
+    else
+    {
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = CM_RGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = 0;
+        modes.push_back(Static);
+
+        mode Breathing;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_RGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
+        Breathing.colors.resize(Breathing.colors_max);
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Breathing);
+
+        mode Flash;
+        Flash.name                  = "Flash";
+        Flash.value                 = CM_RGB_MODE_FLASH;
+        Flash.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Flash.colors_min            = 1;
+        Flash.colors_max            = 1;
+        Flash.colors.resize(Flash.colors_max);
+        Flash.brightness_min        = 0;
+        Flash.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.speed_min             = CM_ARGB_SPEED_SLOWEST;
+        Flash.speed_max             = CM_ARGB_SPEED_FASTEST;
+        Flash.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed                 = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Flash);
+
+        mode Mirage;
+        Mirage.name                 = "Mirage";
+        Mirage.value                = CM_RGB_MODE_MIRAGE;
+        Mirage.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Mirage.colors_min           = 1;
+        Mirage.colors_max           = 1;
+        Mirage.colors.resize(Mirage.colors_max);
+        Mirage.brightness_min       = 0;
+        Mirage.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Mirage.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Mirage.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Mirage.speed                = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Mirage);
+
+        mode PassThru;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_RGB_MODE_PASSTHRU;
+        PassThru.color_mode         = MODE_COLORS_NONE;
+        modes.push_back(PassThru);
+
+        mode Off;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_RGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
+        modes.push_back(Off);
+    }
+
+    Init_Controller();
+    SetupZones();
+
+    int temp_mode   = controller->GetMode();
+    for(int mode_idx = 0; mode_idx < (int)modes.size() ; mode_idx++)
+    {
+        if (temp_mode == modes[mode_idx].value)
         {
-            active_mode = (int)mode_idx;
-
-            if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
-            {
-                modes[mode_idx].colors[0] = ToRGBColor(port_red, port_green, port_blue);
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
-            {
-                modes[mode_idx].speed = port_speed;
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
-            {
-                modes[mode_idx].brightness = port_brightness;
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
-            {
-                if(port_random)
-                {
-                    modes[mode_idx].color_mode = MODE_COLORS_RANDOM;
-                }
-            }
-
+            active_mode = mode_idx;
             break;
         }
     }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
+        modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = controller->GetLedSpeed();
+    }
 }
 
 RGBController_CMARGBController::~RGBController_CMARGBController()
 {
-    Shutdown();
-
     delete controller;
 }
 
-void RGBController_CMARGBController::SetupModes()
+void RGBController_CMARGBController::Init_Controller()
 {
-    /*-----------------------------------------------------*\
-    | Define Direct and Passthrough modes as require entire |
-    | device, these are not available as per-zone modes     |
-    \*-----------------------------------------------------*/
-    mode Direct;
-    Direct.name                     = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
-    Direct.value                    = CM_ARGB_MODE_DIRECT;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
+    int zone_idx            = controller->GetZoneIndex();
+    int zone_led_count      = argb_header_data[zone_idx].count;
 
-    mode PassThru;
-    PassThru.name                   = "Passthrough";
-    PassThru.value                  = CM_ARGB_MODE_PASSTHRU | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
-    PassThru.flags                  = 0;
-    PassThru.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(PassThru);
+    /*-------------------------------------------------*\
+    | If argb_header_data[zone_idx].count == 1 then the |
+    | zone is ZONE_TYPE_SINGLE                          |
+    \*-------------------------------------------------*/
+    bool boolSingleLED      = ( zone_led_count == 1 );
 
-    /*-----------------------------------------------------*\
-    | The ARGB ports support more modes than the RGB port.  |
-    | Define all of the modes the ARGB ports support and    |
-    | map RGB modes to them as best as we can.              |
-    \*-----------------------------------------------------*/
-    mode Off;
-    Off.name                        = "Off";
-    Off.value                       = CM_ARGB_MODE_OFF;
-    Off.color_mode                  = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Off);
-    }
-
-    mode Reload;
-    Reload.name                     = "Reload";
-    Reload.value                    = CM_ARGB_MODE_RELOAD;
-    Reload.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Reload.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Reload.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Reload.speed                    = CM_ARGB_SPEED_NORMAL;
-    Reload.brightness_min           = 0;
-    Reload.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Reload.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Reload.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Reload.colors_min               = 1;
-    Reload.colors_max               = 1;
-    Reload.colors.resize(Reload.colors_max);
-    modes.push_back(Reload);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Reload);
-    }
-
-    mode Recoil;
-    Recoil.name                     = "Recoil";
-    Recoil.value                    = CM_ARGB_MODE_RECOIL;
-    Recoil.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Recoil.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Recoil.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Recoil.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Recoil.speed                    = CM_ARGB_SPEED_NORMAL;
-    Recoil.brightness_min           = 0;
-    Recoil.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Recoil.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Recoil.colors_min               = 1;
-    Recoil.colors_max               = 1;
-    Recoil.colors.resize(Recoil.colors_max);
-    modes.push_back(Recoil);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Recoil);
-    }
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = CM_ARGB_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min             = CM_ARGB_SPEED_SLOWEST;
-    Breathing.speed_max             = CM_ARGB_SPEED_FASTEST;
-    Breathing.speed                 = CM_ARGB_SPEED_NORMAL;
-    Breathing.brightness_min        = 0;
-    Breathing.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    Breathing.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(Breathing.colors_max);
-    modes.push_back(Breathing);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Breathing);
-    }
-
-    mode Refill;
-    Refill.name                     = "Refill";
-    Refill.value                    = CM_ARGB_MODE_REFILL;
-    Refill.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Refill.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Refill.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Refill.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Refill.speed                    = CM_ARGB_SPEED_NORMAL;
-    Refill.brightness_min           = 0;
-    Refill.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Refill.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Refill.colors_min               = 1;
-    Refill.colors_max               = 1;
-    Refill.colors.resize(Refill.colors_max);
-    modes.push_back(Refill);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Refill);
-    }
-
-    mode Demo;
-    Demo.name                       = "Demo";
-    Demo.value                      = CM_ARGB_MODE_DEMO;
-    Demo.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Demo.color_mode                 = MODE_COLORS_NONE;
-    Demo.speed_min                  = CM_ARGB_SPEED_SLOWEST;
-    Demo.speed_max                  = CM_ARGB_SPEED_FASTEST;
-    Demo.speed                      = CM_ARGB_SPEED_NORMAL;
-    Demo.brightness_min             = 0;
-    Demo.brightness_max             = CM_ARGB_BRIGHTNESS_MAX;
-    Demo.brightness                 = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Demo);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Demo);
-    }
-
-    mode Spectrum;
-    Spectrum.name                   = "Rainbow Wave";
-    Spectrum.value                  = CM_ARGB_MODE_SPECTRUM;
-    Spectrum.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Spectrum.color_mode             = MODE_COLORS_NONE;
-    Spectrum.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    Spectrum.speed_max              = CM_ARGB_SPEED_FASTEST;
-    Spectrum.speed                  = CM_ARGB_SPEED_NORMAL;
-    Spectrum.brightness_min         = 0;
-    Spectrum.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    Spectrum.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Spectrum);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Spectrum);
-    }
-
-    mode FillFlow;
-    FillFlow.name                   = "Fill Flow";
-    FillFlow.value                  = CM_ARGB_MODE_FILLFLOW;
-    FillFlow.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    FillFlow.color_mode             = MODE_COLORS_NONE;
-    FillFlow.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    FillFlow.speed_max              = CM_ARGB_SPEED_FASTEST;
-    FillFlow.speed                  = CM_ARGB_SPEED_NORMAL;
-    FillFlow.brightness_min         = 0;
-    FillFlow.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    FillFlow.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(FillFlow);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(FillFlow);
-    }
-
-    mode Rainbow;
-    Rainbow.name                    = "Rainbow";
-    Rainbow.value                   = CM_ARGB_MODE_RAINBOW;
-    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.color_mode              = MODE_COLORS_NONE;
-    Rainbow.speed_min               = CM_ARGB_SPEED_SLOWEST;
-    Rainbow.speed_max               = CM_ARGB_SPEED_FASTEST;
-    Rainbow.speed                   = CM_ARGB_SPEED_NORMAL;
-    Rainbow.brightness_min          = 0;
-    Rainbow.brightness_max          = CM_ARGB_BRIGHTNESS_MAX;
-    Rainbow.brightness              = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Rainbow);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Rainbow);
-    }
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = CM_ARGB_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min           = 0;
-    Static.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Static.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(Static.colors_max);
-    modes.push_back(Static);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Static);
-    }
-
-    /*-----------------------------------------------------*\
-    | Define zone-specific modes for the RGB port           |
-    \*-----------------------------------------------------*/
-    mode RGBOff;
-    RGBOff.name                     = "Off";
-    RGBOff.value                    = CM_RGB_MODE_OFF;
-    RGBOff.color_mode               = MODE_COLORS_NONE;
-    zones[4].modes.push_back(RGBOff);
-
-    mode RGBMirage;
-    RGBMirage.name                  = "Mirage";
-    RGBMirage.value                 = CM_RGB_MODE_MIRAGE;
-    RGBMirage.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBMirage.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RGBMirage.speed_min             = CM_ARGB_SPEED_SLOWEST;
-    RGBMirage.speed_max             = CM_ARGB_SPEED_FASTEST;
-    RGBMirage.speed                 = CM_ARGB_SPEED_NORMAL;
-    RGBMirage.brightness_min        = 0;
-    RGBMirage.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    RGBMirage.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    RGBMirage.colors_min            = 1;
-    RGBMirage.colors_max            = 1;
-    RGBMirage.colors.resize(RGBMirage.colors_max);
-    zones[4].modes.push_back(RGBMirage);
-
-    mode RGBFlash;
-    RGBFlash.name                   = "Flash";
-    RGBFlash.value                  = CM_RGB_MODE_FLASH;
-    RGBFlash.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBFlash.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    RGBFlash.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    RGBFlash.speed_max              = CM_ARGB_SPEED_FASTEST;
-    RGBFlash.speed                  = CM_ARGB_SPEED_NORMAL;
-    RGBFlash.brightness_min         = 0;
-    RGBFlash.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    RGBFlash.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    RGBFlash.colors_min             = 1;
-    RGBFlash.colors_max             = 1;
-    RGBFlash.colors.resize(RGBFlash.colors_max);
-    zones[4].modes.push_back(RGBFlash);
-
-    mode RGBBreathing;
-    RGBBreathing.name               = "Breathing";
-    RGBBreathing.value              = CM_RGB_MODE_BREATHING;
-    RGBBreathing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBBreathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    RGBBreathing.speed_min          = CM_ARGB_SPEED_SLOWEST;
-    RGBBreathing.speed_max          = CM_ARGB_SPEED_FASTEST;
-    RGBBreathing.speed              = CM_ARGB_SPEED_NORMAL;
-    RGBBreathing.brightness_min     = 0;
-    RGBBreathing.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
-    RGBBreathing.brightness         = CM_ARGB_BRIGHTNESS_MAX;
-    RGBBreathing.colors_min         = 1;
-    RGBBreathing.colors_max         = 1;
-    RGBBreathing.colors.resize(RGBBreathing.colors_max);
-    zones[4].modes.push_back(RGBBreathing);
-
-    mode RGBStatic;
-    RGBStatic.name                  = "Static";
-    RGBStatic.value                 = CM_RGB_MODE_STATIC;
-    RGBStatic.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBStatic.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RGBStatic.brightness_min        = 0;
-    RGBStatic.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    RGBStatic.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    RGBStatic.colors_min            = 1;
-    RGBStatic.colors_max            = 1;
-    RGBStatic.colors.resize(RGBStatic.colors_max);
-    zones[4].modes.push_back(RGBStatic);
+    zone ARGB_zone;
+    ARGB_zone.name          = std::to_string(zone_idx);
+    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+    ARGB_zone.leds_min      = 4;
+    ARGB_zone.leds_max      = 48;
+    ARGB_zone.leds_count    = zone_led_count;
+    zones.push_back(ARGB_zone);
 }
 
 void RGBController_CMARGBController::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-----------------------------------------------------*\
-    | Clear any existing color/LED configuration            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
     leds.clear();
     colors.clear();
-    zones.resize(5);
 
-    /*-----------------------------------------------------*\
-    | Set up addressable zones                              |
-    \*-----------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < 4; channel_idx++)
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        zones[channel_idx].leds_min                 = 0;
-        zones[channel_idx].leds_max                 = 48;
+        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);
 
-        if(first_run)
+        if (!boolSingleLED)
         {
-            zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+            controller->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
         }
 
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
         {
-            zones[channel_idx].name                 = "Addressable RGB Header ";
-            zones[channel_idx].name.append(std::to_string(channel_idx + 1));
-        }
+            led     new_led;
+            unsigned int i = std::stoi(zones[zone_idx].name);
 
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[channel_idx].leds_count           = 0;
-        }
-
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[channel_idx].matrix_map.width     = 0;
-            zones[channel_idx].matrix_map.height    = 0;
-            zones[channel_idx].matrix_map.map.resize(0);
-        }
-
-        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
-        {
-            led new_led;
-            new_led.name            = zones[channel_idx].name;
-            new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value           = channel_idx;
+            if(boolSingleLED)
+            {
+                new_led.name  = i;
+                new_led.value = argb_header_data[i].header;
+            }
+            else
+            {
+                new_led.name = i;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+                new_led.value = argb_header_data[i].header;
+            }
 
             leds.push_back(new_led);
         }
     }
 
-    /*-----------------------------------------------------*\
-    | Set up RGB zone                                       |
-    \*-----------------------------------------------------*/
-    zones[4].name                   = "RGB Header";
-    zones[4].type                   = ZONE_TYPE_SINGLE;
-    zones[4].leds_min               = 1;
-    zones[4].leds_max               = 1;
-    zones[4].leds_count             = 1;
-
-    led new_led;
-    new_led.name                    = "RGB Header";
-    new_led.value                   = 4;
-    leds.push_back(new_led);
-
     SetupColors();
 }
 
-void RGBController_CMARGBController::DeviceConfigureZone(int zone_idx)
+void RGBController_CMARGBController::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
-        controller->SetPortLEDCount(zone_idx, zones[zone_idx].leds_count);
-
-        SetupZones();
+        return;
     }
+    uint8_t end_zone = last_zone(zone);
+
+    for(std::size_t zone_idx = first_zone(zone); zone_idx < end_zone; zone_idx++)
+    {
+        if(((unsigned int)new_size >= zones[zone_idx].leds_min) && ((unsigned int)new_size <= zones[zone_idx].leds_max))
+        {
+            zones[zone_idx].leds_count = new_size;
+        }
+    }
+
+    SetupZones();
 }
 
 void RGBController_CMARGBController::DeviceUpdateLEDs()
 {
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    uint8_t end_zone = last_zone(cmargb->GetZoneIndex());
+
+    for(int zone_idx = first_zone(cmargb->GetZoneIndex()); zone_idx < end_zone; zone_idx++)
     {
-        DeviceUpdateZoneLEDs((int)zone_idx);
+        DeviceUpdateZoneLEDs(zone_idx);
     }
 }
 
 void RGBController_CMARGBController::DeviceUpdateZoneLEDs(int zone)
 {
-    if(modes[active_mode].value != CM_ARGB_MODE_DIRECT)
-    {
-        return;
-    }
-
-    /*-----------------------------------------------------*\
-    | The RGB zone doesn't have a separate Direct mode, so  |
-    | use static mode with the per-LED color for it         |
-    \*-----------------------------------------------------*/
-    if(zone < 4)
-    {
-        controller->SetPortLEDsDirect(zone, zones[zone].colors, zones[zone].leds_count);
-    }
-    else
-    {
-        controller->SetPortMode(zone, CM_RGB_MODE_STATIC, 0, 255, false, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
-    }
+    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
 }
 
 void RGBController_CMARGBController::DeviceUpdateSingleLED(int led)
 {
-    unsigned int zone_idx = leds[led].value;
-
-    UpdateZoneLEDs(zone_idx);
+    DeviceUpdateZoneLEDs(GetLED_Zone(led));
 }
 
 void RGBController_CMARGBController::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------*\
-    | Apply mode to all zones                               |
-    \*-----------------------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        DeviceUpdateZoneMode((int)zone_idx);
-    }
+    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours );
 }
 
-void RGBController_CMARGBController::DeviceUpdateZoneMode(int zone)
+int RGBController_CMARGBController::GetLED_Zone(int led_idx)
 {
-    /*-----------------------------------------------------*\
-    | Determine the active mode for this zone               |
-    \*-----------------------------------------------------*/
-    bool            use_zone_mode       = false;
-    int             zone_active_mode    = active_mode;
-    int             zone_mode_value     = modes[active_mode].value;
-
-    /*-----------------------------------------------------*\
-    | Set up mode parameters                                |
-    \*-----------------------------------------------------*/
-    bool            random              = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    RGBColor        color               = 0;
-    unsigned int    brightness          = modes[active_mode].brightness;
-    unsigned int    speed               = modes[active_mode].speed;
-
-    if(modes[active_mode].colors.size() > 0)
+    /*---------------------------------------------------------*\
+    | This may be more useful in the abstract RGBController.cpp |
+    \*---------------------------------------------------------*/
+    for(int zone_idx = 0; zone_idx < (int)zones.size(); zone_idx++)
     {
-        color                           = modes[active_mode].colors[0];
-    }
+        int zone_start  = zones[zone_idx].start_idx;
+        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
 
-    if(!(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE))
-    {
-        if(zones[zone].active_mode >= 0)
+        if(zone_start <= led_idx && zone_end >= led_idx)
         {
-            use_zone_mode               = true;
-            zone_active_mode            = zones[zone].active_mode;
-            zone_mode_value             = zones[zone].modes[zone_active_mode].value;
-
-            random                      = (zones[zone].modes[zone_active_mode].color_mode == MODE_COLORS_RANDOM);
-
-            if(zones[zone].modes[zone_active_mode].colors.size() > 0)
-            {
-                color                   = zones[zone].modes[zone_active_mode].colors[0];
-            }
-
-            brightness                  = zones[zone].modes[zone_active_mode].brightness;
-            speed                       = zones[zone].modes[zone_active_mode].speed;
+            return(zone_idx);
         }
     }
 
-    if((zone == 4) && !use_zone_mode)
-    {
-        /*-------------------------------------------------*\
-        | Map entire-device ARGB modes with the equivalent  |
-        | RGB modes for the RGB zone                        |
-        \*-------------------------------------------------*/
-        switch(modes[active_mode].value)
-        {
-            case CM_ARGB_MODE_SPECTRUM:
-            case CM_ARGB_MODE_FILLFLOW:
-            case CM_ARGB_MODE_RAINBOW:
-                zone_mode_value         = CM_RGB_MODE_MIRAGE;
-                random                  = true;
-                break;
-
-            case CM_ARGB_MODE_RELOAD:
-            case CM_ARGB_MODE_RECOIL:
-                zone_mode_value         = CM_RGB_MODE_FLASH;
-                break;
-
-            case CM_ARGB_MODE_BREATHING:
-                zone_mode_value         = CM_RGB_MODE_BREATHING;
-                break;
-
-            case CM_ARGB_MODE_REFILL:
-            case CM_ARGB_MODE_STATIC:
-                zone_mode_value         = CM_RGB_MODE_STATIC;
-                break;
-
-            case CM_ARGB_MODE_DEMO:
-                zone_mode_value         = CM_RGB_MODE_FLASH;
-                random                  = true;
-                break;
-
-            case CM_ARGB_MODE_OFF:
-            default:
-                zone_mode_value         = CM_RGB_MODE_OFF;
-                break;
-
-            case CM_ARGB_MODE_PASSTHRU:
-                zone_mode_value         = CM_RGB_MODE_PASSTHRU;
-                break;
-        }
-    }
-
-    controller->SetPortMode
-                    (
-                        zone,
-                        zone_mode_value,
-                        speed,
-                        brightness,
-                        random,
-                        RGBGetRValue(color),
-                        RGBGetGValue(color),
-                        RGBGetBValue(color)
-                    );
+    return -1;
 }

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.h

@@ -12,8 +12,11 @@
 #pragma once
 
 #include <vector>
-#include "CMARGBController.h"
 #include "RGBController.h"
+#include "CMARGBController.h"
+
+#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
+#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
 
 class RGBController_CMARGBController : public RGBController
 {
@@ -21,19 +24,19 @@ public:
     RGBController_CMARGBController(CMARGBController* controller_ptr);
     ~RGBController_CMARGBController();
 
-    void        SetupModes();
     void        SetupZones();
-
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
-    void        DeviceUpdateZoneMode(int zone);
 
 private:
-    CMARGBController*           controller;
-    std::vector<unsigned int>   leds_channel;
+    void        Init_Controller();
+    int         GetDeviceMode();
+    int         GetLED_Zone(int led_idx);
+
+    CMARGBController*   controller;
 };

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.cpp

@@ -186,8 +186,6 @@ RGBController_CMARGBGen2A1Controller::RGBController_CMARGBGen2A1Controller(CMARG
 
 RGBController_CMARGBGen2A1Controller::~RGBController_CMARGBGen2A1Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -220,8 +218,10 @@ void RGBController_CMARGBGen2A1Controller::SetupZones()
     SetupColors();
 }
 
-void RGBController_CMARGBGen2A1Controller::DeviceConfigureZone(int zone_idx)
+void RGBController_CMARGBGen2A1Controller::DeviceResizeZone(int zone, int new_size)
 {
+    zones[zone].leds_count = new_size;
+
     unsigned int total_leds = 0;
 
     for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
@@ -236,7 +236,7 @@ void RGBController_CMARGBGen2A1Controller::DeviceConfigureZone(int zone_idx)
         leds[i].name = "LED " + std::to_string(i + 1);
     }
 
-    controller->SetupZoneSize(zone_idx, zones[zone_idx].leds_count);
+    controller->SetupZoneSize(zone, new_size);
 
     SetupColors();
 }

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.h

@@ -23,7 +23,7 @@ public:
     ~RGBController_CMARGBGen2A1Controller();
 
     void SetupZones();
-    void DeviceConfigureZone(int zone_idx);
+    void DeviceResizeZone(int zone, int new_size);
     void DeviceUpdateLEDs();
     void DeviceUpdateZoneLEDs(int zone);
     void UpdateSegmentLEDs(int zone, int subchannel);

Controllers/CoolerMasterController/CMGD160Controller/RGBController_CMGD160Controller.cpp

@@ -140,8 +140,6 @@ RGBController_CMGD160Controller::RGBController_CMGD160Controller(CMGD160Controll
 
 RGBController_CMGD160Controller::~RGBController_CMGD160Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -159,7 +157,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Front LED " + std::to_string(i + 1);
-
+        l.value         = i;
         leds.push_back(l);
     }
 
@@ -175,7 +173,7 @@ void RGBController_CMGD160Controller::SetupZones()
     {
         led l;
         l.name          = "Back LED " + std::to_string(i + 1);
-
+        l.value         = i;
         leds.push_back(l);
     }