Remove led::value

Add display name fields to controller and zone instead of editing the existing name field
Add ConfigureDevice and the ability to configure device name
2026-06-05 03:04:51 -05:00 · 2026-06-04 01:19:04 -05:00 · 2026-06-03 10:10:29 -05:00 · 2026-06-03 10:10:28 -05:00 · 2026-06-03 10:10:28 -05:00 · 2026-06-03 10:10:28 -05:00
1180 changed files with 83041 additions and 37649 deletions
@@ -100,19 +100,19 @@ before_script:
 "Linux i386 AppImage":
  variables:
    TGT_ARCH: "i386"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 i386 Build Target                    #
+# Linux (AppImage) Qt5 i386 Build Target                    #
 #-----------------------------------------------------------#
-"Linux i386 AppImage Qt6":
+"Linux i386 AppImage Qt5":
  variables:
    TGT_ARCH: "i386"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -122,7 +122,7 @@ before_script:
 "Linux amd64 AppImage":
  variables:
    TGT_ARCH: "amd64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "x86_64"
  <<: *appimage_script_steps
@@ -137,13 +137,13 @@ before_script:
  - "saas-linux-small-amd64"

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 amd64 Build Target                   #
+# Linux (AppImage) Qt5 amd64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux amd64 AppImage Qt6":
+"Linux amd64 AppImage Qt5":
  variables:
    TGT_ARCH: "amd64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "x86_64"
  <<: *appimage_script_steps

@@ -153,19 +153,19 @@ before_script:
 "Linux armhf AppImage":
  variables:
    TGT_ARCH: "armhf"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 armhf Build Target                   #
+# Linux (AppImage) Qt5 armhf Build Target                   #
 #-----------------------------------------------------------#
-"Linux armhf AppImage Qt6":
+"Linux armhf AppImage Qt5":
  variables:
    TGT_ARCH: "armhf"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -175,19 +175,19 @@ before_script:
 "Linux arm64 AppImage":
  variables:
    TGT_ARCH: "arm64"
-    TGT_QT: ""
+    TGT_QT: "qt6"
    TGT_NAME: "${TGT_ARCH}"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

 #-----------------------------------------------------------#
-# Linux (AppImage) Qt6 arm64 Build Target                   #
+# Linux (AppImage) Qt5 arm64 Build Target                   #
 #-----------------------------------------------------------#
-"Linux arm64 AppImage Qt6":
+"Linux arm64 AppImage Qt5":
  variables:
    TGT_ARCH: "arm64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
+    TGT_QT: ""
+    TGT_NAME: "${TGT_ARCH}_qt5"
    TGT_PATH: "${TGT_ARCH}"
  <<: *appimage_script_steps

