OpenRGB Release Candidate 1.0rc3.1

- CVE-2026-59682: OpenRGB: arbitrary file overwrite and deletion local and remote
- CVE-2026-59683: OpenRGB: local and remote system compromise via arbitrary file write using attacker controlled strings
- CVE-2026-18794: OpenRGB: insufficient input data checks lead to Denial-of-Service, memory overread and overwrite

.gitlab-ci.yml

@@ -14,9 +14,9 @@
 #   run only if manually started to save CI minutes if      #
 #   GitLab hosted runners                                   #
 # * For commits to the CalcProgrammer1/OpenRGB repository,  #
-#   automatically run all jobs on the default branch,       #
-#   otherwise run them if the source is part of a merge     #
-#   request                                                 #
+#   automatically run all jobs on the default branch or     #
+#   tag builds, otherwise run them if the source is part    #
+#   of a merge request                                      #
 #-----------------------------------------------------------#
 .downstream_rules:
   rules:
@@ -26,7 +26,7 @@
 
 .upstream_rules:
   rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_PIPELINE_SOURCE == "merge_request_event")'
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_COMMIT_TAG || $CI_PIPELINE_SOURCE == "merge_request_event")'
     when: on_success
   - !reference [.downstream_rules, rules]
 
@@ -100,19 +100,19 @@ before_script:
 "Linux i386 AppImage":
   variables:
     TGT_ARCH: "i386"
-    TGT_QT: "qt6"
+    TGT_QT: ""
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt5 i386 Build Target                    #
+# Linux (AppImage) Qt6 i386 Build Target                    #
 #-----------------------------------------------------------#
-"Linux i386 AppImage Qt5":
+"Linux i386 AppImage Qt6":
   variables:
     TGT_ARCH: "i386"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}_qt5"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -122,7 +122,7 @@ before_script:
 "Linux amd64 AppImage":
   variables:
     TGT_ARCH: "amd64"
-    TGT_QT: "qt6"
+    TGT_QT: ""
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "x86_64"
   <<: *appimage_script_steps
@@ -137,13 +137,13 @@ before_script:
   - "saas-linux-small-amd64"
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt5 amd64 Build Target                   #
+# Linux (AppImage) Qt6 amd64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux amd64 AppImage Qt5":
+"Linux amd64 AppImage Qt6":
   variables:
     TGT_ARCH: "amd64"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}_qt5"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
     TGT_PATH: "x86_64"
   <<: *appimage_script_steps
 
@@ -153,19 +153,19 @@ before_script:
 "Linux armhf AppImage":
   variables:
     TGT_ARCH: "armhf"
-    TGT_QT: "qt6"
+    TGT_QT: ""
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt5 armhf Build Target                   #
+# Linux (AppImage) Qt6 armhf Build Target                   #
 #-----------------------------------------------------------#
-"Linux armhf AppImage Qt5":
+"Linux armhf AppImage Qt6":
   variables:
     TGT_ARCH: "armhf"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}_qt5"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -175,19 +175,19 @@ before_script:
 "Linux arm64 AppImage":
   variables:
     TGT_ARCH: "arm64"
-    TGT_QT: "qt6"
+    TGT_QT: ""
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt5 arm64 Build Target                   #
+# Linux (AppImage) Qt6 arm64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux arm64 AppImage Qt5":
+"Linux arm64 AppImage Qt6":
   variables:
     TGT_ARCH: "arm64"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}_qt5"
+    TGT_QT: "qt6"
+    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -296,10 +296,7 @@ before_script:
   image: fedora:43
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git wget -y
-  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
-  - unzip hidapi-hotplug.zip
-  - dnf install ./*.rpm -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
   - rpmdev-setuptree
   - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
@@ -327,14 +324,10 @@ before_script:
   image: i386/debian:bookworm
   stage: test
   script:
-  - DEBIAN_FRONTEND=noninteractive apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
-  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+i386+.deb+%28Debian+Bookworm%29'
-  - unzip hidapi-hotplug.zip
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
+  - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
-  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
+  - apt remove -y openrgb
   dependencies:
   - "Linux i386 .deb (Debian Bookworm)"
   needs:
@@ -349,14 +342,10 @@ before_script:
   image: amd64/debian:bookworm
   stage: test
   script:
-  - DEBIAN_FRONTEND=noninteractive apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
-  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
-  - unzip hidapi-hotplug.zip
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
+  - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
+  - apt remove -y openrgb
   dependencies:
   - "Linux amd64 .deb (Debian Bookworm)"
   needs:
@@ -371,14 +360,10 @@ before_script:
   image: ubuntu:noble
   stage: test
   script:
-  - DEBIAN_FRONTEND=noninteractive apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
-  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
-  - unzip hidapi-hotplug.zip
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
+  - apt update
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
+  - apt remove -y openrgb
   dependencies:
   - "Linux amd64 .deb (Debian Bookworm)"
   needs:
@@ -393,10 +378,6 @@ before_script:
   image: fedora:43
   stage: test
   script:
-  - dnf install unzip wget -y
-  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
-  - unzip hidapi-hotplug.zip
-  - dnf install ./*.rpm -y
   - dnf5 -y install ./openrgb*64.rpm
   - openrgb --version
   - dnf5 -y remove openrgb
@@ -416,7 +397,7 @@ before_script:
   stage: build
   script:
   - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 32
+  - scripts\build-windows.bat 5.15.0 2019 32
   artifacts:
     name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -429,17 +410,17 @@ before_script:
     - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# Windows (32-bit) Qt5 Build Target                         #
+# Windows (32-bit) Qt6 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 32 Qt5":
+"Windows 32 Qt6":
   extends:
   - .shared_windows_runners
   stage: build
   script:
   - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 32
+  - scripts\build-windows.bat 6.8.3 2022 32
   artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_32_Qt5_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_32_Qt6_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 32-bit'
     exclude:
@@ -458,7 +439,7 @@ before_script:
   stage: build
   script:
   - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 64
+  - scripts\build-windows.bat 5.15.0 2019 64
   artifacts:
     name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -489,17 +470,17 @@ before_script:
   - "saas-windows-medium-amd64"
 
 #-----------------------------------------------------------#
-# Windows (64-bit) Qt5 Build Target                         #
+# Windows (64-bit) Qt6 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 64 Qt5 Base":
+"Windows 64 Qt6 Base":
   extends:
   - .shared_windows_runners
   stage: build
   script:
   - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 64
+  - scripts\build-windows.bat 6.8.3 2022 64
   artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_64_Qt5_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_64_Qt6_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 64-bit'
     exclude:
@@ -510,14 +491,13 @@ before_script:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
       when: never
 
-
-"Windows 64 Qt5":
-  extends: "Windows 64 Qt5 Base"
+"Windows 64 Qt6":
+  extends: "Windows 64 Qt6 Base"
   rules:
   - !reference [.upstream_rules, rules]
 
-"Windows 64 Qt5 (Downstream)":
-  extends: "Windows 64 Qt5 Base"
+"Windows 64 Qt6 (Downstream)":
+  extends: "Windows 64 Qt6 Base"
   before_script:
     - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
     - cd OpenRGB-Qt-Packages
@@ -536,7 +516,7 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 arm
+  - ./scripts/build-macos.sh qt5 arm
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -547,15 +527,15 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS ARM64 Qt5":
+"MacOS ARM64 Qt6":
   tags:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 arm
+  - ./scripts/build-macos.sh qt6 arm
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_ARM64_Qt6_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days
@@ -568,7 +548,7 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 intel
+  - ./scripts/build-macos.sh qt5 intel
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -579,15 +559,15 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS Intel Qt5":
+"MacOS Intel Qt6":
   tags:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 intel
+  - ./scripts/build-macos.sh qt6 intel
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt6_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -10,52 +10,47 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+/*-----------------------------------------------------*\
+| OpenRGB includes                                      |
+\*-----------------------------------------------------*/
 #include <hidapi.h>
-#include "BloodyB820RController.h"
-#include "BloodyMouseController.h"
-#include "DetectionManager.h"
-#include "RGBController_BloodyB820R.h"
-#include "RGBController_BloodyMouse.h"
+#include "Detector.h"
 
