DetectionManager fixes and optimizations

* Add JSON string configuration field to RGBController to store device-specific configurations
    * This JSON string holds both configuration and schema
    * Add settings schema tracking to SettingsManager
    * Implement dynamic settings widget that generates a settings UI based on a JSON schema
    * Implement SettingsManager callback for notifying of settings changes and settings schema updates
    * Always enable Entire Device zone option and use it to enable Edit Device
    * Rename SaveSizes to SaveConfiguration in ProfileManager and Sizes.json to Configuration.json
    * Add zone flag for indicating that a zone's geometry may change, informing profile manager to ignore this check
    * Remove Theme setting and Theme Manager, as this didn't work on most setups anyways and Qt6 has proper Windows dark theming

.gitlab-ci.yml

@@ -100,19 +100,19 @@ before_script:
 "Linux i386 AppImage":
   variables:
     TGT_ARCH: "i386"
-    TGT_QT: ""
+    TGT_QT: "qt6"
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 i386 Build Target                    #
+# Linux (AppImage) Qt5 i386 Build Target                    #
 #-----------------------------------------------------------#
-"Linux i386 AppImage Qt6":
+"Linux i386 AppImage Qt5":
   variables:
     TGT_ARCH: "i386"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -122,7 +122,7 @@ before_script:
 "Linux amd64 AppImage":
   variables:
     TGT_ARCH: "amd64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "x86_64"
   <<: *appimage_script_steps
@@ -137,13 +137,13 @@ before_script:
   - "saas-linux-small-amd64"
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 amd64 Build Target                   #
+# Linux (AppImage) Qt5 amd64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux amd64 AppImage Qt6":
+"Linux amd64 AppImage Qt5":
   variables:
     TGT_ARCH: "amd64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
     TGT_PATH: "x86_64"
   <<: *appimage_script_steps
 
@@ -153,19 +153,19 @@ before_script:
 "Linux armhf AppImage":
   variables:
     TGT_ARCH: "armhf"
-    TGT_QT: ""
+    TGT_QT: "qt6"
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 armhf Build Target                   #
+# Linux (AppImage) Qt5 armhf Build Target                   #
 #-----------------------------------------------------------#
-"Linux armhf AppImage Qt6":
+"Linux armhf AppImage Qt5":
   variables:
     TGT_ARCH: "armhf"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -175,19 +175,19 @@ before_script:
 "Linux arm64 AppImage":
   variables:
     TGT_ARCH: "arm64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
     TGT_NAME: "${TGT_ARCH}"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 arm64 Build Target                   #
+# Linux (AppImage) Qt5 arm64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux arm64 AppImage Qt6":
+"Linux arm64 AppImage Qt5":
   variables:
     TGT_ARCH: "arm64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
     TGT_PATH: "${TGT_ARCH}"
   <<: *appimage_script_steps
 
@@ -296,7 +296,10 @@ before_script:
   image: fedora:43
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
+  - 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
   - rpmdev-setuptree
   - ./scripts/build-package-files.sh fedora/OpenRGB.spec
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
@@ -324,10 +327,14 @@ before_script:
   image: i386/debian:bookworm
   stage: test
   script:
-  - apt update
+  - 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
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
   - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
   dependencies:
   - "Linux i386 .deb (Debian Bookworm)"
   needs:
@@ -342,10 +349,14 @@ before_script:
   image: amd64/debian:bookworm
   stage: test
   script:
-  - apt update
+  - 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
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
   dependencies:
   - "Linux amd64 .deb (Debian Bookworm)"
   needs:
@@ -360,10 +371,14 @@ before_script:
   image: ubuntu:noble
   stage: test
   script:
-  - apt update
+  - 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
   - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
   - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
   dependencies:
   - "Linux amd64 .deb (Debian Bookworm)"
   needs:
@@ -378,6 +393,10 @@ 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
@@ -397,7 +416,7 @@ before_script:
   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_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -410,17 +429,17 @@ before_script:
     - !reference [.upstream_rules, rules]
 
 #-----------------------------------------------------------#
-# Windows (32-bit) Qt6 Build Target                         #
+# Windows (32-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 32 Qt6":
+"Windows 32 Qt5":
   extends:
   - .shared_windows_runners
   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_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_32_Qt5_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 32-bit'
     exclude:
@@ -439,7 +458,7 @@ before_script:
   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_${CI_COMMIT_SHORT_SHA}"
     paths:
@@ -470,17 +489,17 @@ before_script:
   - "saas-windows-medium-amd64"
 
 #-----------------------------------------------------------#
-# Windows (64-bit) Qt6 Build Target                         #
+# Windows (64-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 64 Qt6 Base":
+"Windows 64 Qt5 Base":
   extends:
   - .shared_windows_runners
   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_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_64_Qt5_${CI_COMMIT_SHORT_SHA}"
     paths:
     - 'OpenRGB Windows 64-bit'
     exclude:
@@ -491,13 +510,14 @@ before_script:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
       when: never
 
-"Windows 64 Qt6":
-  extends: "Windows 64 Qt6 Base"
+
+"Windows 64 Qt5":
+  extends: "Windows 64 Qt5 Base"
   rules:
   - !reference [.upstream_rules, rules]
 
-"Windows 64 Qt6 (Downstream)":
-  extends: "Windows 64 Qt6 Base"
+"Windows 64 Qt5 (Downstream)":
+  extends: "Windows 64 Qt5 Base"
   before_script:
     - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
     - cd OpenRGB-Qt-Packages
@@ -516,7 +536,7 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 arm
+  - ./scripts/build-macos.sh qt6 arm
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -527,15 +547,15 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS ARM64 Qt6":
+"MacOS ARM64 Qt5":
   tags:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 arm
+  - ./scripts/build-macos.sh qt5 arm
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days
@@ -548,7 +568,7 @@ before_script:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt5 intel
+  - ./scripts/build-macos.sh qt6 intel
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -559,15 +579,15 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS Intel Qt6":
+"MacOS Intel Qt5":
   tags:
   - macos
   stage: build
   script:
-  - ./scripts/build-macos.sh qt6 intel
+  - ./scripts/build-macos.sh qt5 intel
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB.app
     expire_in: 30 days

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -10,47 +10,52 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-/*-----------------------------------------------------*\
-| OpenRGB includes                                      |
-\*-----------------------------------------------------*/
 #include <hidapi.h>
-#include "Detector.h"
-
-/*-----------------------------------------------------*\
-| A4 Tech specific includes                             |
-\*-----------------------------------------------------*/
-#include "RGBController_BloodyMouse.h"
+#include "BloodyB820RController.h"
+#include "BloodyMouseController.h"
+#include "DetectionManager.h"
 #include "RGBController_BloodyB820R.h"
+#include "RGBController_BloodyMouse.h"
 
-/*-----------------------------------------------------*\
-| A4 Tech USB vendor ID                                 |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| A4 Tech USB vendor ID                                     |
+\*---------------------------------------------------------*/
 #define A4_TECH_VID                                 0x09DA
 