@@ -296,7 +296,10 @@ before_script:
  image: fedora:43
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git wget -y
+  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
+  - unzip hidapi-hotplug.zip
+  - dnf install ./*.rpm -y
  - rpmdev-setuptree
  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
@@ -324,10 +327,14 @@ before_script:
  image: i386/debian:bookworm
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+i386+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux i386 .deb (Debian Bookworm)"
  needs:
@@ -342,10 +349,14 @@ before_script:
  image: amd64/debian:bookworm
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
@@ -360,10 +371,14 @@ before_script:
  image: ubuntu:noble
  stage: test
  script:
-  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -y unzip curl
+  - 'curl -o hidapi-hotplug.zip -L https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+amd64+.deb+%28Debian+Bookworm%29'
+  - unzip hidapi-hotplug.zip
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./libhidapi-hotplug*.deb
  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
  - openrgb --version
-  - apt remove -y openrgb
+  - DEBIAN_FRONTEND=noninteractive apt remove -y openrgb
  dependencies:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
@@ -378,6 +393,10 @@ before_script:
  image: fedora:43
  stage: test
  script:
+  - dnf install unzip wget -y
+  - 'wget -O hidapi-hotplug.zip https://gitlab.com/OpenRGBDevelopers/hidapi-hotplug/-/jobs/artifacts/master/download?job=Linux+64+F43+rpm'
+  - unzip hidapi-hotplug.zip
+  - dnf install ./*.rpm -y
  - dnf5 -y install ./openrgb*64.rpm
  - openrgb --version
  - dnf5 -y remove openrgb
@@ -397,7 +416,7 @@ before_script:
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 32
+  - scripts\build-windows.bat 6.8.3 2022 32
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -410,17 +429,17 @@ before_script:
    - !reference [.upstream_rules, rules]

 #-----------------------------------------------------------#
-# Windows (32-bit) Qt6 Build Target                         #
+# Windows (32-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 32 Qt6":
+"Windows 32 Qt5":
  extends:
  - .shared_windows_runners
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 32
+  - scripts\build-windows.bat 5.15.0 2019 32
  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_32_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_32_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 32-bit'
    exclude:
@@ -439,7 +458,7 @@ before_script:
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 64
+  - scripts\build-windows.bat 6.8.3 2022 64
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -470,17 +489,17 @@ before_script:
  - "saas-windows-medium-amd64"

 #-----------------------------------------------------------#
-# Windows (64-bit) Qt6 Build Target                         #
+# Windows (64-bit) Qt5 Build Target                         #
 #-----------------------------------------------------------#
-"Windows 64 Qt6 Base":
+"Windows 64 Qt5 Base":
  extends:
  - .shared_windows_runners
  stage: build
  script:
  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 64
+  - scripts\build-windows.bat 5.15.0 2019 64
  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Windows_64_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - 'OpenRGB Windows 64-bit'
    exclude:
@@ -491,13 +510,14 @@ before_script:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
      when: never

-"Windows 64 Qt6":
-  extends: "Windows 64 Qt6 Base"
+
+"Windows 64 Qt5":
+  extends: "Windows 64 Qt5 Base"
  rules:
  - !reference [.upstream_rules, rules]

-"Windows 64 Qt6 (Downstream)":
-  extends: "Windows 64 Qt6 Base"
+"Windows 64 Qt5 (Downstream)":
+  extends: "Windows 64 Qt5 Base"
  before_script:
    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
    - cd OpenRGB-Qt-Packages
@@ -516,10 +536,7 @@ before_script:
  - macos
  stage: build
  script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
-  - make -j16
-  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 arm

  artifacts:
    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
@@ -530,18 +547,15 @@ 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
-  - make -j16
-  - macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 arm

  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Qt5_ARM64_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB.app
    expire_in: 30 days
@@ -554,10 +568,7 @@ before_script:
  - macos
  stage: build
  script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt6 intel

  artifacts:
    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -568,18 +579,15 @@ 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 make -j16
-  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - ./scripts/build-macos.sh qt5 intel

  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt5_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB.app
    expire_in: 30 days
@@ -22,13 +22,12 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDominatorPlatinumController/
+/Controllers/CorsairDRAMController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
-/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/
@@ -69,3 +69,7 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil

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

 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -187,11 +189,7 @@ void RGBController_BloodyB820R::SetupZones()
    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = 6;
-    KB_zone.matrix_map->width   = 21;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    KB_zone.matrix_map.Set(6, 21, (unsigned int *)&matrix_map);
    zones.push_back(KB_zone);

    /*-------------------------------------------------*\
@@ -207,27 +205,18 @@ void RGBController_BloodyB820R::SetupZones()
    {
        led new_led;
        new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
        leds.push_back(new_led);
    }

    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 +228,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]);
@@ -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();

@@ -67,13 +67,13 @@ void BloodyMouseController::InitDevice()
    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
 }

-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets)
 {
    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };

    for(uint8_t i = 0; i < colors.size(); i++)
    {
-        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
+        uint8_t offset                              = 3 * (offsets[i]) + BLOODYMOUSE_DATA_BYTE;

        buffer[offset]                              = RGBGetRValue(colors[i]);
        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
@@ -58,7 +58,7 @@ public:
    std::string     GetLocation();
    std::string     GetName();

-    void            SetLedsDirect(std::vector<RGBColor> colors);
+    void            SetLedsDirect(std::vector<RGBColor> colors, std::vector<uint8_t> offsets);

 private:
    uint16_t        pid;
@@ -89,6 +89,8 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont

 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -134,14 +136,13 @@ 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++)
        {
            led new_led;

-            new_led.value       = mz.zone_leds[lp_idx];
+            offsets.push_back(mz.zone_leds[lp_idx]);

            if(bool_single)
            {
@@ -160,31 +161,17 @@ 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;
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor c = colors[i] | (leds[i].value << 24);
-        colour.push_back(c);
-    }
-
-    controller->SetLedsDirect(colour);
+    controller->SetLedsDirect(colors, offsets);
 }

-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();
 }
@@ -30,14 +30,14 @@ 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();

 private:
    BloodyMouseController*  controller;
+    std::vector<uint8_t>    offsets;
 };
@@ -186,7 +186,7 @@ void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
 }

-void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
+void AMBXController::SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count)
 {
    for(unsigned int i = 0; i < count; i++)
    {
@@ -44,7 +44,7 @@ public:

    bool            IsInitialized();
    void            SetLEDColor(unsigned int led, RGBColor color);
-    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
+    void            SetLEDColors(const unsigned int* leds, RGBColor* colors, unsigned int count);

 private:
    libusb_context*          usb_context;
@@ -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);
@@ -9,6 +9,15 @@

 #include "RGBController_AMBX.h"

+static const unsigned int led_values[] =
+{
+    AMBX_LIGHT_LEFT,
+    AMBX_LIGHT_RIGHT,
+    AMBX_LIGHT_WALL_LEFT,
+    AMBX_LIGHT_WALL_CENTER,
+    AMBX_LIGHT_WALL_RIGHT
+};
+
 /**------------------------------------------------------------------*\
    @name Philips amBX
    @category Accessory
@@ -44,6 +53,8 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)

 RGBController_AMBX::~RGBController_AMBX()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -56,7 +67,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,43 +75,32 @@ 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
    led left_light;
    left_light.name  = "Left";
-    left_light.value = AMBX_LIGHT_LEFT;
    leds.push_back(left_light);

    led right_light;
    right_light.name  = "Right";
-    right_light.value = AMBX_LIGHT_RIGHT;
    leds.push_back(right_light);

    led wall_left;
    wall_left.name  = "Wall Left";
-    wall_left.value = AMBX_LIGHT_WALL_LEFT;
    leds.push_back(wall_left);

    led wall_center;
    wall_center.name  = "Wall Center";
-    wall_center.value = AMBX_LIGHT_WALL_CENTER;
    leds.push_back(wall_center);

    led wall_right;
    wall_right.name  = "Wall Right";
-    wall_right.value = AMBX_LIGHT_WALL_RIGHT;
    leds.push_back(wall_right);

    SetupColors();
 }

-void RGBController_AMBX::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    // This device does not support resizing zones
-}
-
 void RGBController_AMBX::DeviceUpdateLEDs()
 {
    if(!controller->IsInitialized())
@@ -109,19 +108,10 @@ void RGBController_AMBX::DeviceUpdateLEDs()
        return;
    }

-    unsigned int led_values[5];
-    RGBColor led_colors[5];
-
-    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        led_values[led_idx] = leds[led_idx].value;
-        led_colors[led_idx] = colors[led_idx];
-    }
-
-    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
+    controller->SetLEDColors(led_values, colors.data(), static_cast<unsigned int>(colors.size()));
 }

-void RGBController_AMBX::UpdateZoneLEDs(int zone)
+void RGBController_AMBX::DeviceUpdateZoneLEDs(int zone)
 {
    if(!controller->IsInitialized())
    {
@@ -143,27 +133,27 @@ void RGBController_AMBX::UpdateZoneLEDs(int zone)
        start_idx += zones[z_idx].leds_count;
    }

-    unsigned int led_values[5];
-    RGBColor led_colors[5];
+    unsigned int tmp_values[5];
+    RGBColor     tmp_colors[5];

    for(unsigned int led_idx = 0; led_idx < zone_size; led_idx++)
    {
        unsigned int current_idx = start_idx + led_idx;
-        led_values[led_idx] = leds[current_idx].value;
-        led_colors[led_idx] = colors[current_idx];
+        tmp_values[led_idx] = led_values[current_idx];
+        tmp_colors[led_idx] = colors[current_idx];
    }

-    controller->SetLEDColors(led_values, led_colors, zone_size);
+    controller->SetLEDColors(tmp_values, tmp_colors, zone_size);
 }

-void RGBController_AMBX::UpdateSingleLED(int led)
+void RGBController_AMBX::DeviceUpdateSingleLED(int led)
 {
    if(!controller->IsInitialized())
    {
        return;
    }

-    unsigned int led_value = leds[led].value;
+    unsigned int led_value = led_values[led];
    RGBColor color = colors[led];
    controller->SetLEDColor(led_value, color);
 }
@@ -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();

@@ -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);
@@ -11,6 +11,33 @@

 #include "RGBController_AMDWraithPrism.h"

+/*---------------------------------------------------------*\
+| LED maps                                                  |
+\*---------------------------------------------------------*/
+const unsigned char led_values[] =
+{
+    // Logo
+    0x00,
+    // Fan
+    0x01,
+    // Ring
+    0x08,
+    0x07,
+    0x06,
+    0x05,
+    0x04,
+    0x03,
+    0x02,
+    0x10,
+    0x0F,
+    0x0E,
+    0x0D,
+    0x0C,
+    0x0B,
+    0x0A,
+    0x09
+};
+
 /**------------------------------------------------------------------*\
    @name AMD Wraith Prism
    @category Cooler
@@ -132,19 +159,13 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl

 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
+    Shutdown();
+
    delete controller;
 }

 void RGBController_AMDWraithPrism::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | LED maps                                              |
-    \*-----------------------------------------------------*/
-    const unsigned int logo_leds[1]  =  { 0x00 };
-    const unsigned int fan_leds[1]   =  { 0x01 };
-    const unsigned int ring_leds[15] =  { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10,
-                                          0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
-
    /*-----------------------------------------------------*\
    | Set up zones                                          |
    \*-----------------------------------------------------*/
@@ -154,7 +175,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 +183,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 +191,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);

    /*-----------------------------------------------------*\
@@ -182,7 +200,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    {
        led logo_led;
        logo_led.name       = "Logo LED";
-        logo_led.value      = logo_leds[led_idx];
        leds.push_back(logo_led);
    }

@@ -190,7 +207,6 @@ void RGBController_AMDWraithPrism::SetupZones()
    {
        led fan_led;
        fan_led.name        = "Fan LED";
-        fan_led.value       = fan_leds[led_idx];
        leds.push_back(fan_led);
    }

@@ -198,20 +214,12 @@ void RGBController_AMDWraithPrism::SetupZones()
    {
        led ring_led;
        ring_led.name       = "Ring LED";
-        ring_led.value      = ring_leds[led_idx];
        leds.push_back(ring_led);
    }

    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)
@@ -226,7 +234,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
        leds_count = 0;
        for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
+            led_ids[leds_count]     = led_values[led_idx];
            color_buf[leds_count]   = colors[led_idx];

            leds_count++;
@@ -239,7 +247,7 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
        leds_count = 0;
        for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
+            led_ids[leds_count]     = led_values[led_idx + 2];
            color_buf[leds_count]   = colors[led_idx + 2];

            leds_count++;
@@ -271,12 +279,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();
 }
@@ -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();

@@ -31,7 +31,7 @@ AOCKeyboardController::~AOCKeyboardController()

 std::string AOCKeyboardController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCKeyboardController::GetDeviceName()
@@ -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);
@@ -257,35 +257,25 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont

 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
+    Shutdown();
+
    delete controller;
 }

 void RGBController_AOCKeyboard::SetupZones()
 {
+    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
+
    /*---------------------------------------------------------*\
    | Create the keyboard zone usiung Keyboard Layout Manager   |
    \*---------------------------------------------------------*/
    zone new_zone;