-/*---------------------------------------------------------*\
-| A4 Tech USB vendor ID                                     |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| A4 Tech specific includes                             |
+\*-----------------------------------------------------*/
+#include "RGBController_BloodyMouse.h"
+#include "RGBController_BloodyB820R.h"
+
+/*-----------------------------------------------------*\
+| A4 Tech USB vendor ID                                 |
+\*-----------------------------------------------------*/
 #define A4_TECH_VID                                 0x09DA
 
-DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        BloodyMouseController*     controller       = new BloodyMouseController(dev, info->path, info->product_id, name);
+        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id, name);
         RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
+void DetectBloodyB820R(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
         RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -173,8 +173,6 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 
 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -189,7 +187,11 @@ void RGBController_BloodyB820R::SetupZones()
     KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
     KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
     KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-    KB_zone.matrix_map.Set(6, 21, (unsigned int *)&matrix_map);
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = 6;
+    KB_zone.matrix_map->width   = 21;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
     zones.push_back(KB_zone);
 
     /*-------------------------------------------------*\
@@ -212,12 +214,20 @@ void RGBController_BloodyB820R::SetupZones()
     SetupColors();
 }
 
+void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+
 void RGBController_BloodyB820R::DeviceUpdateLEDs()
 {
     controller->SetLEDDirect(colors);
 }
 
-void RGBController_BloodyB820R::DeviceUpdateZoneLEDs(int zone)
+void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
 {
     std::vector<RGBColor> colour;
 
@@ -229,7 +239,7 @@ void RGBController_BloodyB820R::DeviceUpdateZoneLEDs(int zone)
     controller->SetLEDDirect(colour);
 }
 
-void RGBController_BloodyB820R::DeviceUpdateSingleLED(int led)
+void RGBController_BloodyB820R::UpdateSingleLED(int led)
 {
     std::vector<RGBColor> colour;
     colour.push_back(colors[led]);

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.h

@@ -22,10 +22,11 @@ public:
     ~RGBController_BloodyB820R();
 
     void    SetupZones();
+    void    ResizeZone(int zone, int new_size);
 
     void    DeviceUpdateLEDs();
-    void    DeviceUpdateZoneLEDs(int zone);
-    void    DeviceUpdateSingleLED(int led);
+    void    UpdateZoneLEDs(int zone);
+    void    UpdateSingleLED(int led);
 
     void    DeviceUpdateMode();
 

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -89,8 +89,6 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
 
 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -136,6 +134,7 @@ void RGBController_BloodyMouse::SetupZones()
         new_zone.leds_max       = new_zone.leds_min;
         new_zone.leds_count     = new_zone.leds_min;
         new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+        new_zone.matrix_map     = NULL;
         zones.push_back(new_zone);
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
@@ -161,6 +160,13 @@ void RGBController_BloodyMouse::SetupZones()
     SetupColors();
 }
 
+void RGBController_BloodyMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_BloodyMouse::DeviceUpdateLEDs()
 {
     std::vector<RGBColor> colour;
@@ -173,12 +179,12 @@ void RGBController_BloodyMouse::DeviceUpdateLEDs()
     controller->SetLedsDirect(colour);
 }
 
-void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_BloodyMouse::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -30,10 +30,11 @@ public:
     ~RGBController_BloodyMouse();
 
     void                    SetupZones();
+    void                    ResizeZone(int zone, int new_size);
 
     void                    DeviceUpdateLEDs();
-    void                    DeviceUpdateZoneLEDs(int zone);
-    void                    DeviceUpdateSingleLED(int led);
+    void                    UpdateZoneLEDs(int zone);
+    void                    UpdateSingleLED(int led);
 
     void                    DeviceUpdateMode();
 

Controllers/AMBXController/AMBXControllerDetect.cpp

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include "Detector.h"
 #include "AMBXController.h"
-#include "DetectionManager.h"
 #include "RGBController.h"
 #include "RGBController_AMBX.h"
 
@@ -18,60 +18,66 @@
 #include <libusb.h>
 #endif
 
-DetectedControllers DetectAMBXControllers()
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAMBXControllers                                                                  *
+*                                                                                          *
+*       Detect Philips amBX Gaming devices                                                 *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAMBXControllers()
 {
-    DetectedControllers detected_controllers;
-    libusb_context*     ctx = NULL;
+    libusb_context* ctx = NULL;
 
-    if(libusb_init(&ctx) >= 0)
+    if(libusb_init(&ctx) < 0)
     {
-        libusb_device** devs;
-        ssize_t num_devs = libusb_get_device_list(ctx, &devs);
+        return;
+    }
 
-        if(num_devs > 0)
+    libusb_device** devs;
+    ssize_t num_devs = libusb_get_device_list(ctx, &devs);
+
+    if(num_devs <= 0)
+    {
+        libusb_exit(ctx);
+        return;
+    }
+
+    for(ssize_t i = 0; i < num_devs; i++)
+    {
+        libusb_device* dev = devs[i];
+        libusb_device_descriptor desc;
+
+        if(libusb_get_device_descriptor(dev, &desc) != 0)
         {
-            for(ssize_t i = 0; i < num_devs; i++)
-            {
-                libusb_device* dev = devs[i];
-                libusb_device_descriptor desc;
-
-                if(libusb_get_device_descriptor(dev, &desc) != 0)
-                {
-                    continue;
-                }
-
-                if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
-                {
-                    uint8_t bus = libusb_get_bus_number(dev);
-                    uint8_t address = libusb_get_device_address(dev);
-                    char device_path[32];
-                    snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
-
-                    // Use the AMBXController to handle opening and initializing
-                    AMBXController* controller = new AMBXController(device_path);
-
-                    if(controller->IsInitialized())
-                    {
-                        RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
-                        detected_controllers.push_back(rgb_controller);
-                    }
-                    else
-                    {
-                        delete controller;
-                    }
-                }
-            }
-
-            libusb_free_device_list(devs, 1);
-            libusb_exit(ctx);
+            continue;
         }
-        else
+
+        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
         {
-            libusb_exit(ctx);
+            uint8_t bus = libusb_get_bus_number(dev);
+            uint8_t address = libusb_get_device_address(dev);
+            char device_path[32];
+            snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
+
+            // Use the AMBXController to handle opening and initializing
+            AMBXController* controller = new AMBXController(device_path);
+
+            if(controller->IsInitialized())
+            {
+                RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+            }
+            else
+            {
+                delete controller;
+            }
         }
     }
 
-    return(detected_controllers);
+    libusb_free_device_list(devs, 1);
+    libusb_exit(ctx);
 }
 
 REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -44,8 +44,6 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
 
 RGBController_AMBX::~RGBController_AMBX()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -58,6 +56,7 @@ void RGBController_AMBX::SetupZones()
     side_lights_zone.leds_min   = 2;
     side_lights_zone.leds_max   = 2;
     side_lights_zone.leds_count = 2;
+    side_lights_zone.matrix_map = NULL;
     zones.push_back(side_lights_zone);
 
     zone wallwasher_zone;
@@ -66,6 +65,7 @@ void RGBController_AMBX::SetupZones()
     wallwasher_zone.leds_min   = 3;
     wallwasher_zone.leds_max   = 3;
     wallwasher_zone.leds_count = 3;
+    wallwasher_zone.matrix_map = NULL;
     zones.push_back(wallwasher_zone);
 
     // Set up LEDs
@@ -97,6 +97,11 @@ void RGBController_AMBX::SetupZones()
     SetupColors();
 }
 
+void RGBController_AMBX::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    // This device does not support resizing zones
+}
+
 void RGBController_AMBX::DeviceUpdateLEDs()
 {
     if(!controller->IsInitialized())
@@ -116,7 +121,7 @@ void RGBController_AMBX::DeviceUpdateLEDs()
     controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
 }
 
-void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AMBX::UpdateZoneLEDs(int zone)
 {
     if(!controller->IsInitialized())
     {
@@ -151,7 +156,7 @@ void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
     controller->SetLEDColors(led_values, led_colors, zone_size);
 }
 
-void RGBController_AMBX::DeviceUpdateSingleLED(int led)
+void RGBController_AMBX::UpdateSingleLED(int led)
 {
     if(!controller->IsInitialized())
     {

Controllers/AMBXController/RGBController_AMBX.h

@@ -19,10 +19,11 @@ public:
     ~RGBController_AMBX();
 
     void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -10,8 +10,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
+#include "Detector.h"
 #include "AMDWraithPrismController.h"
-#include "DetectionManager.h"
 #include "RGBController_AMDWraithPrism.h"
 
 /*---------------------------------------------------------*\
@@ -24,22 +24,25 @@
 \*---------------------------------------------------------*/
 #define AMD_WRAITH_PRISM_PID                        0x0051
 
-DetectedControllers DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAMDWraithPrismControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
         RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -132,8 +132,6 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -156,6 +154,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     logo_zone.leds_min      = 1;
     logo_zone.leds_max      = 1;
     logo_zone.leds_count    = 1;
+    logo_zone.matrix_map    = NULL;
     zones.push_back(logo_zone);
 
     zone fan_zone;
@@ -164,6 +163,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     fan_zone.leds_min       = 1;
     fan_zone.leds_max       = 1;
     fan_zone.leds_count     = 1;
+    fan_zone.matrix_map     = NULL;
     zones.push_back(fan_zone);
 
     zone ring_zone;
@@ -172,6 +172,7 @@ void RGBController_AMDWraithPrism::SetupZones()
     ring_zone.leds_min      = 15;
     ring_zone.leds_max      = 15;
     ring_zone.leds_count    = 15;
+    ring_zone.matrix_map    = NULL;
     zones.push_back(ring_zone);
 
     /*-----------------------------------------------------*\
@@ -204,6 +205,13 @@ void RGBController_AMDWraithPrism::SetupZones()
     SetupColors();
 }
 
+void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*-----------------------------------------------------*\
+    | This device does not support resizing zones           |
+    \*-----------------------------------------------------*/
+}
+
 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