-void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectA4TechMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    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);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectBloodyB820R(hid_device_info* info, const std::string& name)
+DetectedControllers DetectBloodyB820R(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
         RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +173,8 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 
 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -187,11 +189,7 @@ 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          = 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;
+    KB_zone.matrix_map.Set(6, 21, (unsigned int *)&matrix_map);
     zones.push_back(KB_zone);
 
     /*-------------------------------------------------*\
@@ -214,20 +212,12 @@ 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::UpdateZoneLEDs(int zone)
+void RGBController_BloodyB820R::DeviceUpdateZoneLEDs(int zone)
 {
     std::vector<RGBColor> colour;
 
@@ -239,7 +229,7 @@ void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
     controller->SetLEDDirect(colour);
 }
 
-void RGBController_BloodyB820R::UpdateSingleLED(int led)
+void RGBController_BloodyB820R::DeviceUpdateSingleLED(int led)
 {
     std::vector<RGBColor> colour;
     colour.push_back(colors[led]);

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.h

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

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -89,6 +89,8 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
 
 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -134,7 +136,6 @@ 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++)
@@ -160,13 +161,6 @@ 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;
@@ -179,12 +173,12 @@ void RGBController_BloodyMouse::DeviceUpdateLEDs()
     controller->SetLedsDirect(colour);
 }
 
-void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_BloodyMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
+void RGBController_BloodyMouse::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -30,11 +30,10 @@ public:
     ~RGBController_BloodyMouse();
 
     void                    SetupZones();
-    void                    ResizeZone(int zone, int new_size);
 
     void                    DeviceUpdateLEDs();
-    void                    UpdateZoneLEDs(int zone);
-    void                    UpdateSingleLED(int led);
+    void                    DeviceUpdateZoneLEDs(int zone);
+    void                    DeviceUpdateSingleLED(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,66 +18,60 @@
 #include <libusb.h>
 #endif
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMBXControllers                                                                  *
-*                                                                                          *
-*       Detect Philips amBX Gaming devices                                                 *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMBXControllers()
+DetectedControllers DetectAMBXControllers()
 {
-    libusb_context* ctx = NULL;
+    DetectedControllers detected_controllers;
+    libusb_context*     ctx = NULL;
 
-    if(libusb_init(&ctx) < 0)
+    if(libusb_init(&ctx) >= 0)
     {
-        return;
-    }
+        libusb_device** devs;
+        ssize_t num_devs = libusb_get_device_list(ctx, &devs);
 
-    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)
+        if(num_devs > 0)
         {
-            continue;
+            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);
         }
-
-        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
+        else
         {
-            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;
-            }
+            libusb_exit(ctx);
         }
     }
 
-    libusb_free_device_list(devs, 1);
-    libusb_exit(ctx);
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -44,6 +44,8 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
 
 RGBController_AMBX::~RGBController_AMBX()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -56,7 +58,6 @@ 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;
@@ -65,7 +66,6 @@ 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,11 +97,6 @@ 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())
@@ -121,7 +116,7 @@ void RGBController_AMBX::DeviceUpdateLEDs()
     controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
 }
 
-void RGBController_AMBX::UpdateZoneLEDs(int zone)
+void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
 {
     if(!controller->IsInitialized())
     {
@@ -156,7 +151,7 @@ void RGBController_AMBX::UpdateZoneLEDs(int zone)
     controller->SetLEDColors(led_values, led_colors, zone_size);
 }
 
-void RGBController_AMBX::UpdateSingleLED(int led)
+void RGBController_AMBX::DeviceUpdateSingleLED(int led)
 {
     if(!controller->IsInitialized())
     {

Controllers/AMBXController/RGBController_AMBX.h

@@ -19,11 +19,10 @@ public:
     ~RGBController_AMBX();
 
     void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(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,25 +24,22 @@
 \*---------------------------------------------------------*/
 #define AMD_WRAITH_PRISM_PID                        0x0051
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMDWraithPrismControllers                                                        *
-*                                                                                          *
-*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
         RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +132,8 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -154,7 +156,6 @@ 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;
@@ -163,7 +164,6 @@ 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,7 +172,6 @@ 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);
 
     /*-----------------------------------------------------*\
@@ -205,13 +204,6 @@ 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)
@@ -271,12 +263,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AMDWraithPrism::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
+void RGBController_AMDWraithPrism::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -22,11 +22,9 @@ public:
 
     void        SetupZones();
 
-    void        ResizeZone(int zone, int new_size);
-
     void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(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,36 +9,33 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.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
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCKeyboardControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Keyboard controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
         RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,35 +257,25 @@ 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;
-
-    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);
+    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);
 
     /*---------------------------------------------------------*\
     | Create LEDs for the Matrix zone                           |
@@ -305,13 +295,6 @@ 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)
@@ -331,12 +314,12 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AOCKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -22,11 +22,9 @@ public:
 
     void        SetupZones();
 
-    void        ResizeZone(int zone, int new_size);
-
     void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(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,35 +9,32 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AOCMouseController.h"
 #include "RGBController_AOCMouse.h"
 
-/*-----------------------------------------------------*\
-| AOC Mouse IDs                                         |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AOC Mouse IDs                                             |
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMouseControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mouse controller exists there.              *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
         RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +123,8 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -134,7 +136,6 @@ 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;
@@ -147,7 +148,6 @@ 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,24 +157,17 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMouse::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -22,11 +22,9 @@ public:
 
     void        SetupZones();
 
-    void        ResizeZone(int zone, int new_size);
-
     void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(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,35 +9,32 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AOCMousematController.h"
 #include "RGBController_AOCMousemat.h"
 
-/*-----------------------------------------------------*\
-| AOC Mousemat IDs                                      |
-\*-----------------------------------------------------*/
+/*---------------------------------------------------------*\
+| AOC Mousemat IDs                                          |
+\*---------------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_AMM700_PID                              0x1162
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAOCMousematControllers                                                           *
-*                                                                                          *
-*       Tests the USB address to see if an AOC Mousemat controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
         RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +113,8 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -124,7 +126,6 @@ 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;
@@ -134,24 +135,17 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMousemat::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AOCMousematController/RGBController_AOCMousemat.h

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

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -11,12 +11,12 @@
 \*---------------------------------------------------------*/
 
 #include <cstring>
-#include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dmiinfo.h"
+#include "ResourceManager.h"
+#include "RGBController.h"
+#include "SettingsManager.h"
+#include "StringUtils.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::ResizeZone(int zone, int new_size)
+void PolychromeUSBController::SetZoneSize(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                                        ResizeZone(int zone, int new_size);
+    void                                        SetZoneSize(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,16 +26,22 @@
 #define ASROCK_MOTHERBOARD_1_PID                    0x01A2
 #define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
 
-void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
         RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -185,8 +185,25 @@ 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        |
     \*-------------------------------------------------*/
@@ -197,40 +214,65 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(std::size_t 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].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;
+            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);
+            }
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            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;
+            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;
         }
 
-
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
             new_led.name = zones[channel_idx].name;
             new_led.name.append(", LED ");
             new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = channel_idx;
+            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
         }
-
-        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
@@ -273,10 +315,14 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
+void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
 {
-    zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+    if((size_t)zone_idx < zones.size())
+    {
+        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
+
+        SetupZones();
+    }
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -299,7 +345,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
+void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
     unsigned char set_mode=zones_info[zone].mode;
 
@@ -311,7 +357,7 @@ void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
     controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
 }
 