-    new_zone.name               = ZONE_EN_KEYBOARD;
-    new_zone.type               = ZONE_TYPE_MATRIX;
-
-    KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
-
-    matrix_map_type * new_map   = new matrix_map_type;
-    new_zone.matrix_map         = new_map;
-    new_zone.matrix_map->height = new_kb.GetRowCount();
-    new_zone.matrix_map->width  = new_kb.GetColumnCount();
-
-    new_zone.matrix_map->map    = new unsigned int[new_map->height * new_map->width];
-    new_zone.leds_count         = new_kb.GetKeyCount();
-    new_zone.leds_min           = new_zone.leds_count;
-    new_zone.leds_max           = new_zone.leds_count;
-
-    /*---------------------------------------------------------*\
-    | Matrix map still uses declared zone rows and columns      |
-    |   as the packet structure depends on the matrix map       |
-    \*---------------------------------------------------------*/
-    new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
+    new_zone.name                   = ZONE_EN_KEYBOARD;
+    new_zone.type                   = ZONE_TYPE_MATRIX;
+    new_zone.leds_count             = new_kb.GetKeyCount();
+    new_zone.leds_min               = new_zone.leds_count;
+    new_zone.leds_max               = new_zone.leds_count;
+    new_zone.matrix_map             = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);

    /*---------------------------------------------------------*\
    | Create LEDs for the Matrix zone                           |
@@ -296,7 +286,7 @@ void RGBController_AOCKeyboard::SetupZones()
        led new_led;

        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-        new_led.value               = new_kb.GetKeyValueAt(led_idx);
+        led_values.push_back(new_kb.GetKeyValueAt(led_idx));
        leds.push_back(new_led);
    }

@@ -305,13 +295,6 @@ void RGBController_AOCKeyboard::SetupZones()
    SetupColors();
 }

-void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCKeyboard::DeviceUpdateLEDs()
 {
    if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
@@ -320,7 +303,7 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()

        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
        {
-            color_buf[leds[led_idx].value] = colors[led_idx];
+            color_buf[led_values[led_idx]] = colors[led_idx];
        }

        controller->SetCustom(&color_buf[0]);
@@ -331,12 +314,12 @@ void RGBController_AOCKeyboard::DeviceUpdateLEDs()
    }
 }

-void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AOCKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -22,14 +22,13 @@ 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();

 private:
-    AOCKeyboardController*  controller;
+    AOCKeyboardController*      controller;
+    std::vector<unsigned int>   led_values;
 };
@@ -27,7 +27,7 @@ AOCMouseController::~AOCMouseController()

 std::string AOCMouseController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCMouseController::GetDeviceName()
@@ -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);
@@ -123,6 +123,8 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt

 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -134,7 +136,6 @@ void RGBController_AOCMouse::SetupZones()
    logo_zone.leds_min              = 1;
    logo_zone.leds_max              = 1;
    logo_zone.leds_count            = 1;
-    logo_zone.matrix_map            = NULL;
    zones.push_back(logo_zone);

    led logo_led;
@@ -147,7 +148,6 @@ void RGBController_AOCMouse::SetupZones()
    scroll_wheel_zone.leds_min      = 1;
    scroll_wheel_zone.leds_max      = 1;
    scroll_wheel_zone.leds_count    = 1;
-    scroll_wheel_zone.matrix_map    = NULL;
    zones.push_back(scroll_wheel_zone);

    led scroll_wheel_led;
@@ -157,24 +157,17 @@ void RGBController_AOCMouse::SetupZones()
    SetupColors();
 }

-void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCMouse::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMouse::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -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();

@@ -27,7 +27,7 @@ AOCMousematController::~AOCMousematController()

 std::string AOCMousematController::GetDeviceLocation()
 {
-    return("HID " + location);
+    return("HID: " + location);
 }

 std::string AOCMousematController::GetDeviceName()
@@ -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);
@@ -113,6 +113,8 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont

 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -124,7 +126,6 @@ void RGBController_AOCMousemat::SetupZones()
    mousemat_zone.leds_min      = 1;
    mousemat_zone.leds_max      = 1;
    mousemat_zone.leds_count    = 1;
-    mousemat_zone.matrix_map    = NULL;
    zones.push_back(mousemat_zone);

    led mousemat_led;
@@ -134,24 +135,17 @@ void RGBController_AOCMousemat::SetupZones()
    SetupColors();
 }

-void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AOCMousemat::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AOCMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
+void RGBController_AOCMousemat::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -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();

@@ -11,12 +11,12 @@
 \*---------------------------------------------------------*/

 #include <cstring>
-#include "RGBController.h"
-#include "ResourceManager.h"
-#include "SettingsManager.h"
-#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dmiinfo.h"
+#include "ResourceManager.h"
+#include "RGBController.h"
+#include "SettingsManager.h"
+#include "StringUtils.h"

 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
    WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }

-void PolychromeUSBController::ResizeZone(int zone, int new_size)
+void PolychromeUSBController::SetZoneSize(int zone, int new_size)
 {
    unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];

@@ -135,7 +135,7 @@ public:
                                                    unsigned int    configsize
                                                    );

-    void                                        ResizeZone(int zone, int new_size);
+    void                                        SetZoneSize(int zone, int new_size);
    void                                        SetRGSwap(bool reset);

 protected:
@@ -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);
@@ -185,8 +185,25 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
    SetupZones();
 }

+RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_PolychromeUSB::SetupZones()
 {
+    /*-----------------------------------------------------*\
+    | Only set LED count on the first run                   |
+    \*-----------------------------------------------------*/
+    bool first_run = false;
+
+    if(zones.size() == 0)
+    {
+        first_run = true;
+    }
+
    /*-------------------------------------------------*\
    | Clear any existing color/LED configuration        |
    \*-------------------------------------------------*/
@@ -197,40 +214,65 @@ void RGBController_PolychromeUSB::SetupZones()
    /*-------------------------------------------------*\
    | Set zones and leds                                |
    \*-------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
    {
        PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];

-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
        if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
        {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].leds_min                 = 0;
+            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
+
+            if(first_run)
+            {
+                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
+                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+            {
+                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
+            {
+                zones[channel_idx].leds_count           = device_info.num_leds;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
+            {
+                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
+            }
+
+            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
+            {
+                zones[channel_idx].matrix_map.width     = 0;
+                zones[channel_idx].matrix_map.height    = 0;
+                zones[channel_idx].matrix_map.map.resize(0);
+            }
        }
        else if(device_info.device_type==PolychromeDeviceType::FIXED)
        {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
+            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
+            zones[channel_idx].leds_min                 = device_info.num_leds;
+            zones[channel_idx].leds_max                 = device_info.num_leds;
+            zones[channel_idx].leds_count               = device_info.num_leds;
        }

-
        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
        {
            led new_led;
            new_led.name = zones[channel_idx].name;
            new_led.name.append(", LED ");
            new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = channel_idx;

            leds.push_back(new_led);
+            led_values.push_back(channel_idx);
        }
-
-        zones[channel_idx].matrix_map = NULL;
    }

    SetupColors();
@@ -254,7 +296,7 @@ void RGBController_PolychromeUSB::SetupZones()
     \*---------------------------------------------------------*/
     for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
     {
-         unsigned char led = (unsigned char)leds[led_idx].value;
+         unsigned char led = (unsigned char)led_values[led_idx];

         colors[led_idx] = zones_info[led].color;
     }
@@ -273,10 +315,14 @@ void RGBController_PolychromeUSB::SetupZones()
     }
 }

-void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
+void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
 {
-    zones[zone].leds_count = (unsigned char) new_size;
-    controller->ResizeZone(zones_info[zone].zone, new_size);
+    if((size_t)zone_idx < zones.size())
+    {
+        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
+
+        SetupZones();
+    }
 }

 void RGBController_PolychromeUSB::DeviceUpdateLEDs()
@@ -299,7 +345,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
    }
 }

