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

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

.gitlab-ci.yml

@@ -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
@@ -517,9 +537,9 @@ before_script:
   stage: build
   script:
   - eval $(/opt/homebrew/bin/brew shellenv)
-  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
+  - qmake OpenRGB.pro
   - make -j16
-  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -530,18 +550,18 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS ARM64 Qt6":
+"MacOS ARM64 Qt5":
   tags:
   - macos
   stage: build
   script:
   - eval $(/opt/homebrew/bin/brew shellenv)
-  - qmake OpenRGB.pro
+  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
   - make -j16
-  - macdeployqt OpenRGB.app -codesign=OpenRGB
+  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   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
@@ -555,9 +575,9 @@ before_script:
   stage: build
   script:
   - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
+  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
   - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   artifacts:
     name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -568,18 +588,18 @@ before_script:
   rules:
   - !reference [.upstream_rules, rules]
 
-"MacOS Intel Qt6":
+"MacOS Intel Qt5":
   tags:
   - macos
   stage: build
   script:
   - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
+  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
   - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
 
   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

@@ -187,11 +187,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 +210,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 +227,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

@@ -134,7 +134,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 +159,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 +171,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

@@ -56,7 +56,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 +64,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 +95,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 +114,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 +149,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

@@ -154,7 +154,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 +162,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 +170,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 +202,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 +261,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/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

@@ -262,30 +262,18 @@ RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 
 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 +293,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 +312,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/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

@@ -134,7 +134,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 +146,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 +155,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/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

@@ -124,7 +124,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 +133,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::DeviceResizeZone(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -135,7 +135,7 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        ResizeZone(int zone, int new_size);
+    void                                        DeviceResizeZone(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

@@ -229,8 +229,6 @@ void RGBController_PolychromeUSB::SetupZones()
 
             leds.push_back(new_led);
         }
-
-        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
@@ -273,10 +271,10 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
+void RGBController_PolychromeUSB::DeviceResizeZone(int zone, int new_size)
 {
     zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+    controller->DeviceResizeZone(zones_info[zone].zone, new_size);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -299,7 +297,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 +309,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

@@ -22,11 +22,11 @@ public:
 
     void        SetupZones();
 
-    void        ResizeZone(int zone, int new_size);
+    void        DeviceResizeZone(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/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -135,7 +135,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,7 +159,7 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockASRRGBSMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -171,16 +170,16 @@ 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,11 @@ public:
 
     void        SetupZones();
 
-    void        ResizeZone(int zone, int new_size);
+    void        DeviceResizeZone(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/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -267,7 +267,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,9 +296,9 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::DeviceResizeZone(int zone, int new_size)
 {
-    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    LOG_TRACE("[%s] DeviceResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
     controller-> SetARGBSize(new_size & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
@@ -309,19 +308,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 +337,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        DeviceResizeZone(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/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -229,8 +229,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                 new_zone->type          = ZONE_TYPE_SINGLE;
             }
 
-            new_zone->matrix_map        = NULL;
-
             /*---------------------------------------------------------*\
             | Push new zone to zones vector                             |
             \*---------------------------------------------------------*/
@@ -281,7 +279,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |
@@ -292,16 +290,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        DeviceResizeZone(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/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,20 +85,10 @@ 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*>& busses)
 {
+    DetectedControllers detected_controllers;
+
     for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
         IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -123,7 +104,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                     u16_to_u8 version;
                     version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
 
-                    switch (version.msb)
+                    switch(version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
@@ -131,7 +112,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[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;
 
@@ -141,7 +122,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[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;
 
@@ -151,7 +132,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
                                 ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[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

@@ -141,7 +141,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 +157,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

@@ -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/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,17 +278,6 @@ 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;
-        }
-    }
-
     delete controller;
 }
 
@@ -310,14 +299,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 +318,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 +349,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,17 +277,6 @@ 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;
-        }
-    }
-
     delete controller;
 }
 
@@ -309,14 +298,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 +317,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 +370,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

@@ -57,7 +57,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 +70,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 +83,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 +93,6 @@ void RGBController_AlienwareAW3423DWF::SetupZones()
     SetupColors();
 }
 
-void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-}
-
 void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -118,17 +111,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

@@ -57,7 +57,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 +70,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 +83,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 +93,6 @@ void RGBController_AlienwareMonitor::SetupZones()
     SetupColors();
 }
 
-void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
 {
     /*-----------------------------------------------------*\
@@ -119,17 +111,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

@@ -164,14 +164,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 +183,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 +214,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,17 +10,20 @@
 \*---------------------------------------------------------*/
 
 #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++)
     {
@@ -29,7 +32,7 @@ void DetectArcticControllers()
         if(controller->IsPresent())
         {
             RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
+            detected_controllers.push_back(rgb_controller);
         }
         else
         {
@@ -38,6 +41,8 @@ void DetectArcticControllers()
 
         delete ports[device];
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -70,7 +70,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 +82,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 +89,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 +115,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

@@ -137,7 +137,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 +149,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

@@ -186,7 +186,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 +194,6 @@ void RGBController_AuraCore::SetupZones()
         auraZone.leds_min   = 20;
         auraZone.leds_max   = 20;
         auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
     }
     else
     {
@@ -215,19 +213,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 +247,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,7 +263,7 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
 
     SetupZones();
 
-    SetMode(active_mode);
+    SetActiveMode(active_mode);
 }
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
@@ -339,18 +339,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 +387,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 +404,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/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,14 +19,6 @@
 
 #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))
@@ -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

@@ -138,7 +138,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 +159,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 +169,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

@@ -124,7 +124,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 +143,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 +155,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,14 +380,6 @@ 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;
-        }
-    }
-
     delete controller;
 }
 
@@ -407,7 +399,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 +407,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 +417,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 +427,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 +441,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 +455,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 +477,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 +500,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

@@ -57,7 +57,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 +72,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 +88,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

@@ -199,7 +199,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 +213,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 +223,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

@@ -133,7 +133,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 +147,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 +155,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 +169,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

@@ -91,7 +91,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 +104,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

@@ -194,7 +194,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 +209,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

@@ -171,29 +171,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

@@ -511,10 +511,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 +530,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 +542,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

@@ -195,14 +195,12 @@ void RGBController_AuraUSB::SetupZones()
 
             leds.push_back(new_led);
         }
-
-        zones[channel_idx].matrix_map = NULL;
     }
 
     SetupColors();
 }
 