-void RGBController_PolychromeUSB::UpdateSingleLED(int led)
+void RGBController_PolychromeUSB::DeviceUpdateSingleLED(int led)
 {
     unsigned int  channel  = leds[led].value;
     unsigned char set_mode = zones_info[channel].mode;

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

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

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/ASRockASRRGBSMBusController.cpp

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

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -113,6 +113,8 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB
 
 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -135,7 +137,6 @@ 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                             |
@@ -160,27 +161,20 @@ 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++)
     {
-        UpdateSingleLED(led);
+        DeviceUpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockASRRGBSMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
+void RGBController_ASRockASRRGBSMBus::DeviceUpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

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

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/ASRockPolychromeV1SMBusController.cpp

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

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -230,6 +230,8 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -267,7 +269,6 @@ 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)
             {
@@ -297,10 +298,9 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
 {
-    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
-    controller-> SetARGBSize(new_size & 0xFF);
+    controller-> SetARGBSize(zones[zone_idx].leds_count & 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++)
     {
-        UpdateSingleLED(zone_idx);
+        DeviceUpdateSingleLED(zone_idx);
     }
 }
 
-void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
-    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
+    LOG_TRACE("[%s] DeviceUpdateZoneLEDs()", name.c_str());
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateSingleLED(int zone)
 {
-    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
+    LOG_TRACE("[%s] DeviceUpdateSingleLED(%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);
-            UpdateSingleLED(zone_idx);
+            DeviceUpdateSingleLED(zone_idx);
         }
     }
     else

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

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

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/ASRockPolychromeV2SMBusController.cpp

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

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -185,6 +185,8 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR
 
 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -229,8 +231,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_zone->type          = ZONE_TYPE_SINGLE;
             }
 
-            new_zone->matrix_map        = NULL;
-
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/
@@ -238,7 +238,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
         }
     }
 
-    unsigned int led_count = 0;
     /*---------------------------------------------------------*\
     | Set up LEDs                                               |
     \*---------------------------------------------------------*/
@@ -268,8 +267,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 \*---------------------------------------------------------*/
                 leds.push_back(*new_led);
 
-                led_count++;
-
                 if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                 {
                     break;
@@ -281,7 +278,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -292,16 +289,16 @@ void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)
     {
-        UpdateSingleLED(led);
+        DeviceUpdateSingleLED(led);
     }
 }
 
-void RGBController_ASRockPolychromeV2SMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
+void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateSingleLED(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        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);
 
     void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -11,7 +11,7 @@
 \*---------------------------------------------------------*/
 
 #include <vector>
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
@@ -22,15 +22,6 @@
 #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
@@ -67,7 +58,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)
 
     return(pass);
 
-}   /* TestForPolychromeController() */
+}
 
 uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
 {
@@ -94,64 +85,54 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-/******************************************************************************************\
-*                                                                                          *
-*   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                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
 {
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    DetectedControllers detected_controllers;
+
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
     {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
         {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(buses[bus]->info.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(busses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(buses[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(busses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(buses[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(busses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
                             case ASROCK_TYPE_POLYCHROME_V1:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
                             case ASROCK_TYPE_POLYCHROME_V2:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                             }
                             break;
 
@@ -172,6 +153,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
         }
     }
 
-}   /* DetectSMBusPolychromeControllers() */
+    return(detected_controllers);
+}
 
 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,17 +22,22 @@
 #define ALIENWARE_G_SERIES_PID1                      0x0550
 #define ALIENWARE_G_SERIES_PID2                      0x0551
 
-void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareController*     controller     = new AlienwareController(dev, *info, name);
         RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +125,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     controller->UpdateDim();
 }
 