-void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
+void RGBController_PolychromeUSB::DeviceUpdateZoneLEDs(int zone)
 {
    unsigned char set_mode=zones_info[zone].mode;

@@ -311,9 +357,9 @@ 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 int  channel  = led_values[led];
    unsigned char set_mode = zones_info[channel].mode;

    if(set_mode > modes.size())
@@ -19,19 +19,21 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
    RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
+    ~RGBController_PolychromeUSB();

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

 private:
    PolychromeUSBController*        controller;
+    std::vector<unsigned int>       led_values;
    std::vector<PolychromeZoneInfo> zones_info;

    unsigned char GetDeviceMode(unsigned char zone);
@@ -36,7 +36,7 @@ ASRockASRRGBSMBusController::~ASRockASRRGBSMBusController()

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

 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -135,7 +137,6 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
    new_zone->leds_min      = 1;
    new_zone->leds_max      = 1;
    new_zone->leds_count    = 1;
-    new_zone->matrix_map    = NULL;

    /*---------------------------------------------------------*\
    | Push new zone to zones vector                             |
@@ -157,30 +158,28 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
    \*---------------------------------------------------------*/
    leds.push_back(*new_led);

-    SetupColors();
-}
-
-void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
-{
    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
+    | Initialize led_values vector                              |
    \*---------------------------------------------------------*/
+    led_values.push_back(0);
+
+    SetupColors();
 }

 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]);
@@ -190,9 +189,9 @@ void RGBController_ASRockASRRGBSMBus::UpdateSingleLED(int led)
    | If the LED value is non-zero, this LED overrides the LED  |
    | index                                                     |
    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
+    if(led_values[led] != 0)
    {
-        led = leds[led].value;
+        led = led_values[led];
    }

    controller->SetColorsAndSpeed(led, red, grn, blu);
@@ -22,14 +22,13 @@ 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();

 private:
    ASRockASRRGBSMBusController* controller;
+    std::vector<unsigned int>    led_values;
 };
@@ -36,7 +36,7 @@ ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()

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

 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -267,7 +269,6 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
            new_zone->leds_min      = 1;
            new_zone->leds_max      = 1;
            new_zone->leds_count    = 1;
-            new_zone->matrix_map    = NULL;

            if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
            {
@@ -284,23 +285,22 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
            led*    new_led         = new led();

            new_led->name           = polychrome_v1_zone_names[zone_idx];
-            new_led->value          = zone_idx;

            /*---------------------------------------------------------*\
            | Push new LED to LEDs vector                               |
            \*---------------------------------------------------------*/
            leds.push_back(*new_led);
            zoneIndexMap.push_back(zone_idx);
+            led_values.push_back(zone_idx);
        }
    }

    SetupColors();
 }

-void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
+void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
 {
-    LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
-    controller-> SetARGBSize(new_size & 0xFF);
+    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
    zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }

@@ -309,19 +309,19 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
    LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
    for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
    {
-        UpdateSingleLED(zone_idx);
+        DeviceUpdateSingleLED(zone_idx);
    }
 }

-void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateZoneLEDs(int /*zone*/)
 {
-    LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
+    LOG_TRACE("[%s] DeviceUpdateZoneLEDs()", name.c_str());
    DeviceUpdateLEDs();
 }

-void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
+void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateSingleLED(int zone)
 {
-    LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
+    LOG_TRACE("[%s] DeviceUpdateSingleLED(%02X)", name.c_str(), zone);

    uint8_t red = RGBGetRValue(colors[zone]);
    uint8_t grn = RGBGetGValue(colors[zone]);
@@ -338,7 +338,7 @@ void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
        for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
        {
            controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
-            UpdateSingleLED(zone_idx);
+            DeviceUpdateSingleLED(zone_idx);
        }
    }
    else
@@ -23,16 +23,18 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

 private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
+    ASRockPolychromeV1SMBusController*  controller;
+    std::vector<unsigned int>           led_values;
+    std::vector<uint8_t>                zoneIndexMap;
+
+    uint8_t                             getModeIndex(uint8_t mode_value);
 };
@@ -37,7 +37,7 @@ ASRockPolychromeV2SMBusController::~ASRockPolychromeV2SMBusController()

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

 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -229,8 +231,6 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                new_zone->type          = ZONE_TYPE_SINGLE;
            }

-            new_zone->matrix_map        = NULL;
-
            /*---------------------------------------------------------*\
            | Push new zone to zones vector                             |
            \*---------------------------------------------------------*/
@@ -256,11 +256,14 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
                new_led->name           = polychrome_v2_zone_names[zone_idx];

                new_led->name.append(" " + std::to_string(led_idx + 1));
-                new_led->value = 0;

                if(zone_idx == POLYCHROME_V2_ZONE_ADDRESSABLE)
                {
-                    new_led->value              = 0x19;
+                    led_values.push_back(0x19);
+                }
+                else
+                {
+                    led_values.push_back(0);
                }

                /*---------------------------------------------------------*\
@@ -281,7 +284,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
    SetupColors();
 }

-void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
 {
    /*---------------------------------------------------------*\
    | This device does not support resizing zones               |
@@ -292,16 +295,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]);
@@ -311,9 +314,9 @@ void RGBController_ASRockPolychromeV2SMBus::UpdateSingleLED(int led)
    | If the LED value is non-zero, this LED overrides the LED  |
    | index                                                     |
    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
+    if(led_values[led] != 0)
    {
-        led = leds[led].value;
+        led = led_values[led];
    }

    controller->SetColorsAndSpeed(led, red, grn, blu);
@@ -23,14 +23,15 @@ public:

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
+    void        DeviceConfigureZone(int zone_idx);

    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

 private:
-    ASRockPolychromeV2SMBusController* controller;
+    ASRockPolychromeV2SMBusController*  controller;
+    std::vector<unsigned int>           led_values;
 };
@@ -11,7 +11,7 @@
 \*---------------------------------------------------------*/

 #include <vector>
-#include "Detector.h"
+#include "DetectionManager.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
@@ -22,15 +22,6 @@
 #include "i2c_smbus.h"
 #include "pci_ids.h"

-/*******************************************************************************************\
-*                                                                                           *
-*   TestForPolychromeSMBusController                                                        *
-*                                                                                           *
-*       Tests the given address to see if an ASRock RGB controller exists there.            *
-*       First does a quick write to test for a response                                     *
-*                                                                                           *
-\*******************************************************************************************/
-
 #define ASROCK_DETECTOR_NAME        "ASRock SMBus Detectector"
 #define VENDOR_NAME                 "ASRock"
 #define SMBUS_ADDRESS               0x6A
@@ -67,7 +58,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, uint8_t address)

    return(pass);

-}   /* TestForPolychromeController() */
+}

 uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
 {
@@ -94,64 +85,54 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
    }
 }

-/******************************************************************************************\
-*                                                                                          *
-*   DetectPolychromeControllers                                                            *
-*                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
-*           dev - I2C address of Polychrome device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
 {
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    DetectedControllers detected_controllers;
+
+    for(unsigned int bus = 0; bus < buses.size(); bus++)
    {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        IF_MOBO_SMBUS(buses[bus]->info.pci_vendor, buses[bus]->info.pci_device)
        {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(buses[bus]->info.pci_subsystem_vendor == ASROCK_SUB_VEN)
            {
                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
                {
                    LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);

                    u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);

-                    switch (version.msb)
+                    switch(version.msb)
                    {
                        case ASROCK_TYPE_ASRLED:
                            {
                                LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

                            case ASROCK_TYPE_POLYCHROME_V1:
                            {
                                LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

                            case ASROCK_TYPE_POLYCHROME_V2:
                            {
                                LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
                                controller-> fw_version = version.u16;
                                RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
-                                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                                detected_controllers.push_back(rgb_controller);
                            }
                            break;

@@ -172,6 +153,7 @@ void DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
        }
    }

-}   /* DetectSMBusPolychromeControllers() */
+    return(detected_controllers);
+}

 REGISTER_I2C_DETECTOR("ASRock Motherboard SMBus Controllers", DetectASRockSMBusControllers);