@@ -263,12 +271,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AMDWraithPrism::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AMDWraithPrism::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

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

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -9,33 +9,36 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCKeyboardController.h"
 #include "RGBController_AOCKeyboard.h"
 
-/*---------------------------------------------------------*\
-| AOC Keyboard IDs                                          |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Keyboard IDs                                      |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
 #define AOC_GK500_PID_2                             0x1229
 
-DetectedControllers DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCKeyboardControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
         RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -257,25 +257,35 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 
 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_AOCKeyboard::SetupZones()
 {
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
-
     /*---------------------------------------------------------*\
     | Create the keyboard zone usiung Keyboard Layout Manager   |
     \*---------------------------------------------------------*/
     zone new_zone;
-    new_zone.name                   = ZONE_EN_KEYBOARD;
-    new_zone.type                   = ZONE_TYPE_MATRIX;
-    new_zone.leds_count             = new_kb.GetKeyCount();
-    new_zone.leds_min               = new_zone.leds_count;
-    new_zone.leds_max               = new_zone.leds_count;
-    new_zone.matrix_map             = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
+    new_zone.name               = ZONE_EN_KEYBOARD;
+    new_zone.type               = ZONE_TYPE_MATRIX;
+
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
+
+    matrix_map_type * new_map   = new matrix_map_type;
+    new_zone.matrix_map         = new_map;
+    new_zone.matrix_map->height = new_kb.GetRowCount();
+    new_zone.matrix_map->width  = new_kb.GetColumnCount();
+
+    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
+    new_zone.leds_count         = new_kb.GetKeyCount();
+    new_zone.leds_min           = new_zone.leds_count;
+    new_zone.leds_max           = new_zone.leds_count;
+
+    /*---------------------------------------------------------*\
+    | Matrix map still uses declared zone rows and columns      |
+    |   as the packet structure depends on the matrix map       |
+    \*---------------------------------------------------------*/
+    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
 
     /*---------------------------------------------------------*\
     | Create LEDs for the Matrix zone                           |
@@ -295,6 +305,13 @@ void RGBController_AOCKeyboard::SetupZones()
     SetupColors();
 }
 
+void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
@@ -314,12 +331,12 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AOCKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCKeyboard::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCMouseController/AOCMouseController.cpp

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

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -9,32 +9,35 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCMouseController.h"
 #include "RGBController_AOCMouse.h"
 
-/*---------------------------------------------------------*\
-| AOC Mouse IDs                                             |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Mouse IDs                                         |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179
 
-DetectedControllers DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMouseControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mouse controller exists there.              *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
         RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("AOC GM500",  DetectAOCMouseControllers,  AOC_VID,    AOC_GM500_PID,  1,  0xFF19, 0xFF19);

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -123,8 +123,6 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -136,6 +134,7 @@ void RGBController_AOCMouse::SetupZones()
     logo_zone.leds_min              = 1;
     logo_zone.leds_max              = 1;
     logo_zone.leds_count            = 1;
+    logo_zone.matrix_map            = NULL;
     zones.push_back(logo_zone);
 
     led logo_led;
@@ -148,6 +147,7 @@ void RGBController_AOCMouse::SetupZones()
     scroll_wheel_zone.leds_min      = 1;
     scroll_wheel_zone.leds_max      = 1;
     scroll_wheel_zone.leds_count    = 1;
+    scroll_wheel_zone.matrix_map    = NULL;
     zones.push_back(scroll_wheel_zone);
 
     led scroll_wheel_led;
@@ -157,17 +157,24 @@ void RGBController_AOCMouse::SetupZones()
     SetupColors();
 }
 
+void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCMouse::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_AOCMouse::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMouse::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AOCMousematController/AOCMousematController.cpp

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

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -9,32 +9,35 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AOCMousematController.h"
 #include "RGBController_AOCMousemat.h"
 
-/*---------------------------------------------------------*\
-| AOC Mousemat IDs                                          |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| AOC Mousemat IDs                                      |
+\*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_AMM700_PID                              0x1162
 
-DetectedControllers DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAOCMousematControllers                                                           *
+*                                                                                          *
+*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
         RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -113,8 +113,6 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -126,6 +124,7 @@ void RGBController_AOCMousemat::SetupZones()
     mousemat_zone.leds_min      = 1;
     mousemat_zone.leds_max      = 1;
     mousemat_zone.leds_count    = 1;
+    mousemat_zone.matrix_map    = NULL;
     zones.push_back(mousemat_zone);
 
     led mousemat_led;
@@ -135,17 +134,24 @@ void RGBController_AOCMousemat::SetupZones()
     SetupColors();
 }
 
+void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AOCMousemat::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_AOCMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMousemat::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -11,12 +11,12 @@
 \*---------------------------------------------------------*/
 
 #include <cstring>
-#include "ASRockPolychromeUSBController.h"
-#include "dmiinfo.h"
-#include "ResourceManager.h"
 #include "RGBController.h"
+#include "ResourceManager.h"
 #include "SettingsManager.h"
 #include "StringUtils.h"
+#include "ASRockPolychromeUSBController.h"
+#include "dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
     WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }
 