+RGBController_Alienware::~RGBController_Alienware()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_Alienware::SetupZones()
 {
     /*-------------------------------------------------*\
@@ -141,7 +148,6 @@ 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);
     }
@@ -158,26 +164,19 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Alienware::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_Alienware::UpdateSingleLED(int led)
+void RGBController_Alienware::DeviceUpdateSingleLED(int led)
 {
-    UpdateZoneLEDs(led);
+    DeviceUpdateZoneLEDs(led);
 }
 
 static bool modes_eq(const mode& mode1, const mode& mode2)

Controllers/AlienwareController/RGBController_Alienware.h

@@ -19,14 +19,13 @@ 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        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.h

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

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -278,16 +278,7 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 
 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    /*---------------------------------------------------------*\
-    | 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;
-        }
-    }
+    Shutdown();
 
     delete controller;
 }
@@ -310,14 +301,7 @@ void RGBController_AlienwareAW410K::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            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;
+            new_zone.matrix_map.Set(6, 24, (unsigned int *)&matrix_map);
         }
 
         zones.push_back(new_zone);
@@ -336,13 +320,6 @@ 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;
@@ -374,21 +351,21 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
     std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }
 
-void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(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::UpdateSingleLED(int led)
+void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW410K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)
     {
-        UpdateLEDs();
+        UpdateLEDsInternal();
         return;
     }
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.cpp

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.h

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

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -277,16 +277,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 
 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    /*---------------------------------------------------------*\
-    | 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;
-        }
-    }
+    Shutdown();
 
     delete controller;
 }
@@ -309,14 +300,7 @@ void RGBController_AlienwareAW510K::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            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;
+            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
         }
 
         zones.push_back(new_zone);
@@ -335,13 +319,6 @@ 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;
@@ -395,21 +372,21 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
     std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }
 
-void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW510K::DeviceUpdateZoneLEDs(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::UpdateSingleLED(int led)
+void RGBController_AlienwareAW510K::DeviceUpdateSingleLED(int led)
 {
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }
 
 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
     if(active_mode == 0xFFFF)
     {
-        UpdateLEDs();
+        UpdateLEDsInternal();
         return;
     }
 

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

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

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -8,55 +8,58 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "Detector.h"
-#include "AlienwareAW510KController.h"
+#include "DetectionManager.h"
 #include "AlienwareAW410KController.h"
-#include "RGBController_AlienwareAW510K.h"
+#include "AlienwareAW510KController.h"
 #include "RGBController_AlienwareAW410K.h"
+#include "RGBController_AlienwareAW510K.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
 
-/******************************************************************************************\
-*                                                                                          *
-*   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 DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path, name);
         RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareAW410KControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
+    if(dev)
     {
         AlienwareAW410KController*     controller     = new AlienwareAW410KController(dev, info->path, name);
         RGBController_AlienwareAW410K* rgb_controller = new RGBController_AlienwareAW410K(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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 "Detector.h"
+#include <hidapi.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,37 +29,40 @@
 #define ALIENWARE_USAGE_PAGE                        0xFFDA
 #define ALIENWARE_USAGE                             0x00DA
 
-/******************************************************************************************\
-*                                                                                          *
-*   AlienwareAW3423DWFControllerDetect                                                     *
-*                                                                                          *
-*       Tests the USB address to see if an Alienware AW3423DWF exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAlienwareAW3423DWFControllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
+
     if(dev)
     {
         AlienwareAW3423DWFController*     controller     = new AlienwareAW3423DWFController(dev, info->path);
         RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path, name);
         RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -46,6 +46,8 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34
 
 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -57,7 +59,6 @@ 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;
@@ -71,7 +72,6 @@ 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,7 +85,6 @@ 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;
@@ -96,10 +95,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     SetupColors();
 }
 
-void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-}
-
 void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -118,17 +113,17 @@ void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
         }
     }
 }
 
-void RGBController_AlienwareAW3423DWF::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareAW3423DWF::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AlienwareAW3423DWF::UpdateSingleLED(int led)
+void RGBController_AlienwareAW3423DWF::DeviceUpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.h

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

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -46,6 +46,8 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC
 
 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -57,7 +59,6 @@ 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;
@@ -71,7 +72,6 @@ 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,7 +85,6 @@ 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;
@@ -96,11 +95,6 @@ void RGBController_AlienwareMonitor::SetupZones()
     SetupColors();
 }
 
-void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -119,17 +113,17 @@ void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
         }
     }
 }
 
-void RGBController_AlienwareMonitor::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AlienwareMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AlienwareMonitor::UpdateSingleLED(int led)
+void RGBController_AlienwareMonitor::DeviceUpdateSingleLED(int led)
 {
     unsigned char red = RGBGetRValue(colors[led]);
     unsigned char grn = RGBGetGValue(colors[led]);

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.h

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

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -9,10 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
-#include "AnnePro2Controller.h"
-#include "RGBController_AnnePro2.h"
 #include <hidapi.h>
+#include "AnnePro2Controller.h"
+#include "DetectionManager.h"
+#include "RGBController_AnnePro2.h"
 
 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -29,25 +29,22 @@
 #define ANNE_PRO_2_PID_4                            0xA293
 #define ANNE_PRO_2_PID_5                            0xA297
 
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAnnePro2Controllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
+DetectedControllers DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
         RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +144,8 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
 
 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -164,14 +166,7 @@ void RGBController_AnnePro2::SetupZones()
 
         if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
         {
-            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;
+            new_zone.matrix_map.Set(5, 14, (unsigned int *)&matrix_map);
         }
 
         zones.push_back(new_zone);
@@ -190,13 +185,6 @@ 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;
@@ -228,12 +216,12 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
     controller->SendDirect(frame_buf_length, frame_buf);
 }
 
-void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AnnePro2::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
+void RGBController_AnnePro2::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AnnePro2Controller/RGBController_AnnePro2.h

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

Controllers/ArcticController/ArcticControllerDetect.cpp

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

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -55,6 +55,8 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
 
 RGBController_Arctic::~RGBController_Arctic()
 {
+    Shutdown();
+
     keepalive_thread_run = false;
     keepalive_thread.join();
     delete controller;
@@ -70,7 +72,6 @@ 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";
@@ -83,13 +84,6 @@ 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();
@@ -97,12 +91,12 @@ void RGBController_Arctic::DeviceUpdateLEDs()
     controller->SetChannels(colors);
 }
 
-void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
+void RGBController_Arctic::DeviceUpdateZoneLEDs(int /* zone */)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_Arctic::UpdateSingleLED(int /* led */)
+void RGBController_Arctic::DeviceUpdateSingleLED(int /* led */)
 {
     DeviceUpdateLEDs();
 }