@@ -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);
@@ -125,6 +125,13 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
    controller->UpdateDim();
 }

+RGBController_Alienware::~RGBController_Alienware()
+{
+    Shutdown();
+
+    delete controller;
+}
+
 void RGBController_Alienware::SetupZones()
 {
    /*-------------------------------------------------*\
@@ -141,7 +148,6 @@ void RGBController_Alienware::SetupZones()
        new_zone.leds_min   = 1;
        new_zone.leds_max   = 1;
        new_zone.leds_count = 1;
-        new_zone.matrix_map = nullptr;

        zones.emplace_back(new_zone);
    }
@@ -158,26 +164,19 @@ void RGBController_Alienware::SetupZones()
    SetupColors();
 }

-void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_Alienware::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Alienware::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_Alienware::UpdateSingleLED(int led)
+void RGBController_Alienware::DeviceUpdateSingleLED(int led)
 {
-    UpdateZoneLEDs(led);
+    DeviceUpdateZoneLEDs(led);
 }

 static bool modes_eq(const mode& mode1, const mode& mode2)
@@ -19,14 +19,13 @@ class RGBController_Alienware : public RGBController
 {
 public:
    RGBController_Alienware(AlienwareController* controller_ptr);
+    ~RGBController_Alienware();

    void        SetupZones();

-    void        ResizeZone(int zone, int new_size);
-
    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    void        DeviceUpdateZoneLEDs(int zone);
+    void        DeviceUpdateSingleLED(int led);

    void        DeviceUpdateMode();

@@ -319,7 +319,7 @@ void AlienwareAW410KController::SetMode
    SendCommit();
 }

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

-    void        UpdateSingleLED
+    void        DeviceUpdateSingleLED
                    (
                    unsigned char   led,
                    unsigned char   red,
@@ -278,16 +278,7 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont

 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
+    Shutdown();

    delete controller;
 }
@@ -310,14 +301,7 @@ void RGBController_AlienwareAW410K::SetupZones()

        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 6;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map.Set(6, 24, (unsigned int *)&matrix_map);
        }

        zones.push_back(new_zone);
@@ -329,20 +313,13 @@ void RGBController_AlienwareAW410K::SetupZones()
    {
        led new_led;
        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
+        led_values.push_back(led_names[led_idx].idx);
        leds.push_back(new_led);
    }

    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;
@@ -352,14 +329,14 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()

    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
    {
-            SelectedButtons key;
+        SelectedButtons key;

-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
+        key.idx     = led_values[led_idx];
+        key.red     = RGBGetRValue(colors[led_idx]);
+        key.green   = RGBGetGValue(colors[led_idx]);
+        key.blue    = RGBGetBValue(colors[led_idx]);

-            frame_buf_keys.push_back(key);
+        frame_buf_keys.push_back(key);
    }

    controller->SendInitialize();
@@ -374,21 +351,21 @@ void RGBController_AlienwareAW410K::DeviceUpdateLEDs()
    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
 }

-void RGBController_AlienwareAW410K::UpdateZoneLEDs(int zone)
+void RGBController_AlienwareAW410K::DeviceUpdateZoneLEDs(int zone)
 {
    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
 }

-void RGBController_AlienwareAW410K::UpdateSingleLED(int led)
+void RGBController_AlienwareAW410K::DeviceUpdateSingleLED(int led)
 {
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
+    controller->DeviceUpdateSingleLED(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }

 void RGBController_AlienwareAW410K::DeviceUpdateMode()
 {
    if(active_mode == 0xFFFF)
    {
-        UpdateLEDs();
+        UpdateLEDsInternal();
        return;
    }

@@ -23,15 +23,14 @@ 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();

 private:
    AlienwareAW410KController*  controller;
    std::vector<RGBColor>       current_colors;
+    std::vector<unsigned char>  led_values;
 };
@@ -318,7 +318,7 @@ void AlienwareAW510KController::SetMode
    SendCommit();
 }

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

-    void        UpdateSingleLED
+    void        DeviceUpdateSingleLED
                    (
                    unsigned char   led,
                    unsigned char   red,
@@ -277,16 +277,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont

 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
+    Shutdown();

    delete controller;
 }
@@ -309,14 +300,7 @@ void RGBController_AlienwareAW510K::SetupZones()

        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 7;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map.Set(7, 24, (unsigned int *)&matrix_map);
        }

        zones.push_back(new_zone);
@@ -328,20 +312,13 @@ void RGBController_AlienwareAW510K::SetupZones()
    {
        led new_led;
        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
+        led_values.push_back(led_names[led_idx].idx);
        leds.push_back(new_led);
    }

    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;
@@ -351,7 +328,7 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()

    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
    {
-        if (current_colors[led_idx]==new_colors[led_idx])
+        if(current_colors[led_idx] == new_colors[led_idx])
        {
            /*-------------------------------------------------*\
            | Don't send if key color is not changed            |
@@ -359,28 +336,14 @@ void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
            continue;
        }

-        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
-        {
-            SelectedKeys key;
+        SelectedKeys key;

-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
+        key.idx     = led_values[led_idx];
+        key.red     = RGBGetRValue(colors[led_idx]);
+        key.green   = RGBGetGValue(colors[led_idx]);
+        key.blue    = RGBGetBValue(colors[led_idx]);

-            frame_buf_keys.push_back(key);
-        }
-        else
-        {
-            SelectedKeys key;
-
-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
-
-            frame_buf_keys.push_back(key);
-        }
+        frame_buf_keys.push_back(key);
    }

    controller->SendInitialize();
@@ -395,21 +358,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(led_values[led], RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
 }

 void RGBController_AlienwareAW510K::DeviceUpdateMode()
 {
    if(active_mode == 0xFFFF)
    {
-        UpdateLEDs();
+        UpdateLEDsInternal();
        return;
    }

@@ -22,15 +22,14 @@ 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();

 private:
    AlienwareAW510KController*  controller;
    std::vector<RGBColor>       current_colors;
+    std::vector<unsigned char>  led_values;
 };
@@ -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);
@@ -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);
@@ -11,6 +11,13 @@

 #include "RGBController_AlienwareAW3423DWF.h"

+static const unsigned char led_values[] =
+{
+    0x01,
+    0x02,
+    0x08
+};
+
 /**------------------------------------------------------------------*\
    @name AW3423DWF
    @category Accessory
@@ -46,6 +53,8 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34

 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -57,12 +66,10 @@ 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;
    Logo_LED.name           = "Logo";
-    Logo_LED.value          = 0x01;
    leds.push_back(Logo_LED);

    zone Number;
@@ -71,12 +78,10 @@ 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;
    Number_LED.name         = "Number";
-    Number_LED.value        = 0x02;
    leds.push_back(Number_LED);

    zone PowerButton;
@@ -85,21 +90,15 @@ 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;
    PowerButton_LED.name    = "Power Button";
-    PowerButton_LED.value   = 0x08;
    leds.push_back(PowerButton_LED);

    SetupColors();
 }

-void RGBController_AlienwareAW3423DWF::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-}
-
 void RGBController_AlienwareAW3423DWF::DeviceUpdateLEDs()
 {
    /*-----------------------------------------------------*\
@@ -118,22 +117,22 @@ 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]);
    unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(leds[led].value, red, grn, blu);
+    controller->SendColor(led_values[led], red, grn, blu);
 }

 void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()
@@ -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();

@@ -11,6 +11,13 @@

 #include "RGBController_AlienwareMonitor.h"

+static const unsigned char led_values[] =
+{
+    0x01,
+    0x02,
+    0x08
+};
+
 /**------------------------------------------------------------------*\
    @name Alienware Monitor
    @category Accessory
@@ -46,6 +53,8 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC

 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -57,12 +66,10 @@ 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;
    Logo_LED.name           = "Logo";
-    Logo_LED.value          = 0x01;
    leds.push_back(Logo_LED);

    zone Number;
@@ -71,12 +78,10 @@ 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;
    Number_LED.name         = "Number";
-    Number_LED.value        = 0x02;
    leds.push_back(Number_LED);

    zone PowerButton;
@@ -85,22 +90,15 @@ 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;
    PowerButton_LED.name    = "Power Button";
-    PowerButton_LED.value   = 0x08;
    leds.push_back(PowerButton_LED);

    SetupColors();
 }

-void RGBController_AlienwareMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AlienwareMonitor::DeviceUpdateLEDs()
 {
    /*-----------------------------------------------------*\
@@ -119,22 +117,22 @@ 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]);
    unsigned char blu = RGBGetBValue(colors[led]);
-    controller->SendColor(leds[led].value, red, grn, blu);
+    controller->SendColor(led_values[led], red, grn, blu);
 }

 void RGBController_AlienwareMonitor::DeviceUpdateMode()
@@ -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();

@@ -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);
@@ -38,76 +38,69 @@ static const unsigned int zone_sizes[] =
    LED_COUNT,
 };

-typedef struct
+static const char* led_names[] =
 {
-    const char *        name;
-    const unsigned char idx;
-} annepro2_led_type;
-
-static const annepro2_led_type led_names[] =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0       },
-    { KEY_EN_1,                 1       },
-    { KEY_EN_2,                 2       },
-    { KEY_EN_3,                 3       },
-    { KEY_EN_4,                 4       },
-    { KEY_EN_5,                 5       },
-    { KEY_EN_6,                 6       },
-    { KEY_EN_7,                 7       },
-    { KEY_EN_8,                 8       },
-    { KEY_EN_9,                 9       },
-    { KEY_EN_0,                 10      },
-    { KEY_EN_MINUS,             11      },
-    { KEY_EN_EQUALS,            12      },
-    { KEY_EN_BACKSPACE,         13      },
-    { KEY_EN_TAB,               14      },
-    { KEY_EN_Q,                 15      },
-    { KEY_EN_W,                 16      },
-    { KEY_EN_E,                 17      },
-    { KEY_EN_R,                 18      },
-    { KEY_EN_T,                 19      },
-    { KEY_EN_Y,                 20      },
-    { KEY_EN_U,                 21      },
-    { KEY_EN_I,                 22      },
-    { KEY_EN_O,                 23      },
-    { KEY_EN_P,                 24      },
-    { KEY_EN_LEFT_BRACKET,      25      },
-    { KEY_EN_RIGHT_BRACKET,     26      },
-    { KEY_EN_ANSI_BACK_SLASH,   27      },
-    { KEY_EN_CAPS_LOCK,         28      },
-    { KEY_EN_A,                 29      },
-    { KEY_EN_S,                 30      },
-    { KEY_EN_D,                 31      },
-    { KEY_EN_F,                 32      },
-    { KEY_EN_G,                 33      },
-    { KEY_EN_H,                 34      },
-    { KEY_EN_J,                 35      },
-    { KEY_EN_K,                 36      },
-    { KEY_EN_L,                 37      },
-    { KEY_EN_SEMICOLON,         38      },
-    { KEY_EN_QUOTE,             39      },
-    { KEY_EN_ANSI_ENTER,        40      },
-    { KEY_EN_LEFT_SHIFT,        41      },
-    { KEY_EN_Z,                 42      },
-    { KEY_EN_X,                 43      },
-    { KEY_EN_C,                 44      },
-    { KEY_EN_V,                 45      },
-    { KEY_EN_B,                 46      },
-    { KEY_EN_N,                 47      },
-    { KEY_EN_M,                 48      },
-    { KEY_EN_COMMA,             49      },
-    { KEY_EN_PERIOD,            50      },
-    { KEY_EN_FORWARD_SLASH,     51      },
-    { KEY_EN_RIGHT_SHIFT,       52      },
-    { KEY_EN_LEFT_CONTROL,      53      },
-    { KEY_EN_LEFT_WINDOWS,      54      },
-    { KEY_EN_LEFT_ALT,          55      },
-    { KEY_EN_SPACE,             56      },
-    { KEY_EN_RIGHT_ALT,         57      },
-    { KEY_EN_RIGHT_FUNCTION,    58      },
-    { KEY_EN_MENU,              59      },
-    { KEY_EN_RIGHT_CONTROL,     60      },
+    KEY_EN_ESCAPE,
+    KEY_EN_1,
+    KEY_EN_2,
+    KEY_EN_3,
+    KEY_EN_4,
+    KEY_EN_5,
+    KEY_EN_6,
+    KEY_EN_7,
+    KEY_EN_8,
+    KEY_EN_9,
+    KEY_EN_0,
+    KEY_EN_MINUS,
+    KEY_EN_EQUALS,
+    KEY_EN_BACKSPACE,
+    KEY_EN_TAB,
+    KEY_EN_Q,
+    KEY_EN_W,
+    KEY_EN_E,
+    KEY_EN_R,
+    KEY_EN_T,
+    KEY_EN_Y,
+    KEY_EN_U,
+    KEY_EN_I,
+    KEY_EN_O,
+    KEY_EN_P,
+    KEY_EN_LEFT_BRACKET,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_ANSI_BACK_SLASH,
+    KEY_EN_CAPS_LOCK,
+    KEY_EN_A,
+    KEY_EN_S,
+    KEY_EN_D,
+    KEY_EN_F,
+    KEY_EN_G,
+    KEY_EN_H,
+    KEY_EN_J,
+    KEY_EN_K,
+    KEY_EN_L,
+    KEY_EN_SEMICOLON,
+    KEY_EN_QUOTE,
+    KEY_EN_ANSI_ENTER,
+    KEY_EN_LEFT_SHIFT,
+    KEY_EN_Z,
+    KEY_EN_X,
+    KEY_EN_C,
+    KEY_EN_V,
+    KEY_EN_B,
+    KEY_EN_N,
+    KEY_EN_M,
+    KEY_EN_COMMA,
+    KEY_EN_PERIOD,
+    KEY_EN_FORWARD_SLASH,
+    KEY_EN_RIGHT_SHIFT,
+    KEY_EN_LEFT_CONTROL,
+    KEY_EN_LEFT_WINDOWS,
+    KEY_EN_LEFT_ALT,
+    KEY_EN_SPACE,
+    KEY_EN_RIGHT_ALT,
+    KEY_EN_RIGHT_FUNCTION,
+    KEY_EN_MENU,
+    KEY_EN_RIGHT_CONTROL,
 };

 /**------------------------------------------------------------------*\
@@ -144,6 +137,8 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt

 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -164,14 +159,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);
@@ -182,21 +170,13 @@ void RGBController_AnnePro2::SetupZones()
    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
    {
        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
+        new_led.name  = led_names[led_idx];
        leds.push_back(new_led);
    }

    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;
@@ -206,7 +186,7 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
    | TODO: Send packets with multiple LED frames               |
    \*---------------------------------------------------------*/
    std::size_t led_real_idx = 0;
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    for(std::size_t led_idx = 0; led_idx < colors.size(); led_idx++)
    {
        frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
        frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
@@ -228,12 +208,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();
 }
@@ -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();

@@ -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);
@@ -55,6 +55,8 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)

 RGBController_Arctic::~RGBController_Arctic()
 {
+    Shutdown();
+
    keepalive_thread_run = false;
    keepalive_thread.join();
    delete controller;
@@ -70,11 +72,9 @@ 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";
-        Led.value   = channel;

        zones.push_back(LedZone);
        leds.push_back(Led);
@@ -83,13 +83,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 +90,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 +116,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
@@ -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();

@@ -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);
@@ -125,6 +125,8 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)

 RGBController_Areson::~RGBController_Areson()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -137,7 +139,6 @@ void RGBController_Areson::SetupZones()
    new_zone.leds_min   = 1;
    new_zone.leds_max   = 1;
    new_zone.leds_count = 1;