-void PolychromeUSBController::SetZoneSize(int zone, int new_size)
+void PolychromeUSBController::ResizeZone(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

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

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -11,8 +11,8 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
+#include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
-#include "DetectionManager.h"
 #include "RGBController_ASRockPolychromeUSB.h"
 
 /*---------------------------------------------------------*\
@@ -26,22 +26,16 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
 
-DetectedControllers DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
+void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
         RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);

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,55 +197,28 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
-
-            if(first_run)
-            {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = device_info.num_leds;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
 
+
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
@@ -273,6 +229,8 @@ void RGBController_PolychromeUSB::SetupZones()
 
             leds.push_back(new_led);
         }
+
+        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
@@ -315,14 +273,10 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
-    {
-        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
-
-        SetupZones();
-    }
+    zones[zone].leds_count = (unsigned char) new_size;
+    controller->ResizeZone(zones_info[zone].zone, new_size);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -345,7 +299,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
+void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
 {
     unsigned char set_mode=zones_info[zone].mode;
 
@@ -357,7 +311,7 @@ void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
     controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
-void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
+void RGBController_PolychromeUSB::UpdateSingleLED(int led)
 {
     unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -19,15 +19,14 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
     RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
-    ~RGBController_PolychromeUSB();
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

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;
 }
 
@@ -137,6 +135,7 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     new_zone->leds_min      = 1;
     new_zone->leds_max      = 1;
     new_zone->leds_count    = 1;
+    new_zone->matrix_map    = NULL;
 
     /*---------------------------------------------------------*\
     | Push new zone to zones vector                             |
@@ -161,20 +160,27 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     SetupColors();
 }
 
+void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)
     {
-        DeviceUpdateSingleLED(led);
+        UpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockASRRGBSMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockASRRGBSMBus::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
+void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/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;
 }
 
@@ -269,6 +267,7 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
             new_zone->leds_min      = 1;
             new_zone->leds_max      = 1;
             new_zone->leds_count    = 1;
+            new_zone->matrix_map    = NULL;
 
             if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
             {
@@ -298,9 +297,10 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
+void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
 {
-    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
+    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    controller-> SetARGBSize(new_size & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 
@@ -309,19 +309,19 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
     LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
     for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
     {
-        DeviceUpdateSingleLED(zone_idx);
+        UpdateSingleLED(zone_idx);
     }
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
 {
-    LOG_TRACE("[%s] DeviceUpdateZoneLEDs()", name.c_str());
+    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
 {
-    LOG_TRACE("[%s] DeviceUpdateSingleLED(%02X)", name.c_str(), zone);
+    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
 
     uint8_t red = RGBGetRValue(colors[zone]);
     uint8_t grn = RGBGetGValue(colors[zone]);
@@ -338,7 +338,7 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
         for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
         {
             controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
-            DeviceUpdateSingleLED(zone_idx);
+            UpdateSingleLED(zone_idx);
         }
     }
     else

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -23,11 +23,11 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

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;
 }
 
@@ -231,6 +229,8 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_zone->type          = ZONE_TYPE_SINGLE;
             }
 
+            new_zone->matrix_map        = NULL;
+
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/
@@ -281,7 +281,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
+void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -292,16 +292,16 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)
     {
-        DeviceUpdateSingleLED(led);
+        UpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV2SMBus::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(int led)
+void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -23,11 +23,11 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

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

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -7,8 +7,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
+#include "Detector.h"
 #include "AlienwareController.h"
-#include "DetectionManager.h"
 #include "RGBController_Alienware.h"
 
 /*---------------------------------------------------------*\
@@ -22,22 +22,17 @@
 #define ALIENWARE_G_SERIES_PID1                      0x0550
 #define ALIENWARE_G_SERIES_PID2                      0x0551
 
-DetectedControllers DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareController*     controller     = new AlienwareController(dev, *info, name);
         RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);

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()
 {
     /*-------------------------------------------------*\
@@ -148,6 +141,7 @@ void RGBController_Alienware::SetupZones()
         new_zone.leds_min   = 1;
         new_zone.leds_max   = 1;
         new_zone.leds_count = 1;
+        new_zone.matrix_map = nullptr;
 
         zones.emplace_back(new_zone);
     }
@@ -164,19 +158,26 @@ void RGBController_Alienware::SetupZones()
     SetupColors();
 }
 
+void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_Alienware::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_Alienware::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_Alienware::DeviceUpdateSingleLED(int led)
+void RGBController_Alienware::UpdateSingleLED(int led)
 {
-    DeviceUpdateZoneLEDs(led);
+    UpdateZoneLEDs(led);
 }
 
 static bool modes_eq(const mode& mode1, const mode& mode2)

Controllers/AlienwareController/RGBController_Alienware.h

@@ -19,13 +19,14 @@ class RGBController_Alienware : public RGBController
 {
 public:
     RGBController_Alienware(AlienwareController* controller_ptr);
-    ~RGBController_Alienware();
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.cpp

@@ -319,7 +319,7 @@ void AlienwareAW410KController::SetMode
     SendCommit();
 }
 
-void AlienwareAW410KController::DeviceUpdateSingleLED
+void AlienwareAW410KController::UpdateSingleLED
     (
     unsigned char   led,
     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.h

@@ -130,7 +130,7 @@ public:
                     unsigned char   blue2
                     );
 
-    void        DeviceUpdateSingleLED
+    void        UpdateSingleLED
                     (
                     unsigned char   led,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -278,7 +278,16 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 
 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    Shutdown();
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
 
     delete controller;
 }
@@ -301,7 +310,14 @@ void RGBController_AlienwareAW410K::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map.Set(6, 24, (unsigned int *)&matrix_map);
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 6;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
         }
 
         zones.push_back(new_zone);
@@ -320,6 +336,13 @@ void RGBController_AlienwareAW410K::SetupZones()
     SetupColors();
 }
 
+void RGBController_AlienwareAW410K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
 {
     std::vector<SelectedButtons>   frame_buf_keys;
@@ -351,21 +374,21 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
     std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }
 
-void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
 {
     controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }
 
-void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
+void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW410K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)
     {
-        UpdateLEDsInternal();
+        UpdateLEDs();
         return;
     }
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -23,9 +23,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.cpp

@@ -318,7 +318,7 @@ void AlienwareAW510KController::SetMode
     SendCommit();
 }
 
-void AlienwareAW510KController::DeviceUpdateSingleLED
+void AlienwareAW510KController::UpdateSingleLED
     (
     unsigned char   led,
     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.h

@@ -132,7 +132,7 @@ public:
                     unsigned char   blue2
                     );
 
-    void        DeviceUpdateSingleLED
+    void        UpdateSingleLED
                     (
                     unsigned char   led,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -277,7 +277,16 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 
 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    Shutdown();
+    /*---------------------------------------------------------*\
+    | Delete the matrix map                                     |
+    \*---------------------------------------------------------*/
+    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
+    {
+        if(zones[zone_index].matrix_map != NULL)
+        {
+            delete zones[zone_index].matrix_map;
+        }
+    }
 
     delete controller;
 }
@@ -300,7 +309,14 @@ void RGBController_AlienwareAW510K::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 7;
+            new_zone.matrix_map->width  = 24;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
         }
 
         zones.push_back(new_zone);
@@ -319,6 +335,13 @@ void RGBController_AlienwareAW510K::SetupZones()
     SetupColors();
 }
 
+void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
 {
     std::vector<SelectedKeys>   frame_buf_keys;
@@ -372,21 +395,21 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
     std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }
 
-void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
 {
     controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }
 
-void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
+void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
 {
-    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)
     {
-        UpdateLEDsInternal();
+        UpdateLEDs();
         return;
     }
 

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -8,58 +8,55 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "DetectionManager.h"
-#include "AlienwareAW410KController.h"
+#include "Detector.h"
 #include "AlienwareAW510KController.h"
-#include "RGBController_AlienwareAW410K.h"
+#include "AlienwareAW410KController.h"
 #include "RGBController_AlienwareAW510K.h"
+#include "RGBController_AlienwareAW410K.h"
 
-/*---------------------------------------------------------*\
-| Alienware vendor ID                                       |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Alienware vendor ID                                   |
+\*-----------------------------------------------------*/
 #define ALIENWARE_VID                           0x04F2
 
-/*---------------------------------------------------------*\
-| Keyboard product IDs                                      |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
 #define ALIENWARE_AW510K_PID                    0x1830
 #define ALIENWARE_AW410K_PID                    0x1968
 
-DetectedControllers DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAlienwareKeyboardControllers                                                     *
+*                                                                                          *
+*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
         AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
         RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
-    if(dev)
+    hid_device* dev = hid_open_path(info->path);
+    if( dev )
     {
         AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
         RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
+}/* DetectAlienwareKeyboardControllers() */
 
-    return(detected_controllers);
-}
 
 REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
 REGISTER_HID_DETECTOR_IPU("Alienware AW410K",   DetectAlienwareAW410KControllers,   ALIENWARE_VID,  ALIENWARE_AW410K_PID,   0x02,   0xFF00, 0x01);

Controllers/AlienwareMonitorController/AlienwareMonitorControllerDetect.cpp

@@ -9,12 +9,12 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <hidapi.h>
+#include "Detector.h"
 #include "AlienwareAW3423DWFController.h"
 #include "AlienwareMonitorController.h"
-#include "DetectionManager.h"
 #include "RGBController_AlienwareAW3423DWF.h"
 #include "RGBController_AlienwareMonitor.h"