@@ -123,7 +117,7 @@ void RGBController_Arctic::KeepaliveThreadFunction()
         sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
         if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
         {
-            UpdateLEDs();   // Already protected thru a device update thread
+            UpdateLEDsInternal();   // Already protected thru a device update thread
             std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
         }
         else

Controllers/ArcticController/RGBController_Arctic.h

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

Controllers/AresonController/AresonControllerDetect.cpp

@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AresonController.h"
 #include "RGBController_Areson.h"
 
@@ -28,17 +28,22 @@
 #define REDRAGON_M914_PID                              0xFA7B
 #define REDRAGON_M914_WIRELESS_PID                     0xFA7C
 
-void DetectAresonControllers(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAresonControllers(hid_device_info* info, const std::string& name)
 {
-    hid_device* dev = hid_open_path(info->path);
+    DetectedControllers detected_controllers;
+    hid_device*         dev;
+
+    dev = hid_open_path(info->path);
 
     if(dev)
     {
         AresonController*     controller      = new AresonController(dev, *info, name);
         RGBController_Areson* rgb_controller  = new RGBController_Areson(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(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,6 +125,8 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
 
 RGBController_Areson::~RGBController_Areson()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -137,7 +139,6 @@ 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);
 
@@ -150,24 +151,17 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Areson::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateMode();
 }
 
-void RGBController_Areson::UpdateSingleLED(int /*led*/)
+void RGBController_Areson::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateMode();
 }

Controllers/AresonController/RGBController_Areson.h

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

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -45,6 +45,13 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
     SetupZones();
 }
 
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_AuraCore::SetupKeyboard()
 {
     name                    = "ASUS Aura Keyboard";
@@ -170,11 +177,6 @@ void RGBController_AuraCore::SetupGA15DH()
     modes.push_back(Static);
 }
 
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupZones()
 {
     zone auraZone;
@@ -186,7 +188,6 @@ 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)
     {
@@ -195,7 +196,6 @@ void RGBController_AuraCore::SetupZones()
         auraZone.leds_min   = 20;
         auraZone.leds_max   = 20;
         auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
     }
     else
     {
@@ -215,19 +215,12 @@ void RGBController_AuraCore::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraCore::DeviceUpdateLEDs()
 {
-    UpdateZoneLEDs(0);
+    DeviceUpdateZoneLEDs(0);
 }
 
-void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraCore::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
     {
@@ -256,16 +249,16 @@ void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
     {
         for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
         {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
         }
     }
     else
     {
-        UpdateSingleLED(0);
+        DeviceUpdateSingleLED(0);
     }
 }
 
-void RGBController_AuraCore::UpdateSingleLED(int led)
+void RGBController_AuraCore::DeviceUpdateSingleLED(int led)
 {
     unsigned char speed = 0xFF;
     unsigned char red   = 0;

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.h

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

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

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

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -11,6 +11,7 @@
 
 #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 "RGBController.h"
 #include "ResourceManager.h"
+#include "RGBController.h"
 #include "RGBControllerKeyNames.h"
 #include "AsusAuraCoreLaptopDevices.h"
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -263,11 +263,13 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
 
     SetupZones();
 
-    SetMode(active_mode);
+    SetActiveMode(active_mode);
 }
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -339,18 +341,7 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                     else
                     {
                         new_zone.type               = ZONE_TYPE_MATRIX;
-                        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);
+                        new_zone.matrix_map         = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
                     }
 
                     /*---------------------------------------------------------*\
@@ -398,13 +389,6 @@ 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++)
@@ -422,12 +406,12 @@ void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
     controller->SetLedsDirect(buffer_map);
 }
 
-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusAuraCoreLaptop::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     controller->SetLedsDirect(buffer_map);
 }
 
-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
+void RGBController_AsusAuraCoreLaptop::DeviceUpdateSingleLED(int /*led*/)
 {
     controller->SetLedsDirect(buffer_map);
 }

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h