-    new_zone.matrix_map = nullptr;

    zones.emplace_back(new_zone);

@@ -150,24 +151,17 @@ void RGBController_Areson::SetupZones()
    SetupColors();
 }

-void RGBController_Areson::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_Areson::DeviceUpdateLEDs()
 {
    DeviceUpdateMode();
 }

-void RGBController_Areson::UpdateZoneLEDs(int /*zone*/)
+void RGBController_Areson::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateMode();
 }

-void RGBController_Areson::UpdateSingleLED(int /*led*/)
+void RGBController_Areson::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateMode();
 }
@@ -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();

@@ -45,6 +45,13 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
    SetupZones();
 }

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

-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupZones()
 {
    zone auraZone;
@@ -186,7 +188,6 @@ void RGBController_AuraCore::SetupZones()
        auraZone.leds_min   = 4;
        auraZone.leds_max   = 4;
        auraZone.leds_count = 4;
-        auraZone.matrix_map = NULL;
    }
    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
    {
@@ -195,7 +196,6 @@ void RGBController_AuraCore::SetupZones()
        auraZone.leds_min   = 20;
        auraZone.leds_max   = 20;
        auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
    }
    else
    {
@@ -215,19 +215,12 @@ void RGBController_AuraCore::SetupZones()
    SetupColors();
 }