+#include <hidapi.h>
 
 /*---------------------------------------------------------*\
 | Alienware Vendor ID                                       |
@@ -29,40 +29,37 @@
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA
 
-DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+/******************************************************************************************\
+*                                                                                          *
+*   AlienwareAW3423DWFControllerDetect                                                     *
+*                                                                                          *
+*       Tests the USB address to see if an Alienware AW3423DWF exists there.               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
-
+    hid_device* dev = hid_open_path(info->path);
     if(dev)
     {
         AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
         RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
+void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
         RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -46,8 +46,6 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34
 
 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -59,6 +57,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     Logo.leds_min           = 1;
     Logo.leds_max           = 1;
     Logo.leds_count         = 1;
+    Logo.matrix_map         = NULL;
     zones.push_back(Logo);
 
     led Logo_LED;
@@ -72,6 +71,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     Number.leds_min         = 1;
     Number.leds_max         = 1;
     Number.leds_count       = 1;
+    Number.matrix_map       = NULL;
     zones.push_back(Number);
 
     led Number_LED;
@@ -85,6 +85,7 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     PowerButton.leds_min    = 1;
     PowerButton.leds_max    = 1;
     PowerButton.leds_count  = 1;
+    PowerButton.matrix_map  = NULL;
     zones.push_back(PowerButton);
 
     led PowerButton_LED;
@@ -95,6 +96,10 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     SetupColors();
 }
 
+void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+}
+
 void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -113,17 +118,17 @@ void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            DeviceUpdateSingleLED(led_idx);
+            UpdateSingleLED(led_idx);
         }
     }
 }
 
-void RGBController_AlienwareAW3423DWF::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareAW3423DWF::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AlienwareAW3423DWF::DeviceUpdateSingleLED(int led)
+void RGBController_AlienwareAW3423DWF::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.h

@@ -21,10 +21,11 @@ public:
     ~RGBController_AlienwareAW3423DWF();
 
     void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -46,8 +46,6 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC
 
 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -59,6 +57,7 @@ void RGBController_AlienwareMonitor::SetupZones()
     Logo.leds_min           = 1;
     Logo.leds_max           = 1;
     Logo.leds_count         = 1;
+    Logo.matrix_map         = NULL;
     zones.push_back(Logo);
 
     led Logo_LED;
@@ -72,6 +71,7 @@ void RGBController_AlienwareMonitor::SetupZones()
     Number.leds_min         = 1;
     Number.leds_max         = 1;
     Number.leds_count       = 1;
+    Number.matrix_map       = NULL;
     zones.push_back(Number);
 
     led Number_LED;
@@ -85,6 +85,7 @@ void RGBController_AlienwareMonitor::SetupZones()
     PowerButton.leds_min    = 1;
     PowerButton.leds_max    = 1;
     PowerButton.leds_count  = 1;
+    PowerButton.matrix_map  = NULL;
     zones.push_back(PowerButton);
 
     led PowerButton_LED;
@@ -95,6 +96,11 @@ void RGBController_AlienwareMonitor::SetupZones()
     SetupColors();
 }
 
+void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
 void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -113,17 +119,17 @@ void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            DeviceUpdateSingleLED(led_idx);
+            UpdateSingleLED(led_idx);
         }
     }
 }
 
-void RGBController_AlienwareMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareMonitor::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AlienwareMonitor::DeviceUpdateSingleLED(int led)
+void RGBController_AlienwareMonitor::UpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.h

@@ -21,10 +21,11 @@ RGBController_AlienwareMonitor(AlienwareMonitorController* controller_ptr);
     ~RGBController_AlienwareMonitor();
 
     void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -9,10 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <hidapi.h>
+#include "Detector.h"
 #include "AnnePro2Controller.h"
-#include "DetectionManager.h"
 #include "RGBController_AnnePro2.h"
+#include <hidapi.h>
 
 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -29,22 +29,25 @@
 #define ANNE_PRO_2_PID_4                            0xA293
 #define ANNE_PRO_2_PID_5                            0xA297
 
-DetectedControllers DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAnnePro2Controllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
         RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID_1, ANNE_PRO_2_PID_1, 1);

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -144,8 +144,6 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
 
 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -166,7 +164,14 @@ void RGBController_AnnePro2::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map.Set(5, 14, (unsigned int *)&matrix_map);
+            new_zone.matrix_map         = new matrix_map_type;
+            new_zone.matrix_map->height = 5;
+            new_zone.matrix_map->width  = 14;
+            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
         }
 
         zones.push_back(new_zone);
@@ -185,6 +190,13 @@ void RGBController_AnnePro2::SetupZones()
     SetupColors();
 }
 
+void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AnnePro2::DeviceUpdateLEDs()
 {
     const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
@@ -216,12 +228,12 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
     controller->SendDirect(frame_buf_length, frame_buf);
 }
 
-void RGBController_AnnePro2::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AnnePro2::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

@@ -21,10 +21,11 @@ public:
     ~RGBController_AnnePro2();
 
     void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -10,20 +10,17 @@
 \*---------------------------------------------------------*/
 
 #include <vector>
+#include "Detector.h"
 #include "ArcticController.h"
-#include "DetectionManager.h"
-#include "find_usb_serial_port.h"
 #include "RGBController_Arctic.h"
+#include "find_usb_serial_port.h"
 
 #define CH341_VID   0x1A86
 #define CH341_PID   0x7523
 
-DetectedControllers DetectArcticControllers()
+void DetectArcticControllers()
 {
-    DetectedControllers         detected_controllers;
-    std::vector<std::string *>  ports;
-
-    ports = find_usb_serial_port(CH341_VID, CH341_PID);
+    std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
 
     for(unsigned int device = 0; device < ports.size(); device++)
     {
@@ -32,7 +29,7 @@ DetectedControllers DetectArcticControllers()
         if(controller->IsPresent())
         {
             RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            detected_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         else
         {
@@ -41,8 +38,6 @@ DetectedControllers DetectArcticControllers()
 
         delete ports[device];
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);

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;
@@ -72,6 +70,7 @@ void RGBController_Arctic::SetupZones()
         LedZone.leds_count  = 1;
         LedZone.leds_min    = 1;
         LedZone.leds_max    = 1;
+        LedZone.matrix_map  = nullptr;
 
         led Led;
         Led.name    = LedZone.name + " LED";
@@ -84,6 +83,13 @@ void RGBController_Arctic::SetupZones()
     SetupColors();
 }
 
+void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_Arctic::DeviceUpdateLEDs()
 {
     last_update_time = std::chrono::steady_clock::now();
@@ -91,12 +97,12 @@ void RGBController_Arctic::DeviceUpdateLEDs()
     controller->SetChannels(colors);
 }
 
-void RGBController_Arctic::DeviceUpdateZoneLEDs(int /* zone */)
+void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_Arctic::DeviceUpdateSingleLED(int /* led */)
+void RGBController_Arctic::UpdateSingleLED(int /* led */)
 {
     DeviceUpdateLEDs();
 }
@@ -117,7 +123,7 @@ void RGBController_Arctic::KeepaliveThreadFunction()
         sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
         if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
         {
-            UpdateLEDsInternal();   // Already protected thru a device update thread
+            UpdateLEDs();   // Already protected thru a device update thread
             std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
         }
         else

Controllers/ArcticController/RGBController_Arctic.h

@@ -25,9 +25,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AresonController/AresonControllerDetect.cpp

@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AresonController.h"
 #include "RGBController_Areson.h"
 
@@ -28,22 +28,17 @@
 #define REDRAGON_M914_PID                              0xFA7B
 #define REDRAGON_M914_WIRELESS_PID                     0xFA7C
 
-DetectedControllers DetectAresonControllers(hid_device_info* info, const std::string& name)
+void DetectAresonControllers(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AresonController*     controller      = new AresonController(dev, *info, name);
         RGBController_Areson* rgb_controller  = new RGBController_Areson(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("ZET GAMING Edge Air Pro (Wireless)",     DetectAresonControllers, ARESON_VID, ZET_GAMING_EDGE_AIR_PRO_WIRELESS_PID,      1, 0xFF02, 2);

Controllers/AresonController/RGBController_Areson.cpp

@@ -125,8 +125,6 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
 
 RGBController_Areson::~RGBController_Areson()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -139,6 +137,7 @@ void RGBController_Areson::SetupZones()
     new_zone.leds_min   = 1;
     new_zone.leds_max   = 1;
     new_zone.leds_count = 1;
+    new_zone.matrix_map = nullptr;
 
     zones.emplace_back(new_zone);
 
@@ -151,17 +150,24 @@ void RGBController_Areson::SetupZones()
     SetupColors();
 }
 
+void RGBController_Areson::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_Areson::DeviceUpdateLEDs()
 {
     DeviceUpdateMode();
 }
 
-void RGBController_Areson::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_Areson::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateMode();
 }
 
-void RGBController_Areson::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_Areson::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateMode();
 }

Controllers/AresonController/RGBController_Areson.h

@@ -21,10 +21,11 @@ public:
     ~RGBController_Areson();
 
     void SetupZones();
+    void ResizeZone(int zone, int new_size);
 
     void DeviceUpdateLEDs();
-    void DeviceUpdateZoneLEDs(int zone);
-    void DeviceUpdateSingleLED(int led);
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
 
     void DeviceUpdateMode();
 

Controllers/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;
@@ -188,6 +186,7 @@ void RGBController_AuraCore::SetupZones()
         auraZone.leds_min   = 4;
         auraZone.leds_max   = 4;
         auraZone.leds_count = 4;
+        auraZone.matrix_map = NULL;
     }
     else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
     {
@@ -196,6 +195,7 @@ void RGBController_AuraCore::SetupZones()
         auraZone.leds_min   = 20;
         auraZone.leds_max   = 20;
         auraZone.leds_count = 20;
+        auraZone.matrix_map = NULL;
     }
     else
     {
@@ -215,12 +215,19 @@ void RGBController_AuraCore::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraCore::DeviceUpdateLEDs()
+void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
 {
-    DeviceUpdateZoneLEDs(0);
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
 }
 
-void RGBController_AuraCore::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraCore::DeviceUpdateLEDs()
+{
+    UpdateZoneLEDs(0);
+}
+
+void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
 {
     if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
     {
@@ -249,16 +256,16 @@ void RGBController_AuraCore::DeviceUpdateZoneLEDs(int /*zone*/)
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            DeviceUpdateSingleLED(led_idx);
+            UpdateSingleLED(led_idx);
         }
     }
     else
     {
-        DeviceUpdateSingleLED(0);
+        UpdateSingleLED(0);
     }
 }
 