@@ -23,11 +23,10 @@ public:
     ~RGBController_AsusAuraCoreLaptop();
 
     void                SetupZones();
-    void                ResizeZone(int zone, int new_size);
 
     void                DeviceUpdateLEDs();
-    void                UpdateZoneLEDs(int zone);
-    void                UpdateSingleLED(int led);
+    void                DeviceUpdateZoneLEDs(int zone);
+    void                DeviceUpdateSingleLED(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->device_name);
+    std::string return_string(bus->info.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->pci_subsystem_device)
+    switch (bus->info.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 "Detector.h"
+#include "DetectionManager.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
 #include "RGBController_AsusAuraGPU.h"
@@ -19,17 +19,9 @@
 
 #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->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
     {
         return false;
     }
@@ -48,31 +40,26 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
 
     return(pass);
 
-}   /* TestForAuraGPUController() */
+}
 
-/******************************************************************************************\
-*                                                                                          *
-*   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 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);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
-} /* DetectAsusAuraGPUControllers() */
 
-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
+    return(detected_controllers);
+}
 
+/*---------------------------------------------------------*\
+|  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);
@@ -131,10 +118,9 @@ 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,6 +124,8 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
 
 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -138,7 +140,6 @@ 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);
 
     /*---------------------------------------------------------*\
@@ -160,13 +161,6 @@ 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++)
@@ -177,18 +171,18 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
 
         controller->SetLEDColors(red, grn, blu);
     }
-    if (controller->SaveOnlyApplies() && GetMode() != 0)
+    if (controller->SaveOnlyApplies() && GetActiveMode() != 0)
     {
         controller->Save();
     }
 }
 
-void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraGPU::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
+void RGBController_AuraGPU::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h

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

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -112,6 +112,8 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -124,7 +126,6 @@ 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);
 
@@ -144,7 +145,6 @@ 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,24 +157,17 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraHeadsetStand::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
+void RGBController_AuraHeadsetStand::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.h

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

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -380,13 +380,7 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
 
 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
-    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;
-        }
-    }
+    Shutdown();
 
     delete controller;
 }
@@ -407,7 +401,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});
@@ -415,7 +409,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});
@@ -425,7 +419,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});
 
@@ -435,7 +429,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});
 
@@ -449,7 +443,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;
     }
 
@@ -463,13 +457,9 @@ 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)
+        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX && led_zones[zone_idx].matrix != NULL)
         {
-            new_zone.matrix_map         = led_zones[zone_idx].matrix;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map         = *led_zones[zone_idx].matrix;
         }
 
         zones.push_back(new_zone);
@@ -489,13 +479,6 @@ 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;
@@ -519,12 +502,12 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
     controller->SendDirect((unsigned char)leds.size(), frame_buf.data());
 }
 
-void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AuraKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.h

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

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -45,6 +45,8 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 
 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -57,7 +59,6 @@ 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);
 
@@ -73,13 +74,6 @@ 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();
@@ -96,12 +90,12 @@ void RGBController_AuraMonitor::DeviceUpdateLEDs()
     controller->ApplyChanges();
 }
 
-void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMonitor::UpdateSingleLED(int led)
+void RGBController_AuraMonitor::DeviceUpdateSingleLED(int led)
 {
     controller->BeginUpdate();
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.h

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

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -185,6 +185,8 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -199,7 +201,6 @@ 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);
 
@@ -214,11 +215,6 @@ 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)
@@ -229,17 +225,17 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
     {
         for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
         {
-            UpdateSingleLED(zone_index);
+            DeviceUpdateSingleLED(zone_index);
         }
     }
 }
 
-void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMouse::UpdateSingleLED(int led)
+void RGBController_AuraMouse::DeviceUpdateSingleLED(int led)
 {
     if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
     {

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.h

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

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -116,6 +116,8 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 
 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -133,7 +135,6 @@ 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);
 
@@ -148,11 +149,6 @@ 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)
@@ -161,13 +157,13 @@ void RGBController_AsusROGSpatha::DeviceUpdateLEDs()
     }
     else
     {
-        UpdateSingleLED(0);
-        UpdateSingleLED(1);
-        UpdateSingleLED(2);
+        DeviceUpdateSingleLED(0);
+        DeviceUpdateSingleLED(1);
+        DeviceUpdateSingleLED(2);
     }
 }
 
-void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
+void RGBController_AsusROGSpatha::DeviceUpdateZoneLEDs(int zone)
 {
     if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
     {
@@ -175,11 +171,11 @@ void RGBController_AsusROGSpatha::UpdateZoneLEDs(int zone)
     }
     else
     {
-        UpdateSingleLED(zone);
+        DeviceUpdateSingleLED(zone);
     }
 }
 
-void RGBController_AsusROGSpatha::UpdateSingleLED(int led)
+void RGBController_AsusROGSpatha::DeviceUpdateSingleLED(int led)
 {
     if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_DIRECT)
     {

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.h

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

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -79,6 +79,8 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 
 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -91,7 +93,6 @@ 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);
 
@@ -105,22 +106,17 @@ void RGBController_AsusROGStrixEvolve::SetupZones()
     SetupColors();
 }
 
-void RGBController_AsusROGStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AsusROGStrixEvolve::DeviceUpdateLEDs()
 {
-    UpdateSingleLED(0);
+    DeviceUpdateSingleLED(0);
 }
 
-void RGBController_AsusROGStrixEvolve::UpdateZoneLEDs(int zone)
+void RGBController_AsusROGStrixEvolve::DeviceUpdateZoneLEDs(int zone)
 {
-    UpdateSingleLED(zone);
+    DeviceUpdateSingleLED(zone);
 }
 
-void RGBController_AsusROGStrixEvolve::UpdateSingleLED(int /*led*/)
+void RGBController_AsusROGStrixEvolve::DeviceUpdateSingleLED(int /*led*/)
 {
     controller->SendUpdate(0x1C, RGBGetRValue(colors[0]));
     controller->SendUpdate(0x1D, RGBGetGValue(colors[0]));

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.h

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

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -182,6 +182,8 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 
 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -194,7 +196,6 @@ 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);
 