-void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraCore::DeviceUpdateLEDs()
 {
-    UpdateZoneLEDs(0);
+    DeviceUpdateZoneLEDs(0);
 }

-void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraCore::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
    {
@@ -256,16 +249,16 @@ void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
    {
        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
        {
-            UpdateSingleLED(led_idx);
+            DeviceUpdateSingleLED(led_idx);
        }
    }
    else
    {
-        UpdateSingleLED(0);
+        DeviceUpdateSingleLED(0);
    }
 }

-void RGBController_AuraCore::UpdateSingleLED(int led)
+void RGBController_AuraCore::DeviceUpdateSingleLED(int led)
 {
    unsigned char speed = 0xFF;
    unsigned char red   = 0;
@@ -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();

@@ -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);
 }


@@ -11,6 +11,7 @@

 #include "AsusAuraCoreLaptopController.h"
 #include "dmiinfo.h"
+#include "ResourceManager.h"
 #include "SettingsManager.h"
 #include "StringUtils.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"

@@ -263,11 +263,13 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL

    SetupZones();

-    SetMode(active_mode);
+    SetActiveMode(active_mode);
 }

 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -339,18 +341,7 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                    else
                    {
                        new_zone.type               = ZONE_TYPE_MATRIX;
-                        matrix_map_type * new_map   = new matrix_map_type;
-                        new_zone.matrix_map         = new_map;
-
-                        /*---------------------------------------------------------*\
-                        | Trusting the layout handed to the KLM is correct use the  |
-                        |   row & column counts to set the matrix height & width    |
-                        \*---------------------------------------------------------*/
-                        new_map->height             = new_kb.GetRowCount();
-                        new_map->width              = new_kb.GetColumnCount();
-                        new_map->map                = new unsigned int[new_map->height * new_map->width];
-
-                        new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
+                        new_zone.matrix_map         = new_kb.GetKeyMap(KEYBOARD_MAP_FILL_TYPE_COUNT);
                    }

                    /*---------------------------------------------------------*\
@@ -360,11 +351,14 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()
                    new_zone.leds_count             = new_kb.GetKeyCount();
                    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
                    {
-                        led new_led;
+                        led             new_led;
+                        unsigned int    new_led_value;

                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-                        max_led_value               = std::max(max_led_value, new_led.value);
+                        new_led_value               = new_kb.GetKeyValueAt(led_idx);
+                        max_led_value               = std::max(max_led_value, new_led_value);
+
+                        led_values.push_back(new_led_value);
                        leds.push_back(new_led);
                    }
                }
@@ -394,40 +388,21 @@ void RGBController_AsusAuraCoreLaptop::SetupZones()

    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
    {
-        buffer_map[leds[led_idx].value] = &colors[led_idx];
+        buffer_map[led_values[led_idx]] = &colors[led_idx];
    }
 }

-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++)
-    {
-        LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
-                  name.c_str(),
-                  leds[i].name.c_str(),
-                  i,
-                  leds[i].value,
-                  RGBGetRValue(colors[i]),
-                  RGBGetGValue(colors[i]),
-                  RGBGetBValue(colors[i]));
-    }
-
    controller->SetLedsDirect(buffer_map);
 }

-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);
 }
@@ -23,17 +23,17 @@ 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();

 private:
    RGBColor                            null_color              = 0;
    std::vector<RGBColor *>             buffer_map;
+    std::vector<unsigned int>           led_values;

    AsusAuraCoreLaptopController*       controller;
 };
@@ -32,7 +32,7 @@ std::string AuraGPUController::GetDeviceName()

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

 bool AuraGPUController::SaveOnlyApplies()
 {
-    switch (bus->pci_subsystem_device)
+    switch (bus->info.pci_subsystem_device)
    {
        case ASUS_VEGA64_STRIX:
            return false;
@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/

-#include "Detector.h"
+#include "DetectionManager.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
 #include "RGBController_AsusAuraGPU.h"
@@ -19,17 +19,9 @@

 #define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"

-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraGPUController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Aura GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
 bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
 {
-    if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
+    if(bus->info.pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
    {
        return false;
    }
@@ -48,31 +40,26 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres

    return(pass);

-}   /* TestForAuraGPUController() */
+}

-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraGPUControllers                                                               *
-*                                                                                          *
-*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
+DetectedControllers DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
 {
+    DetectedControllers detected_controllers;
+
    if(TestForAsusAuraGPUController(bus, i2c_addr))
    {
        AuraGPUController*     controller     = new AuraGPUController(bus, i2c_addr, name);
        RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);

-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+        detected_controllers.push_back(rgb_controller);
    }
-} /* DetectAsusAuraGPUControllers() */

-/*-----------------------------------------*\
-|  Nvidia GPUs                              |
-\*-----------------------------------------*/
+    return(detected_controllers);
+}

+/*---------------------------------------------------------*\
+|  Nvidia GPUs                                              |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
@@ -131,10 +118,9 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti A11G Gaming",
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
 REGISTER_I2C_PCI_DETECTOR("ASUS TUF GeForce RTX 3060 Ti Gaming OC",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060TI_O8G_OC,                 0x2A);

-/*-----------------------------------------*\
-|  AMD GPUs                                 |
-\*-----------------------------------------*/
-
+/*---------------------------------------------------------*\
+|  AMD GPUs                                                 |
+\*---------------------------------------------------------*/
 REGISTER_I2C_PCI_DETECTOR("ASUS AREZ STRIX Radeon RX Vega 56 Gaming OC",           DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon Vega 64",                         DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
 REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 470 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
@@ -124,6 +124,8 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)

 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -138,7 +140,6 @@ void RGBController_AuraGPU::SetupZones()
    aura_gpu_zone.leds_min      = 1;
    aura_gpu_zone.leds_max      = 1;
    aura_gpu_zone.leds_count    = 1;
-    aura_gpu_zone.matrix_map    = NULL;
    zones.push_back(aura_gpu_zone);

    /*---------------------------------------------------------*\
@@ -160,13 +161,6 @@ void RGBController_AuraGPU::SetupZones()
    colors[0] =  ToRGBColor(red, grn, blu);
 }

-void RGBController_AuraGPU::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraGPU::DeviceUpdateLEDs()
 {
    for(std::size_t led = 0; led < colors.size(); led++)
@@ -177,18 +171,18 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()

        controller->SetLEDColors(red, grn, blu);
    }
-    if (controller->SaveOnlyApplies() && GetMode() != 0)
+    if (controller->SaveOnlyApplies() && GetActiveMode() != 0)
    {
        controller->Save();
    }
 }

-void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraGPU::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
+void RGBController_AuraGPU::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -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();
@@ -112,6 +112,8 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC

 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -124,7 +126,6 @@ void RGBController_AuraHeadsetStand::SetupZones()
    underglow_zone.leds_min     = 17;
    underglow_zone.leds_max     = 17;
    underglow_zone.leds_count   = 17;
-    underglow_zone.matrix_map   = NULL;

    zones.push_back(underglow_zone);

@@ -144,7 +145,6 @@ void RGBController_AuraHeadsetStand::SetupZones()
    logo_zone.leds_min          = 1;
    logo_zone.leds_max          = 1;
    logo_zone.leds_count        = 1;
-    logo_zone.matrix_map        = NULL;

    zones.push_back(logo_zone);

@@ -157,24 +157,17 @@ void RGBController_AuraHeadsetStand::SetupZones()
    SetupColors();
 }

-void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
 {
    controller->UpdateLeds(std::vector<RGBColor>(colors));
 }

-void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraHeadsetStand::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
+void RGBController_AuraHeadsetStand::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -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();
@@ -380,13 +380,7 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c

 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
-        {
-            delete zones[zone_idx].matrix_map;
-        }
-    }
+    Shutdown();

    delete controller;
 }
@@ -407,7 +401,7 @@ void RGBController_AuraKeyboard::SetupZones()
        \*-----------------------------------------------------*/
        case SCOPE_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&scope_matrix_map)});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