-void RGBController_AuraCore::DeviceUpdateSingleLED(int led)
+void RGBController_AuraCore::UpdateSingleLED(int led)
 {
     unsigned char speed = 0xFF;
     unsigned char red   = 0;

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.h

@@ -24,9 +24,11 @@ public:
     void        SetupGA15DH();
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -10,7 +10,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AsusAuraCoreController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
@@ -19,47 +19,45 @@
 
 #define AURA_CORE_VID                   0x0B05
 
-DetectedControllers DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
-{
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraCoreControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
+*                                                                                          *
+\******************************************************************************************/
 
-    dev = hid_open_path(info->path);
+void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
+{
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraCoreController*     controller                  = new AuraCoreController(dev, info->path);
         RGBController_AuraCore* rgb_controller              = new RGBController_AuraCore(controller);
 
-        if(rgb_controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
         {
-            detected_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         else
         {
             delete rgb_controller;
         }
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
+void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusAuraCoreLaptopController*     controller        = new AsusAuraCoreLaptopController(dev, info->path);
         RGBController_AsusAuraCoreLaptop* rgb_controller    = new RGBController_AsusAuraCoreLaptop(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -11,7 +11,6 @@
 
 #include "AsusAuraCoreLaptopController.h"
 #include "dmiinfo.h"
-#include "ResourceManager.h"
 #include "SettingsManager.h"
 #include "StringUtils.h"
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h

@@ -15,8 +15,8 @@
 #include <vector>
 #include <hidapi.h>
 #include "LogManager.h"
-#include "ResourceManager.h"
 #include "RGBController.h"
+#include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
 #include "AsusAuraCoreLaptopDevices.h"
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -263,13 +263,11 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
 
     SetupZones();
 
-    SetActiveMode(active_mode);
+    SetMode(active_mode);
 }
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -341,7 +339,18 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                     else
                     {
                         new_zone.type               = ZONE_TYPE_MATRIX;
-                        new_zone.matrix_map         = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
+                        matrix_map_type * new_map   = new matrix_map_type;
+                        new_zone.matrix_map         = new_map;
+
+                        /*---------------------------------------------------------*\
+                        | Trusting the layout handed to the KLM is correct use the  |
+                        |   row & column counts to set the matrix height & width    |
+                        \*---------------------------------------------------------*/
+                        new_map->height             = new_kb.GetRowCount();
+                        new_map->width              = new_kb.GetColumnCount();
+                        new_map->map                = new unsigned int[new_map->height * new_map->width];
+
+                        new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
                     }
 
                     /*---------------------------------------------------------*\
@@ -389,6 +398,13 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
     }
 }
 
+void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
     for(size_t i = 85; i < leds.size(); i++)
@@ -406,12 +422,12 @@ void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
     controller->SetLedsDirect(buffer_map);
 }
 
-void RGBController_AsusAuraCoreLaptop::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
 {
     controller->SetLedsDirect(buffer_map);
 }
 
-void RGBController_AsusAuraCoreLaptop::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
 {
     controller->SetLedsDirect(buffer_map);
 }

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -23,10 +23,11 @@ public:
     ~RGBController_AsusAuraCoreLaptop();
 
     void                SetupZones();
+    void                ResizeZone(int zone, int new_size);
 
     void                DeviceUpdateLEDs();
-    void                DeviceUpdateZoneLEDs(int zone);
-    void                DeviceUpdateSingleLED(int led);
+    void                UpdateZoneLEDs(int zone);
+    void                UpdateSingleLED(int led);
 
     void                DeviceUpdateMode();
 

Controllers/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

@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
 #include "RGBController_AsusAuraGPU.h"
@@ -19,9 +19,17 @@
 
 #define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
 
+/******************************************************************************************\
+*                                                                                          *
+*   TestForAuraGPUController                                                               *
+*                                                                                          *
+*       Tests the given address to see if an Aura GPU controller exists there.             *
+*                                                                                          *
+\******************************************************************************************/
+
 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;
     }
@@ -40,26 +48,31 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 
     return(pass);
 
-}
+}   /* TestForAuraGPUController() */
 
-DetectedControllers DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraGPUControllers                                                               *
+*                                                                                          *
+*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-
     if(TestForAsusAuraGPUController(bus, i2c_addr))
     {
         AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr, name);
         RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
+} /* DetectAsusAuraGPUControllers() */
 
-    return(detected_controllers);
-}
+/*-----------------------------------------*\
+|  Nvidia GPUs                              |
+\*-----------------------------------------*/
 
-/*---------------------------------------------------------*\
-|  Nvidia GPUs                                              |
-\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
@@ -118,9 +131,10 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti A11G Gaming",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC,                 0x2A);
 
-/*---------------------------------------------------------*\
-|  AMD GPUs                                                 |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AMD GPUs                                 |
+\*-----------------------------------------*/
+
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ STRIX Radeon RX Vega 56 Gaming OC",           DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon Vega 64",                         DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 470 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -124,8 +124,6 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
 
 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -140,6 +138,7 @@ void RGBController_AuraGPU::SetupZones()
     aura_gpu_zone.leds_min      = 1;
     aura_gpu_zone.leds_max      = 1;
     aura_gpu_zone.leds_count    = 1;