@@ -210,24 +211,17 @@ 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::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
+void RGBController_AuraMousemat::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.h

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

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -128,6 +128,8 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
 
 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -171,29 +173,22 @@ 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++)
     {
-        UpdateZoneLEDs(zone_idx);
+        DeviceUpdateZoneLEDs(zone_idx);
     }
 }
 
-void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateZoneLEDs(int zone)
 {
     controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
 }
 
-void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
+void RGBController_AsusAuraRyuoAIO::DeviceUpdateSingleLED(int led)
 {
-    UpdateZoneLEDs(GetLED_Zone(led));
+    DeviceUpdateZoneLEDs(GetLED_Zone(led));
 }
 
 void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.h

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

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -410,6 +410,8 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
 RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -511,10 +513,7 @@ 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         = 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;
+    keyboard_zone.matrix_map.Set(keyboard[layout].rows, keyboard[layout].cols, keyboard[layout].matrix_map);
     zones.push_back(keyboard_zone);
 
     for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
@@ -533,11 +532,6 @@ 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 = {};
@@ -550,12 +544,12 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
     controller->UpdateLeds(led_color_list);
 }
 
-void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraTUFKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
+void RGBController_AuraTUFKeyboard::DeviceUpdateSingleLED(int led)
 {
     if(!controller->is_per_led_keyboard)
     {

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

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

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -119,6 +119,8 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
 
 RGBController_AuraUSB::~RGBController_AuraUSB()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -145,41 +147,68 @@ void RGBController_AuraUSB::SetupZones()
     | Set zones and leds                                |
     \*-------------------------------------------------*/
     int addressableCounter = 1;
-    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+
+    for(std::size_t 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].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].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;
         }
         else
         {
-            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++;
+            zones[channel_idx].leds_min                 = 0;
+            zones[channel_idx].leds_max                 = AURA_ADDRESSABLE_MAX_LEDS;
 
             if(first_run)
             {
-                zones[channel_idx].leds_count = 0;
+                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                 = "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 ");
@@ -189,30 +218,22 @@ void RGBController_AuraUSB::SetupZones()
             {
                 new_led.name.append(", LED ");
             }
+
             new_led.name.append(std::to_string(led_idx));
 
-            new_led.value = channel_idx;
+            new_led.value = (unsigned int)channel_idx;
 
             leds.push_back(new_led);
         }
-
-        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
 }
 
-void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
+void RGBController_AuraUSB::DeviceConfigureZone(int zone_idx)
 {
-    if((size_t) zone >= zones.size())
+    if((size_t)zone_idx < 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();
     }
 }
@@ -229,7 +250,7 @@ void RGBController_AuraUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
+void RGBController_AuraUSB::DeviceUpdateZoneLEDs(int zone)
 {
     if(!initializedMode)
     {
@@ -239,7 +260,7 @@ void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
     controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
 }
 
-void RGBController_AuraUSB::UpdateSingleLED(int led)
+void RGBController_AuraUSB::DeviceUpdateSingleLED(int led)
 {
     if(!initializedMode)
     {

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

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

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

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

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -117,6 +117,8 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 
 RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
 {
+    Shutdown();
+
     delete controller;
 }
 
@@ -129,7 +131,6 @@ 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);
 
@@ -149,7 +150,6 @@ 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,13 +165,6 @@ 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)
@@ -180,12 +173,12 @@ void RGBController_AsusROGAlly::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusROGAlly::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
+void RGBController_AsusROGAlly::DeviceUpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.h

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

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

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