@@ -415,7 +409,7 @@ void RGBController_AuraKeyboard::SetupZones()

        case SCOPE_RX_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&scope_matrix_map)});
            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});

            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
@@ -425,7 +419,7 @@ void RGBController_AuraKeyboard::SetupZones()

        case SCOPE_TKL_LAYOUT:
            led_names = default_tkl_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 86, new matrix_map_type(6, 18, (unsigned int *)&scope_tkl_matrix_map)});
            led_zones.push_back({"Logo",                ZONE_TYPE_LINEAR, 2, NULL});
            led_zones.push_back({"Underglow",           ZONE_TYPE_LINEAR, 26, NULL});

@@ -435,7 +429,7 @@ void RGBController_AuraKeyboard::SetupZones()

        case FLARE_LAYOUT:
            led_names = default_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 106, new matrix_map_type(6, 22, (unsigned int *)&flare_matrix_map)});
            led_zones.push_back({"Logo",                ZONE_TYPE_SINGLE, 1, NULL});
            led_zones.push_back({"Underglow",           ZONE_TYPE_SINGLE, 2, NULL});

@@ -449,7 +443,7 @@ void RGBController_AuraKeyboard::SetupZones()

        case FALCHION_LAYOUT:
            led_names = default_65pct_led_names;
-            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
+            led_zones.push_back({ZONE_EN_KEYBOARD,      ZONE_TYPE_MATRIX, 68, new matrix_map_type(5, 16, (unsigned int *)&falchion_matrix_map)});
            break;
    }

@@ -463,13 +457,9 @@ void RGBController_AuraKeyboard::SetupZones()
        new_zone.leds_max               = led_zones[zone_idx].size;
        new_zone.leds_count             = led_zones[zone_idx].size;

-        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
+        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX && led_zones[zone_idx].matrix != NULL)
        {
-            new_zone.matrix_map         = led_zones[zone_idx].matrix;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
+            new_zone.matrix_map         = *led_zones[zone_idx].matrix;
        }

        zones.push_back(new_zone);
@@ -481,21 +471,14 @@ void RGBController_AuraKeyboard::SetupZones()
    {
        led new_led;
        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;

+        led_values.push_back(led_names[led_idx].idx);
        leds.push_back(new_led);
    }

    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;
@@ -510,7 +493,7 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
    \*---------------------------------------------------------*/
    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
    {
-        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
+        frame_buf[(led_idx * 4) + 0] = led_values[led_idx];
        frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
        frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
        frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
@@ -519,12 +502,12 @@ void RGBController_AuraKeyboard::DeviceUpdateLEDs()
    controller->SendDirect((unsigned char)leds.size(), frame_buf.data());
 }

-void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraKeyboard::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
+void RGBController_AuraKeyboard::DeviceUpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }
@@ -45,15 +45,14 @@ 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();

 private:
    AuraKeyboardController*         controller;
    AuraKeyboardMappingLayoutType   layout;
+    std::vector<unsigned char>      led_values;
 };
@@ -45,6 +45,8 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont

 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -57,7 +59,6 @@ void RGBController_AuraMonitor::SetupZones()
    underglow_zone.leds_min     = 3;
    underglow_zone.leds_max     = 3;
    underglow_zone.leds_count   = 3;
-    underglow_zone.matrix_map   = NULL;

    zones.push_back(underglow_zone);

@@ -73,13 +74,6 @@ void RGBController_AuraMonitor::SetupZones()
    SetupColors();
 }

-void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraMonitor::DeviceUpdateLEDs()
 {
    controller->BeginUpdate();
@@ -96,12 +90,12 @@ void RGBController_AuraMonitor::DeviceUpdateLEDs()
    controller->ApplyChanges();
 }

-void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMonitor::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AuraMonitor::UpdateSingleLED(int led)
+void RGBController_AuraMonitor::DeviceUpdateSingleLED(int led)
 {
    controller->BeginUpdate();

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

 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -199,26 +201,20 @@ 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);

        led mouse_led;

        mouse_led.name          = mouse_zone.name + " LED";
-        mouse_led.value         = *zone_it;

+        led_values.push_back(*zone_it);
        leds.push_back(mouse_led);
    }

    SetupColors();
 }

-void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
 void RGBController_AuraMouse::DeviceUpdateLEDs()
 {
    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
@@ -229,17 +225,17 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
    {
        for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
        {
-            UpdateSingleLED(zone_index);
+            DeviceUpdateSingleLED(zone_index);
        }
    }
 }

-void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMouse::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AuraMouse::UpdateSingleLED(int led)
+void RGBController_AuraMouse::DeviceUpdateSingleLED(int led)
 {
    if(modes[active_mode].value == AURA_MOUSE_MODE_DIRECT)
    {
@@ -251,7 +247,7 @@ void RGBController_AuraMouse::UpdateSingleLED(int led)
    uint8_t grn = RGBGetGValue(colors[led]);
    uint8_t blu = RGBGetBValue(colors[led]);

-    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
+    controller->SendUpdate(led_values[led], modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
 }

 void RGBController_AuraMouse::DeviceUpdateMode()
@@ -22,16 +22,15 @@ 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();

 private:
    AuraMouseController*  controller;
+    std::vector<uint8_t>  led_values;
    uint16_t              pid;
 };
@@ -116,6 +116,8 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro

 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -133,14 +135,12 @@ 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);

        led spatha_led;

        spatha_led.name          = zones_names[i];
-        spatha_led.value         = 1;

        leds.push_back(spatha_led);
    }
@@ -148,11 +148,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 +156,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 +170,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)
    {
@@ -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();
@@ -79,6 +79,8 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse

 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -91,36 +93,29 @@ 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);

    led mouse_led;

    mouse_led.name          = "Underglow";
-    mouse_led.value         = 1;

    leds.push_back(mouse_led);

    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]));
@@ -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();
@@ -182,6 +182,8 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c

 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -194,7 +196,6 @@ void RGBController_AuraMousemat::SetupZones()
    mousemat_zone.leds_min     = 15;
    mousemat_zone.leds_max     = 15;
    mousemat_zone.leds_count   = 15;
-    mousemat_zone.matrix_map   = NULL;

    zones.push_back(mousemat_zone);

@@ -210,24 +211,17 @@ void RGBController_AuraMousemat::SetupZones()
    SetupColors();
 }

-void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
 void RGBController_AuraMousemat::DeviceUpdateLEDs()
 {
    controller->UpdateLeds(std::vector<RGBColor>(colors));
 }

-void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AuraMousemat::DeviceUpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

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

 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
@@ -128,6 +128,8 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont

 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
+    Shutdown();
+
    delete controller;
 }

@@ -161,7 +163,6 @@ void RGBController_AsusAuraRyuoAIO::SetupZones()

            new_led.name = zones[zone_idx].name;
            new_led.name.append(" LED " + std::to_string(lp_idx));
-            new_led.value = lp_idx;

            leds.push_back(new_led);
        }
@@ -171,29 +172,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()
@@ -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();

--- a/Show More
+++ b/Show More