+    aura_gpu_zone.matrix_map    = NULL;
     zones.push_back(aura_gpu_zone);
 
     /*---------------------------------------------------------*\
@@ -161,6 +160,13 @@ void RGBController_AuraGPU::SetupZones()
     colors[0] =  ToRGBColor(red, grn, blu);
 }
 
+void RGBController_AuraGPU::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AuraGPU::DeviceUpdateLEDs()
 {
     for(std::size_t led = 0; led < colors.size(); led++)
@@ -171,18 +177,18 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
 
         controller->SetLEDColors(red, grn, blu);
     }
-    if (controller->SaveOnlyApplies() && GetActiveMode() != 0)
+    if (controller->SaveOnlyApplies() && GetMode() != 0)
     {
         controller->Save();
     }
 }
 
-void RGBController_AuraGPU::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraGPU::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -112,8 +112,6 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -126,6 +124,7 @@ void RGBController_AuraHeadsetStand::SetupZones()
     underglow_zone.leds_min     = 17;
     underglow_zone.leds_max     = 17;
     underglow_zone.leds_count   = 17;
+    underglow_zone.matrix_map   = NULL;
 
     zones.push_back(underglow_zone);
 
@@ -145,6 +144,7 @@ void RGBController_AuraHeadsetStand::SetupZones()
     logo_zone.leds_min          = 1;
     logo_zone.leds_max          = 1;
     logo_zone.leds_count        = 1;
+    logo_zone.matrix_map        = NULL;
 
     zones.push_back(logo_zone);
 
@@ -157,17 +157,24 @@ void RGBController_AuraHeadsetStand::SetupZones()
     SetupColors();
 }
 
+void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
 {
     controller->UpdateLeds(std::vector<RGBColor>(colors));
 }
 
-void RGBController_AuraHeadsetStand::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraHeadsetStand::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.h

@@ -32,9 +32,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -380,7 +380,13 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
 
 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
-    Shutdown();
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
+        {
+            delete zones[zone_idx].matrix_map;
+        }
+    }
 
     delete controller;
 }
@@ -401,7 +407,7 @@ void RGBController_AuraKeyboard::SetupZones()
         \*-----------------------------------------------------*/
         case SCOPE_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&scope_matrix_map)});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
             led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -409,7 +415,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case SCOPE_RX_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&scope_matrix_map)});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
             led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
 
             led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
@@ -419,7 +425,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case SCOPE_TKL_LAYOUT:
             led_names = default_tkl_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type(6, 18, (unsigned int *)&scope_tkl_matrix_map)});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
             led_zones.push_back({"Logo",                ZONE_TYPE_LINEAR, 2, NULL});
             led_zones.push_back({"Underglow",           ZONE_TYPE_LINEAR, 26, NULL});
 
@@ -429,7 +435,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case FLARE_LAYOUT:
             led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&flare_matrix_map)});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
             led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
             led_zones.push_back({"Underglow",           ZONE_TYPE_SINGLE, 2, NULL});
 
@@ -443,7 +449,7 @@ void RGBController_AuraKeyboard::SetupZones()
 
         case FALCHION_LAYOUT:
             led_names = default_65pct_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type(5, 16, (unsigned int *)&falchion_matrix_map)});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
             break;
     }
 
@@ -457,9 +463,13 @@ void RGBController_AuraKeyboard::SetupZones()
         new_zone.leds_max               = led_zones[zone_idx].size;
         new_zone.leds_count             = led_zones[zone_idx].size;
 
-        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX && led_zones[zone_idx].matrix != NULL)
+        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
         {
-            new_zone.matrix_map         = *led_zones[zone_idx].matrix;
+            new_zone.matrix_map         = led_zones[zone_idx].matrix;
+        }
+        else
+        {
+            new_zone.matrix_map         = NULL;
         }
 
         zones.push_back(new_zone);
@@ -479,6 +489,13 @@ void RGBController_AuraKeyboard::SetupZones()
     SetupColors();
 }
 
+void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AuraKeyboard::DeviceUpdateLEDs()
 {
     std::vector<unsigned char> frame_buf;
@@ -502,12 +519,12 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
     controller->SendDirect((unsigned char)leds.size(), frame_buf.data());
 }
 
-void RGBController_AuraKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraKeyboard::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h

@@ -45,9 +45,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -45,8 +45,6 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 
 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -59,6 +57,7 @@ void RGBController_AuraMonitor::SetupZones()
     underglow_zone.leds_min     = 3;
     underglow_zone.leds_max     = 3;
     underglow_zone.leds_count   = 3;
+    underglow_zone.matrix_map   = NULL;
 
     zones.push_back(underglow_zone);
 
@@ -74,6 +73,13 @@ void RGBController_AuraMonitor::SetupZones()
     SetupColors();
 }
 
+void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AuraMonitor::DeviceUpdateLEDs()
 {
     controller->BeginUpdate();
@@ -90,12 +96,12 @@ void RGBController_AuraMonitor::DeviceUpdateLEDs()
     controller->ApplyChanges();
 }
 
-void RGBController_AuraMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMonitor::DeviceUpdateSingleLED(int led)
+void RGBController_AuraMonitor::UpdateSingleLED(int led)
 {
     controller->BeginUpdate();
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseDevices.h

@@ -22,6 +22,7 @@
 #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
@@ -217,6 +218,20 @@ 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;
 }
 
@@ -201,6 +199,7 @@ void RGBController_AuraMouse::SetupZones()
         mouse_zone.leds_min     = 1;
         mouse_zone.leds_max     = 1;
         mouse_zone.leds_count   = 1;
+        mouse_zone.matrix_map   = NULL;
 
         zones.push_back(mouse_zone);
 
@@ -215,6 +214,11 @@ void RGBController_AuraMouse::SetupZones()
     SetupColors();
 }
 
+void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
@@ -225,17 +229,17 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
     {
         for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
         {
-            DeviceUpdateSingleLED(zone_index);
+            UpdateSingleLED(zone_index);
         }
     }
 }
 
-void RGBController_AuraMouse::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMouse::DeviceUpdateSingleLED(int led)
+void RGBController_AuraMouse::UpdateSingleLED(int led)
 {
     if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
     {

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -116,8 +116,6 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 
 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -135,6 +133,7 @@ void RGBController_AsusROGSpatha::SetupZones()
         spatha_zone.leds_min     = 1;
         spatha_zone.leds_max     = 1;
         spatha_zone.leds_count   = 1;
+        spatha_zone.matrix_map   = NULL;
 
         zones.push_back(spatha_zone);
 
@@ -149,6 +148,11 @@ void RGBController_AsusROGSpatha::SetupZones()
     SetupColors();
 }
 
+void RGBController_AsusROGSpatha::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
 void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
@@ -157,13 +161,13 @@ void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
     }
     else
     {
-        DeviceUpdateSingleLED(0);
-        DeviceUpdateSingleLED(1);
-        DeviceUpdateSingleLED(2);
+        UpdateSingleLED(0);
+        UpdateSingleLED(1);
+        UpdateSingleLED(2);
     }
 }
 
-void RGBController_AsusROGSpatha::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
 {
     if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
     {
@@ -171,11 +175,11 @@ void RGBController_AsusROGSpatha::DeviceUpdateZoneLEDs(int zone)
     }
     else
     {
-        DeviceUpdateSingleLED(zone);
+        UpdateSingleLED(zone);
     }
 }
 
-void RGBController_AsusROGSpatha::DeviceUpdateSingleLED(int led)
+void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
 {
     if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
     {

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.h

@@ -40,9 +40,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -79,8 +79,6 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 
 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -93,6 +91,7 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     mouse_zone.leds_min     = 1;
     mouse_zone.leds_max     = 1;
     mouse_zone.leds_count   = 1;
+    mouse_zone.matrix_map   = NULL;
 
     zones.push_back(mouse_zone);
 
@@ -106,17 +105,22 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     SetupColors();
 }
 
+void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
 void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
 {
-    DeviceUpdateSingleLED(0);
+    UpdateSingleLED(0);
 }
 
-void RGBController_AsusROGStrixEvolve::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
 {
-    DeviceUpdateSingleLED(zone);
+    UpdateSingleLED(zone);
 }
 
-void RGBController_AsusROGStrixEvolve::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int /*led*/)
 {
     controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
     controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.h

@@ -37,9 +37,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -182,8 +182,6 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 
 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -196,6 +194,7 @@ void RGBController_AuraMousemat::SetupZones()
     mousemat_zone.leds_min     = 15;
     mousemat_zone.leds_max     = 15;
     mousemat_zone.leds_count   = 15;
+    mousemat_zone.matrix_map   = NULL;
 
     zones.push_back(mousemat_zone);
 
@@ -211,17 +210,24 @@ void RGBController_AuraMousemat::SetupZones()
     SetupColors();
 }
 