-void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
+void RGBController_AuraUSB::DeviceResizeZone(int zone, int new_size)
 {
     if((size_t) zone >= zones.size())
     {
@@ -229,7 +227,7 @@ void RGBController_AuraUSB::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
+void RGBController_AuraUSB::DeviceUpdateZoneLEDs(int zone)
 {
     if(!initializedMode)
     {
@@ -239,7 +237,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        DeviceResizeZone(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/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"
@@ -143,22 +143,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)
     {
@@ -166,13 +174,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)
     {
@@ -182,7 +195,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)
         {
@@ -190,11 +203,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)
     {
@@ -202,13 +220,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)
     {
@@ -216,125 +239,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

@@ -129,7 +129,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 +148,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 +163,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 +171,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

@@ -172,29 +172,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()

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.h

@@ -23,11 +23,10 @@ public:
     ~RGBController_AsusROGStrixLC();
 
     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();
 private:

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.cpp

@@ -296,10 +296,7 @@ void RGBController_AsusCerberusKeyboard::SetupZones()
     keyboard.leds_min           = zone_size;
     keyboard.leds_max           = zone_size;
     keyboard.leds_count         = zone_size;
-    keyboard.matrix_map         = new matrix_map_type;
-    keyboard.matrix_map->height = 6;
-    keyboard.matrix_map->width  = 24;
-    keyboard.matrix_map->map    = *matrix_map;
+    keyboard.matrix_map.Set(6, 24, *matrix_map);
     zones.push_back(keyboard);
 
     for(int led_id = 0; led_id < zone_size; led_id++)
@@ -314,11 +311,6 @@ void RGBController_AsusCerberusKeyboard::SetupZones()
     SetupColors();
 }
 
-void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
 {
     for(unsigned int i = 0; i < colors.size(); i++)
@@ -332,12 +324,12 @@ void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
     controller->SendPerLEDColorEnd();
 }
 
-void RGBController_AsusCerberusKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusCerberusKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AsusCerberusKeyboard::UpdateSingleLED(int led)
+void RGBController_AsusCerberusKeyboard::DeviceUpdateSingleLED(int led)
 {
     uint8_t red   = RGBGetRValue(colors[led]);
     uint8_t green = RGBGetGValue(colors[led]);

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.h

@@ -29,11 +29,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/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -8,7 +8,7 @@
 \*---------------------------------------------------------*/
 
 #include <hidapi.h>
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AsusCerberusKeyboardController.h"
 #include "AsusSagarisKeyboardController.h"
 #include "AsusStrixClawController.h"
@@ -23,43 +23,58 @@
 #define ASUS_SAGARIS_GK1100_PID     0x1835
 #define ASUS_ROG_STRIX_CLAW_PID     0x1016
 
-void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusCerberusMech(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)
     {
         AsusCerberusKeyboardController*     controller          = new AsusCerberusKeyboardController(dev, info->path, info->release_number, name);
         RGBController_AsusCerberusKeyboard* rgb_controller      = new RGBController_AsusCerberusKeyboard(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusSagarisKeyboard(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)
     {
         AsusSagarisKeyboardController*     controller          = new AsusSagarisKeyboardController(dev, info->path, info->release_number, name);
         RGBController_AsusSagarisKeyboard* rgb_controller      = new RGBController_AsusSagarisKeyboard(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
-void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
+DetectedControllers DetectAsusStrixClaw(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)
     {
         StrixClawController*     controller          = new StrixClawController(dev, info->path, name);
         RGBController_StrixClaw* rgb_controller      = new RGBController_StrixClaw(controller);
 
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
     }
+
+    return(detected_controllers);
 }
 
 REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,    ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp

@@ -176,27 +176,21 @@ void RGBController_AsusSagarisKeyboard::SetupZones()
     keyboard.leds_min           = 1;
     keyboard.leds_max           = 1;
     keyboard.leds_count         = 1;
-    keyboard.matrix_map         = nullptr;
 
     SetupColors();
 }
 
-void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
 {
 
 }
 
-void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusSagarisKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
 
 }
 
-void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AsusSagarisKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
 
 }

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.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/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.cpp

@@ -65,7 +65,6 @@ void RGBController_StrixClaw::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);
 
@@ -83,7 +82,6 @@ void RGBController_StrixClaw::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);
 
@@ -97,22 +95,17 @@ void RGBController_StrixClaw::SetupZones()
     SetupColors();
 }
 
-void RGBController_StrixClaw::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_StrixClaw::DeviceUpdateLEDs()
 {
 
 }
 
-void RGBController_StrixClaw::UpdateZoneLEDs(int /*zone*/)
+void RGBController_StrixClaw::DeviceUpdateZoneLEDs(int /*zone*/)
 {
 
 }
 
-void RGBController_StrixClaw::UpdateSingleLED(int /*led*/)
+void RGBController_StrixClaw::DeviceUpdateSingleLED(int /*led*/)
 {
 
 }