+void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AuraMousemat::DeviceUpdateLEDs()
 {
     controller->UpdateLeds(std::vector<RGBColor>(colors));
 }
 
-void RGBController_AuraMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMousemat::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.h

@@ -40,9 +40,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -128,8 +128,6 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
 
 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -173,22 +171,29 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()
     SetupColors();
 }
 
+void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
 {
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        DeviceUpdateZoneLEDs(zone_idx);
+        UpdateZoneLEDs(zone_idx);
     }
 }
 
-void RGBController_AsusAuraRyuoAIO::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
 {
     controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
 }
 
-void RGBController_AsusAuraRyuoAIO::DeviceUpdateSingleLED(int led)
+void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
 {
-    DeviceUpdateZoneLEDs(GetLED_Zone(led));
+    UpdateZoneLEDs(GetLED_Zone(led));
 }
 
 void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.h

@@ -24,10 +24,11 @@ public:
     ~RGBController_AsusAuraRyuoAIO();
 
     void SetupZones();
+    void ResizeZone(int zone, int new_size);
 
     void DeviceUpdateLEDs();
-    void DeviceUpdateZoneLEDs(int zone);
-    void DeviceUpdateSingleLED(int led);
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
 
     void DeviceUpdateMode();
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -410,8 +410,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
 RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -513,7 +511,10 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     keyboard_zone.leds_min           = keyboard[layout].size;
     keyboard_zone.leds_max           = keyboard[layout].size;
     keyboard_zone.leds_count         = keyboard[layout].size;
-    keyboard_zone.matrix_map.Set(keyboard[layout].rows, keyboard[layout].cols, keyboard[layout].matrix_map);
+    keyboard_zone.matrix_map         = new matrix_map_type;
+    keyboard_zone.matrix_map->height = keyboard[layout].rows;
+    keyboard_zone.matrix_map->width  = keyboard[layout].cols;
+    keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
     zones.push_back(keyboard_zone);
 
     for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
@@ -532,6 +533,11 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     DeviceUpdateMode();
 }
 
+void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
 void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
     std::vector<led_color> led_color_list = {};
@@ -544,12 +550,12 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
     controller->UpdateLeds(led_color_list);
 }
 
-void RGBController_AuraTUFKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraTUFKeyboard::DeviceUpdateSingleLED(int led)
+void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
 {
     if(!controller->is_per_led_keyboard)
     {

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

@@ -43,9 +43,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();

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,22 +189,30 @@ void RGBController_AuraUSB::SetupZones()
             {
                 new_led.name.append(", LED ");
             }
-
             new_led.name.append(std::to_string(led_idx));
 
             new_led.value = channel_idx;
 
             leds.push_back(new_led);
         }
+
+        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
 }
 
-void RGBController_AuraUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_AuraUSB::ResizeZone(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();
     }
 }
@@ -250,7 +229,7 @@ void RGBController_AuraUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraUSB::DeviceUpdateZoneLEDs(int zone)
+void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
 {
     if(!initializedMode)
     {
@@ -260,7 +239,7 @@ void RGBController_AuraUSB::DeviceUpdateZoneLEDs(int zone)
     controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
 }
 
-void RGBController_AuraUSB::DeviceUpdateSingleLED(int led)
+void RGBController_AuraUSB::UpdateSingleLED(int led)
 {
     if(!initializedMode)
     {

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -24,11 +24,11 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -9,7 +9,7 @@
 
 #include <stdexcept>
 #include <hidapi.h>
-#include "DetectionManager.h"
+#include "Detector.h"
 #include "AsusAuraAddressableController.h"
 #include "AsusAuraHeadsetStandController.h"
 #include "AsusAuraKeyboardController.h"
@@ -144,30 +144,22 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
     }
 }
 
-DetectedControllers DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, name);
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
+void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -175,18 +167,13 @@ DetectedControllers DetectAsusAuraUSBAddressable(hid_device_info* info, const st
         AuraAddressableController* controller               = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
         RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
+void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -196,7 +183,7 @@ DetectedControllers DetectAsusAuraUSBMotherboards(hid_device_info* info, const s
             AuraMainboardController*     controller         = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
             RGBController_AuraMainboard* rgb_controller     = new RGBController_AuraMainboard(controller);
 
-            detected_controllers.push_back(rgb_controller);
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
         catch(const std::runtime_error& ex)
         {
@@ -204,16 +191,11 @@ DetectedControllers DetectAsusAuraUSBMotherboards(hid_device_info* info, const s
             LOG_ERROR("[AsusAuraUSB] An error occured while reading the config table: %s", ex.what());
         }
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -221,18 +203,13 @@ DetectedControllers DetectAsusAuraUSBKeyboards(hid_device_info* info, const std:
         AuraKeyboardMappingLayoutType layout                = GetKeyboardMappingLayoutType(info->product_id);
         RGBController_AuraKeyboard*   rgb_controller        = new RGBController_AuraKeyboard(controller, layout);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
@@ -240,172 +217,125 @@ DetectedControllers DetectAsusAuraUSBMice(hid_device_info* info, const std::stri
         AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, pid, name);
         RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraMousematController*     controller              = new AuraMousematController(dev, info->path, name);
         RGBController_AuraMousemat* rgb_controller          = new RGBController_AuraMousemat(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AsusROGStrixLCController*     controller     = new AsusROGStrixLCController(dev, info->path, name);
         RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraRyuoAIOController*     controller     = new AsusAuraRyuoAIOController(dev, info->path, name);
+        AsusAuraRyuoAIOController* controller         = new AsusAuraRyuoAIOController(dev, info->path, name);
         RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller*      controller        = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
         RGBController_AsusROGStrixEvolve* rgb_controller    = new RGBController_AsusROGStrixEvolve(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
-        AsusAuraMouseGen1Controller* controller     = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
-        RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller);
+        AsusAuraMouseGen1Controller*     controller         = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
+        RGBController_AsusROGSpatha* rgb_controller         = new RGBController_AsusROGSpatha(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path, name);
         RGBController_AuraHeadsetStand* rgb_controller      = new RGBController_AuraHeadsetStand(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
+void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
         RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
+void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path, info->product_id, name);
         RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
-DetectedControllers DetectAsusROGAlly(hid_device_info* info, const std::string& name)
+void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
 {
-    DetectedControllers detected_controllers;
-    hid_device*         dev;
-
-    dev = hid_open_path(info->path);
+    hid_device* dev = hid_open_path(info->path);
 
     if(dev)
     {
         ROGAllyController*         controller           = new ROGAllyController(dev, info->path, name);
         RGBController_AsusROGAlly* rgb_controller       = new RGBController_AsusROGAlly(controller);
 
-        detected_controllers.push_back(rgb_controller);
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
-
-    return(detected_controllers);
 }
 
 /*-----------------------------------------------------------------*\
@@ -464,6 +394,7 @@ 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);

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -117,8 +117,6 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 
 RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -131,6 +129,7 @@ void RGBController_AsusROGAlly::SetupZones()
     left_stick_zone.leds_min     = 2;
     left_stick_zone.leds_max     = 2;
     left_stick_zone.leds_count   = 2;
+    left_stick_zone.matrix_map   = NULL;
 
     zones.push_back(left_stick_zone);
 
@@ -150,6 +149,7 @@ void RGBController_AsusROGAlly::SetupZones()
     right_stick_zone.leds_min     = 2;
     right_stick_zone.leds_max     = 2;
     right_stick_zone.leds_count   = 2;
+    right_stick_zone.matrix_map   = NULL;
 
     zones.push_back(right_stick_zone);
 
@@ -165,6 +165,13 @@ void RGBController_AsusROGAlly::SetupZones()
     SetupColors();
 }
 
+void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_AsusROGAlly::DeviceUpdateLEDs()
 {
     if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
@@ -173,12 +180,12 @@ void RGBController_AsusROGAlly::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AsusROGAlly::DeviceUpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AsusROGAlly::DeviceUpdateSingleLED(int /*led*/)
+void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.h

@@ -22,9 +22,11 @@ public:
 
     void        SetupZones();
 
+    void        ResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
-    void        DeviceUpdateZoneLEDs(int zone);
-    void        DeviceUpdateSingleLED(int led);
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
     void        DeviceSaveMode();