Add XPG Spectrix S20G to detectors for S40G

2024-05-11 17:53:27 -05:00
3012 changed files with 366480 additions and 87696 deletions
@@ -1,21 +0,0 @@
-name: Issue Opened
-
-on:
-  issues:
-    types: [opened,reopened]
-
-jobs:
-  issue_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Greeting
-        run: gh issue comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            For any new issue please refer to https://gitlab.com/CalcProgrammer1/OpenRGB/-/issues
@@ -1,21 +0,0 @@
-name: PR Opened
-
-on:
-  pull_request:
-    types: [opened,reopened]
-
-jobs:
-  pr_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Greeting
-        run: gh pr comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.pull_request.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            Please fork https://gitlab.com/CalcProgrammer1/OpenRGB/ and raise the appropriate merge request on Gitlab.
@@ -43,7 +43,6 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EVGAGP102GPUController/
 /Controllers/EVGAPascalGPUController/
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
-/Controllers/EVGASMBusController/                           @balika011
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
 /Controllers/EspurnaController/
@@ -23,9 +23,9 @@ Please add a link to the manufacturer's product page beneath this line
 ~"DeviceType::IDK" <!-- I Don't know -->
 ~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
 ~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
-~"DeviceType::GPU::Nvidia" <!-- The device is a Nvidia GPU -->
+~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
 ~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
-~"DeviceType::WMI"  <!-- The device is controlled through Windows Management Instrumentation -->
+~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->

 <!-- Please delete any lines that are not relevant -->

@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -75,7 +75,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
        /*---------------------------------------------*\
@@ -89,13 +89,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

            if (!success)
            {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -76,7 +76,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
        /*---------------------------------------------*\
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

            if (!success)
            {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -76,7 +76,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
        /*---------------------------------------------*\
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

            if (!success)
            {
-                LOG_ERROR("[AutoStart] An error occurred writing the auto start file.");
+                LOG_ERROR("An error occurred writing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -46,13 +46,13 @@ bool AutoStart::DisableAutoStart()

            if(!success)
            {
-                LOG_ERROR("[AutoStart] An error occurred removing the auto start file.");
+                LOG_ERROR("An error occurred removing the auto start file.");
            }
        }
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -124,7 +124,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return success;
@@ -1,243 +0,0 @@
-#-----------------------------------------------------------#
-# CMakeLists.txt                                            #
-#                                                           #
-#   CMake configuration for building OpenRGB                #
-#                                                           #
-#   Adam Honse (CalcProgrammer1)                24 May 2025 #
-#                                                           #
-#   This file is part of the OpenRGB project                #
-#   SPDX-License-Identifier: GPL-2.0-only                   #
-#-----------------------------------------------------------#
-
-cmake_minimum_required(VERSION 3.16)
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules")
-
-#-----------------------------------------------------------#
-# Project Definition                                        #
-#-----------------------------------------------------------#
-project(OpenRGB LANGUAGES CXX)
-
-#-----------------------------------------------------------#
-# Executable                                                #
-#-----------------------------------------------------------#
-add_executable(OpenRGB)
-
-#-----------------------------------------------------------#
-# CMake Configuration                                       #
-#-----------------------------------------------------------#
-set(CMAKE_CXX_STANDARD          17                          )
-set(CMAKE_CXX_STANDARD_REQUIRED ON                          )
-set(CMAKE_AUTOMOC               ON                          )
-set(CMAKE_AUTORCC               ON                          )
-set(CMAKE_AUTOUIC               ON                          )
-set(CMAKE_INCLUDE_CURRENT_DIR   ON                          )
-
-#-----------------------------------------------------------#
-# Qt Configuration                                          #
-#-----------------------------------------------------------#
-find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
-qt_standard_project_setup()
-
-#-----------------------------------------------------------#
-# Version                                                   #
-#-----------------------------------------------------------#
-set(MAJOR       "0"                                         )
-set(MINOR       "9"                                         )
-set(SUFFIX      "git"                                       )
-
-#-----------------------------------------------------------#
-# Git Information                                           #
-#-----------------------------------------------------------#
-set(LASTTAG     "release_${MAJOR}.${MINOR}"                 )
-
-execute_process(COMMAND git rev-parse --short=7 HEAD
-                OUTPUT_VARIABLE SHORTHASH
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(COMMAND git rev-list --count ${LASTTAG}..HEAD
-                OUTPUT_VARIABLE COMMITS
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(COMMAND sh ${CMAKE_SOURCE_DIR}/scripts/git-get-branch.sh
-                OUTPUT_VARIABLE GITBRANCH
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-#-----------------------------------------------------------#
-# Version Strings                                           #
-#-----------------------------------------------------------#
-set(VERSION_NUM "${MAJOR}.${MINOR}.${COMMITS}"              )
-set(VERSION_STR "${MAJOR}.${MINOR}"                         )
-
-set(VERSION_DEB ${VERSION_NUM}                              )
-set(VERSION_WIX ${VERSION_NUM}                              )
-set(VERSION_AUR ${VERSION_NUM}                              )
-set(VERSION_RPM ${VERSION_NUM}                              )
-
-#-----------------------------------------------------------#
-# If suffix is "git", use package-specific git versioning   #
-# Otherwise, append suffix if it is not empty               #
-#-----------------------------------------------------------#
-if("${SUFFIX}" STREQUAL "git")
-set(VERSION_STR "${VERSION_STR}+ (${SUFFIX}${COMMITS})"     )
-set(VERSION_DEB "${VERSION_DEB}~git${SHORTHASH}"            )
-set(VERSION_AUR "${VERSION_AUR}.g${SHORTHASH}"              )
-set(VERSION_RPM "${VERSION_RPM}^git${SHORTHASH}"            )
-elseif(NOT "${SUFFIX}" STREQUAL "")
-set(VERSION_STR "${VERSION_STR}+ (${SUFFIX})"               )
-set(VERSION_DEB "${VERSION_DEB}~${SUFFIX}"                  )
-set(VERSION_AUR "${VERSION_AUR}.${SUFFIX}"                  )
-set(VERSION_RPM "${VERSION_RPM}^${SUFFIX}"                  )
-endif()
-
-#-----------------------------------------------------------#
-# Print build configuration information                     #
-#-----------------------------------------------------------#
-message(STATUS "OpenRGB ${VERSION_STR} CMake Build"         )
-message(STATUS "-------------------------------------------")
-message(STATUS "  Last release tag:      ${LASTTAG}"        )
-message(STATUS "  Shorthash:             ${SHORTHASH}"      )
-message(STATUS "  Commits since release: ${COMMITS}"        )
-message(STATUS "  Git branch:            ${GITBRANCH}"      )
-message(STATUS "  Version:  Main:        ${VERSION_STR}"    )
-message(STATUS "            Windows:     ${VERSION_WIX}"    )
-message(STATUS "            Debian:      ${VERSION_DEB}"    )
-message(STATUS "            Arch (AUR):  ${VERSION_AUR}"    )
-message(STATUS "            Fedora:      ${VERSION_RPM}"    )
-
-#-----------------------------------------------------------#
-# Build list of controller headers, include directories,    #
-# and source files                                          #
-#-----------------------------------------------------------#
-file(GLOB_RECURSE children LIST_DIRECTORIES true
-    "${CMAKE_SOURCE_DIR}/Controllers/*"                     )
-
-foreach(child ${children})
-    if(IS_DIRECTORY ${curdir}/${child})
-        list(APPEND CONTROLLER_INC ${child})
-    endif()
-endforeach()
-
-file(GLOB_RECURSE CONTROLLER_H
-    "${CMAKE_SOURCE_DIR}/Controllers/*.h"                   )
-
-file(GLOB_RECURSE CONTROLLER_CPP
-    "${CMAKE_SOURCE_DIR}/Controllers/*.cpp"                 )
-
-#-----------------------------------------------------------#
-# Remove OS-specific files from the overall controller      #
-# headers and sources lists.  The suffixes _Windows, _Linux,#
-# _FreeBSD, and _MacOS are usable to denote that a file     #
-# only applies to one or more OSes.  The suffixes may be    #
-# combined such as <file>_Windows_Linux.cpp.                #
-#-----------------------------------------------------------#
-file(GLOB_RECURSE CONTROLLER_H_WINDOWS
-    "${CMAKE_SOURCE_DIR}/Controllers/*_Windows*.h"          )
-file(GLOB_RECURSE CONTROLLER_CPP_WINDOWS
-    "${CMAKE_SOURCE_DIR}/Controllers/*_Windows*.cpp"        )
-file(GLOB_RECURSE CONTROLLER_H_LINUX
-    "${CMAKE_SOURCE_DIR}/Controllers/*_Linux*.h"            )
-file(GLOB_RECURSE CONTROLLER_CPP_LINUX
-    "${CMAKE_SOURCE_DIR}/Controllers/*_Linux*.cpp"          )
-file(GLOB_RECURSE CONTROLLER_H_MACOS
-    "${CMAKE_SOURCE_DIR}/Controllers/*_MacOS*.h"            )
-file(GLOB_RECURSE CONTROLLER_CPP_MACOS
-    "${CMAKE_SOURCE_DIR}/Controllers/*_MacOS*.cpp"          )
-file(GLOB_RECURSE CONTROLLER_H_FREEBSD
-    "${CMAKE_SOURCE_DIR}/Controllers/*_FreeBSD*.h"          )
-file(GLOB_RECURSE CONTROLLER_CPP_FREEBSD
-    "${CMAKE_SOURCE_DIR}/Controllers/*_FreeBSD*.cpp"        )
-
-list(REMOVE_ITEM CONTROLLER_H   ${CONTROLLER_H_WINDOWS}     )
-list(REMOVE_ITEM CONTROLLER_CPP ${CONTROLLER_CPP_WINDOWS}   )
-list(REMOVE_ITEM CONTROLLER_H   ${CONTROLLER_H_LINUX}       )
-list(REMOVE_ITEM CONTROLLER_CPP ${CONTROLLER_CPP_LINUX}     )
-list(REMOVE_ITEM CONTROLLER_H   ${CONTROLLER_H_MACOS}       )
-list(REMOVE_ITEM CONTROLLER_CPP ${CONTROLLER_CPP_MACOS}     )
-list(REMOVE_ITEM CONTROLLER_H   ${CONTROLLER_H_FREEBSD}     )
-list(REMOVE_ITEM CONTROLLER_CPP ${CONTROLLER_CPP_FREEBSD}   )
-
-target_sources(OpenRGB PRIVATE ${CONTROLLER_CPP}            )
-target_include_directories(OpenRGB PRIVATE ${CONTROLLER_INC})
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/AutoStart)
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/dmiinfo)
-target_sources(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/dmiinfo/dmiinfo.cpp)
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/hidapi_wrapper)
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/i2c_smbus)
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/i2c_tools)
-target_sources(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/i2c_tools/i2c_tools.cpp)
-
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/interop)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/KeyboardLayoutManager)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/net_port)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/pci_ids)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/qt)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/RGBController)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/scsiapi)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/serial_port)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/SPDAccessor)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/super_io)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/SuspendResume)
-target_include_directories(OpenRGB PRIVATE ${CMAKE_SOURCE_DIR}/wmi)
-
-#-----------------------------------------------------------#
-# CRCpp                                                     #
-#-----------------------------------------------------------#
-set(CRCPP_DIR ${CMAKE_SOURCE_DIR}/dependencies/CRCpp)
-
-add_library(CRCpp INTERFACE)
-target_include_directories(CRCpp INTERFACE ${CRCPP_DIR}/)
-
-target_link_libraries(OpenRGB CRCpp)
-
-#-----------------------------------------------------------#
-# hidapi                                                    #
-#-----------------------------------------------------------#
-find_package(hidapi REQUIRED)
-target_link_libraries(OpenRGB hidapi::hidapi)
-
-#-----------------------------------------------------------#
-# httplib                                                   #
-#-----------------------------------------------------------#
-set(HTTPLIB_DIR ${CMAKE_SOURCE_DIR}/dependencies/httplib)
-
-add_library(httplib INTERFACE)
-target_include_directories(httplib INTERFACE ${HTTPLIB_DIR}/)
-
-target_link_libraries(OpenRGB httplib)
-
-#-----------------------------------------------------------#
-# libe131                                                   #
-#-----------------------------------------------------------#
-set(LIBE131_DIR ${CMAKE_SOURCE_DIR}/dependencies/libe131)
-
-add_library(libe131 STATIC)
-target_include_directories(libe131 PUBLIC ${LIBE131_DIR}/src)
-target_sources(libe131 PRIVATE ${LIBE131_DIR}/src/e131.c)
-
-target_link_libraries(OpenRGB libe131)
-
-#-----------------------------------------------------------#
-# libusb                                                    #
-#-----------------------------------------------------------#
-find_package(PkgConfig REQUIRED)
-pkg_check_modules(libusb-1.0 REQUIRED IMPORTED_TARGET GLOBAL libusb-1.0)
-
-target_link_libraries(OpenRGB PkgConfig::libusb-1.0)
-
-#-----------------------------------------------------------#
-# hueplusplus                                               #
-#-----------------------------------------------------------#
-add_subdirectory(${CMAKE_SOURCE_DIR}/dependencies/hueplusplus-1.2.0)
-target_link_libraries(OpenRGB hueplusplusstatic)
-
-#-----------------------------------------------------------#
-# nlohmann_json                                             #
-#-----------------------------------------------------------#
-find_package(nlohmann_json REQUIRED)
-target_link_libraries(OpenRGB nlohmann_json)
@@ -13,8 +13,9 @@
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "RGBController.h"

 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
@@ -55,9 +56,7 @@ void DetectBloodyB820R(hid_device_info* info, const std::string& name)
    }
 }

-REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -10,7 +10,6 @@
 \*---------------------------------------------------------*/

 #include "BloodyB820RController.h"
-#include "StringUtils.h"

 /*-------------------------------------------------------------------------------------*\
 | The controller for this device should pass a packet of 64 bytes where the subsequent  |
@@ -36,15 +35,14 @@ BloodyB820RController::~BloodyB820RController()

 std::string BloodyB820RController::GetSerial()
 {
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+    const int szTemp    = HID_MAX_STR;
+    wchar_t   tmpName[szTemp];

-    if(ret != 0)
-    {
-        return("");
-    }
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    std::string serial  = std::string(wName.begin(), wName.end());

-    return(StringUtils::wstring_to_string(serial_string));
+    return(serial);
 }

 std::string BloodyB820RController::GetLocation()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 #define HID_MAX_STR                     255
@@ -145,7 +145,7 @@ static const char *led_names[] =
    @save :x:
    @direct :white_check_mark:
    @effects :x:
-    @detectors DetectBloodyB820R
+    @detectors A4TechDetector
    @comment The A4Tech Bloody B820R keyboard controller currently
        supports the full size (ANSI layout).
 \*-------------------------------------------------------------------*/
@@ -10,7 +10,7 @@
 \*---------------------------------------------------------*/

 #include "BloodyMouseController.h"
-#include "StringUtils.h"
+#include "LogManager.h"

 BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
@@ -33,15 +33,21 @@ uint16_t BloodyMouseController::GetPid()

 std::string BloodyMouseController::GetSerial()
 {
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
+    const uint8_t   sz  = HID_MAX_STR;
+    wchar_t         tmp[sz];

-    if(ret != 0)
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
    {
+        LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return(serial);
 }

 std::string BloodyMouseController::GetLocation()
@@ -12,16 +12,14 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------------------*\
 | Mouse product IDs                                     |
 \*-----------------------------------------------------*/
 #define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W70_MAX_PID                          0x79EF
 #define BLOODY_W90_MAX_PID                          0x3666
-#define BLOODY_W90_PRO_PID                          0x39B6

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
@@ -109,9 +109,7 @@ void RGBController_BloodyMouse::SetupZones()
        case BLOODY_W60_PRO_PID:
            layout = w60_pro;
            break;
-        case BLOODY_W70_MAX_PID:
        case BLOODY_W90_MAX_PID:
-        case BLOODY_W90_PRO_PID:
            layout = w90_max;
            break;
        case BLOODY_MP_50RS_PID:
@@ -13,7 +13,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "AMDWraithPrismController.h"
-#include "StringUtils.h"

 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
@@ -56,7 +55,10 @@ std::string AMDWraithPrismController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 std::string AMDWraithPrismController::GetFirmwareVersionString()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
@@ -9,9 +9,10 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
+#include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"

 /*---------------------------------------------------------*\
@@ -13,7 +13,6 @@
 #include <cstring>
 #include <thread>
 #include "AOCKeyboardController.h"
-#include "StringUtils.h"

 using namespace std::chrono_literals;

@@ -43,7 +42,10 @@ std::string AOCKeyboardController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AOCKeyboardController::SetLightingConfig
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -11,6 +11,7 @@

 #include "Detector.h"
 #include "AOCKeyboardController.h"
+#include "RGBController.h"
 #include "RGBController_AOCKeyboard.h"

 /*-----------------------------------------------------*\
@@ -35,10 +35,10 @@ layout_values aoc_keyboard_offset_values =
            75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
        /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
            60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                     NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,    0,   10,                      57,   72,   87,
-        /* LSFT    \     Z     X     C     V     B     N     M     ,     .     /   RSFT             ARWU          NP1   NP2   NP3  NPEN */
-            30,    0,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,               11,          42,   27,   12,  101,
+        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
+            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
+        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
+            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
        /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
            15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
    },
@@ -11,7 +11,6 @@

 #include <cstring>
 #include "AOCMouseController.h"
-#include "StringUtils.h"

 AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
 {
@@ -39,7 +38,10 @@ std::string AOCMouseController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 /*-------------------------------------------------------------------------------------------------*\
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -11,6 +11,7 @@

 #include "Detector.h"
 #include "AOCMouseController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMouse.h"

 /*-----------------------------------------------------*\
@@ -11,7 +11,6 @@

 #include <cstring>
 #include "AOCMousematController.h"
-#include "StringUtils.h"

 AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
 {
@@ -39,7 +38,10 @@ std::string AOCMousematController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 /*-------------------------------------------------------------------------------------------------*\
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*-----------------------------------------*\
@@ -11,6 +11,7 @@

 #include "Detector.h"
 #include "AOCMousematController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMousemat.h"

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

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

@@ -80,7 +80,10 @@ std::string PolychromeUSBController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void PolychromeUSBController::SetDeviceInfo()
@@ -13,7 +13,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*----------------------------------------------------------------------------------------------*\
@@ -156,6 +156,7 @@ protected:
        );

 private:
+    unsigned int  led_count;
    std::string   device_name;
    unsigned char configtable[12];
    bool          rgswapconfig[8] = { 0 };
@@ -10,10 +10,16 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <hidapi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
+#include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"

 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -31,6 +31,7 @@ public:
    void        DeviceUpdateMode();

 private:
+    bool                            initializedMode;
    PolychromeUSBController*        controller;
    std::vector<PolychromeZoneInfo> zones_info;

@@ -169,7 +169,7 @@ void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for(int led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -290,7 +290,7 @@ void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_s

 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for(int led = 0; led < colors.size(); led++)
    {
        UpdateSingleLED(led);
    }
@@ -10,12 +10,15 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

+#include <stdio.h>
+#include <stdlib.h>
 #include <vector>
 #include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
 #include "LogManager.h"
+#include "RGBController.h"
 #include "RGBController_ASRockASRRGBSMBus.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
 #include "RGBController_ASRockPolychromeV2SMBus.h"
@@ -19,7 +19,6 @@
 #include "RGBController.h"
 #include "AlienwareController.h"
 #include "LogManager.h"
-#include "StringUtils.h"

 typedef uint32_t alienware_platform_id;

@@ -31,8 +30,7 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
    { 0x0C01,   4 },    // Dell G5 SE 5505
    { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 },    // Dell G15   5511
-    { 0x0E0A,   4 }     // Dell G15   5530
+    { 0x0E03,   4 }     // Dell G15   5511

 };

@@ -48,8 +46,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                  "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                  "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                  "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
-    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };

 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -90,7 +87,9 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    /*-----------------------------------------------------*\
    | Get serial number                                     |
    \*-----------------------------------------------------*/
-    serial_number       = StringUtils::wstring_to_string(info.serial_number);
+    std::wstring tmp_serial_number;
+    tmp_serial_number   = info.serial_number;
+    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());

    /*-----------------------------------------------------*\
    | Get zone information by checking firmware             |
@@ -99,11 +98,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];

-    /*-----------------------------------------------------*\
-    | Check if the device reports the wrong number of zones |
-    \*-----------------------------------------------------*/
-    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
-
    /*-----------------------------------------------------*\
    | Get firmware version                                  |
    \*-----------------------------------------------------*/
@@ -114,6 +108,11 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
    version             = fw_string.str();

+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
    /*-----------------------------------------------------*\
    | Initialize Alienware zones                            |
    \*-----------------------------------------------------*/
@@ -655,7 +654,7 @@ void AlienwareController::UpdateDim()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        dim_zone_map[zones[i].dim].emplace_back(i);
    }

    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -682,7 +681,7 @@ bool AlienwareController::UpdateDirect()

    for(size_t i = 0; i < zones.size(); i++)
    {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        color_zone_map[zones[i].color[0]].emplace_back(i);
    }

    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 /*----------------------------------------------------------------------------------------------*\
@@ -9,6 +9,7 @@

 #include "Detector.h"
 #include "AlienwareController.h"
+#include "RGBController.h"
 #include "RGBController_Alienware.h"

 /*---------------------------------------------------------*\
@@ -19,8 +20,7 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID1                      0x0550
-#define ALIENWARE_G_SERIES_PID2                      0x0551
+#define ALIENWARE_G_SERIES_PID                      0x0550

 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -35,5 +35,4 @@ void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
    }
 }

-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID2);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);
@@ -12,7 +12,6 @@

 #include <cstring>
 #include "AlienwareAW410KController.h"
-#include "StringUtils.h"

 AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
 {
@@ -36,13 +35,15 @@ std::string AlienwareAW410KController::GetSerialString()
 {
    wchar_t serial_string[128];
    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
    if(ret != 0)
    {
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AlienwareAW410KController::SendCommit()
@@ -13,7 +13,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

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

 #include <cstring>
 #include "AlienwareAW510KController.h"
-#include "StringUtils.h"

 AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
@@ -34,14 +33,12 @@ std::string AlienwareAW510KController::GetDeviceLocation()
 std::string AlienwareAW510KController::GetSerialString()
 {
    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    hid_get_serial_number_string(dev, serial_string, 128);

-    if(ret != 0)
-    {
-        return("");
-    }
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());

-    return(StringUtils::wstring_to_string(serial_string));
+    return(return_string);
 }

 void AlienwareAW510KController::SendCommit()
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 enum
@@ -7,10 +7,11 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
 #include "AlienwareAW410KController.h"
+#include "RGBController.h"
 #include "RGBController_AlienwareAW510K.h"
 #include "RGBController_AlienwareAW410K.h"

@@ -1,183 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW3423DWFController.cpp                          |
-|                                                           |
-|   Driver for the Alienware AW3423DWF monitor              |
-|                                                           |
-|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <bitset>
-#include <chrono>
-#include <cstring>
-#include <thread>
-
-#include "AlienwareAW3423DWFController.h"
-#include "StringUtils.h"
-
-AlienwareAW3423DWFController::AlienwareAW3423DWFController(hid_device *dev_handle, const char *path) : dev(dev_handle), location(path){}
-
-void AlienwareAW3423DWFController::SendControlPacket(const unsigned char *data, size_t length)
-{
-    unsigned char buffer[256] = {0x00};
-    memcpy(buffer + 1, data, length);
-
-    hid_write(dev, buffer, length + 1);
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
-{
-    uint8_t buffer[193];
-
-    memset(buffer, 0, 193);
-
-    hid_get_input_report(dev, buffer, 193);
-
-    return std::vector<unsigned char>(buffer + 1, buffer + 18);
-}
-
-void AlienwareAW3423DWFController::PerformLogin()
-{
-    unsigned char init_packet[64] =
-    {
-        0x40, 0xE1, 0x01
-    };
-    SendControlPacket(init_packet, 4);
-
-    std::vector<unsigned char> response = GetReportResponse();
-
-    std::vector<unsigned char> key = GenerateKey(response);
-
-    unsigned char login_packet[192] = {0x00};
-    login_packet[0] = 0x40;
-    login_packet[1] = 0xE1;
-    login_packet[2] = 0x02;
-    memcpy(login_packet + 64, key.data(), key.size());
-
-    SendControlPacket(login_packet, 192);
-}
-
-void AlienwareAW3423DWFController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
-{
-    unsigned char led_id_2 = (led_id == 0x01) ? 0xf6 : (led_id == 0x02) ? 0xf5
-                                                   : (led_id == 0x08)   ? 0xff
-                                                                        : 0xfc;
-    PerformLogin();
-
-    unsigned char color_packet[192] = {0x00};
-
-    color_packet[0]  = 0x40;
-    color_packet[1]  = 0xC6;
-    color_packet[6]  = 0x0A;
-    color_packet[8]  = 0x6E;
-    color_packet[10] = 0x82;
-    color_packet[64] = 0x51;
-    color_packet[65] = 0x87;
-    color_packet[66] = 0xD0;
-    color_packet[67] = 0x04;
-
-    color_packet[68] = led_id;
-    color_packet[69] = r;
-    color_packet[70] = g;
-    color_packet[71] = b;
-    color_packet[72] = 0x64;
-    color_packet[73] = led_id_2;
-
-    SendControlPacket(color_packet, 192);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(200));
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GenerateKey(
-    const std::vector<unsigned char> &response)
-{
-    std::vector<unsigned char> syn_key(8, 0);
-
-    const std::vector<unsigned char> oem_key = {
-        0xf5, 0x3f, 0xc1, 0x39, 0x44, 0x3a, 0x31, 0x79, 0x0d, 0xb1, 0x82, 0x76
-    };
-
-    size_t sk_idx = 0, ok_idx = 0;
-    while(ok_idx < oem_key.size() && sk_idx < 8)
-    {
-        unsigned char ok_sub_len = (oem_key[ok_idx] & 1) + ((oem_key[ok_idx] & 0x10) >> 4);
-
-        for(unsigned int i = 0; i < ok_sub_len && sk_idx < 8; i++)
-        {
-            syn_key[sk_idx] = oem_key[ok_idx + 1] ^ oem_key[ok_idx];
-            ok_idx++;
-            sk_idx++;
-        }
-        ok_idx++;
-    }
-
-    std::vector<unsigned char> out_buffer;
-
-    uint16_t v15 = static_cast<uint16_t>(response[15]) |
-                   (static_cast<uint16_t>(response[0]) << 8);
-    bool parity_odd = (std::bitset<16>(v15).count() % 2 != 0);
-
-    if(parity_odd)
-    {
-        size_t end = std::min<size_t>(8, response.size());
-        out_buffer = std::vector<unsigned char>(response.begin(), response.begin() + end);
-
-        if(response.size() > 14)
-        {
-            unsigned char idx = response[14] & 0x07;
-            if((idx + 8) < response.size())
-            {
-                out_buffer[idx] ^= response[idx + 8];
-            }
-        }
-    }
-    else
-    {
-        size_t start = std::min<size_t>(8, response.size());
-        size_t end = std::min<size_t>(start + 8, response.size());
-        out_buffer = std::vector<unsigned char>(response.begin() + start, response.begin() + end);
-
-        if(response.size() > 6)
-        {
-            unsigned char idx = response[6] & 0x07;
-            if(idx < response.size())
-            {
-                out_buffer[idx] ^= response[idx];
-            }
-        }
-    }
-
-    for(size_t i = 0; i < 8 && i < out_buffer.size(); i++)
-    {
-        syn_key[i] ^= out_buffer[i];
-    }
-
-    return syn_key;
-}
-
-AlienwareAW3423DWFController::~AlienwareAW3423DWFController()
-{
-    if(dev)
-    {
-        hid_close(dev);
-        dev = nullptr;
-    }
-}
-
-std::string AlienwareAW3423DWFController::GetLocation()
-{
-    return "HID: " + location;
-}
-
-std::string AlienwareAW3423DWFController::GetSerialString()
-{
-    wchar_t serial[256];
-    if(hid_get_serial_number_string(dev, serial, 256) >= 0)
-    {
-        std::wstring ws(serial);
-        return StringUtils::wstring_to_string(ws);
-    }
-    return "";
-}
@@ -1,40 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW3423DWFController.h                            |
-|                                                           |
-|   Driver for the Alienware AW3423DWF monitor              |
-|                                                           |
-|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <hidapi.h>
-#include <vector>
-#include <string>
-
-class AlienwareAW3423DWFController
-{
-public:
-    AlienwareAW3423DWFController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW3423DWFController();
-
-    std::string GetLocation();
-    std::string GetSerialString();
-    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
-
-private:
-    hid_device* dev;
-    std::string location;
-    unsigned char endpoint_out = 0x02;
-    unsigned char endpoint_in = 0x81;
-
-    static const std::vector<std::vector<unsigned char>> OEM_KEYS;
-
-    void PerformLogin();
-    std::vector<unsigned char> GenerateKey(const std::vector<unsigned char>& response);
-    void SendControlPacket(const unsigned char* data, size_t length);
-    std::vector<unsigned char> GetReportResponse();
-};
@@ -1,136 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorController.cpp                            |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <chrono>
-#include <cstring>
-#include <thread>
-
-#include "AlienwareMonitorController.h"
-
-AlienwareMonitorController::AlienwareMonitorController(hid_device *dev_handle, const char *path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    Initialize();
-}
-
-AlienwareMonitorController::~AlienwareMonitorController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareMonitorController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareMonitorController::GetSerialString()
-{
-    return("");
-}
-
-void fillInChecksum(unsigned char *packet)
-{
-    unsigned char checksum = 110;
-
-    for(unsigned int index = 5; index <= 13; index++)
-    {
-      checksum ^= packet[index];
-    }
-
-    packet[14] = checksum;
-}
-
-void AlienwareMonitorController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
-{
-    unsigned char packet[65];
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[1] = 0x92;
-    packet[2] = 0x37;
-    packet[3] = 0x0a;
-    packet[4] = 0x00;
-    packet[5] = 0x51;
-    packet[6] = 0x87;
-    packet[7] = 0xd0;
-    packet[8] = 0x04;
-
-    packet[9] = led_id;
-    packet[10] = r;
-    packet[11] = g;
-    packet[12] = b;
-    packet[13] = 0x64;
-
-    fillInChecksum(packet);
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-}
-
-void AlienwareMonitorController::Initialize()
-{
-    unsigned char packet[65];
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[1] = 0x95;
-    packet[2] = 0x00;
-    packet[3] = 0x00;
-    packet[4] = 0x00;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-
-    memset(packet, 0xFF, sizeof(packet));
-
-    packet[1] = 0x92;
-    packet[2] = 0x37;
-    packet[3] = 0x08;
-    packet[4] = 0x00;
-    packet[5] = 0x51;
-    packet[6] = 0x85;
-    packet[7] = 0x01;
-    packet[8] = 0xFE;
-    packet[9] = 0x03;
-    packet[10] = 0x00;
-    packet[11] = 0x06;
-    packet[12] = 0x40;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-
-    memset(packet, 0x00, sizeof(packet));
-
-    packet[1] = 0x93;
-    packet[2] = 0x37;
-    packet[3] = 0x12;
-
-    hid_write(dev, packet, sizeof(packet));
-
-    /*-----------------------------------------------------*\
-    | Delay 50 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-}
@@ -1,33 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorController.h                              |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <hidapi.h>
-#include <vector>
-#include <string>
-
-class AlienwareMonitorController
-{
-public:
-AlienwareMonitorController(hid_device* dev_handle, const char* path);
-    ~AlienwareMonitorController();
-
-    std::string GetLocation();
-    std::string GetSerialString();
-    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
-
-private:
-    hid_device* dev;
-    std::string location;
-
-    void Initialize();
-};
@@ -1,66 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareMonitorControllerDetect.cpp                      |
-|                                                           |
-|   Detector for Alienware monitors                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "Detector.h"
-#include "AlienwareAW3423DWFController.h"
-#include "AlienwareMonitorController.h"
-#include "RGBController_AlienwareAW3423DWF.h"
-#include "RGBController_AlienwareMonitor.h"
-#include <hidapi.h>
-
-/*---------------------------------------------------------*\
-| Alienware Vendor ID                                       |
-\*---------------------------------------------------------*/
-#define ALIENWARE_VID                               0x187C
-
-/*---------------------------------------------------------*\
-| Alienware Vendor ID                                       |
-\*---------------------------------------------------------*/
-#define ALIENWARE_AW3423DWF_PID                     0x100E
-#define ALIENWARE_AW3225QF_PID                      0x1013
-#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&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if(dev)
-    {
-        AlienwareAW3423DWFController* controller = new AlienwareAW3423DWFController(dev, info->path);
-        RGBController_AlienwareAW3423DWF* rgb_controller = new RGBController_AlienwareAW3423DWF(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAlienwareMonitorControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareMonitorController*     controller     = new AlienwareMonitorController(dev, info->path);
-        RGBController_AlienwareMonitor* rgb_controller = new RGBController_AlienwareMonitor(controller);
-        rgb_controller->name                           = name;
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR("Alienware AW3423DWF", DetectAlienwareAW3423DWFControllers, ALIENWARE_VID, ALIENWARE_AW3423DWF_PID);
-REGISTER_HID_DETECTOR("Alienware AW3225QF", DetectAlienwareMonitorControllers, ALIENWARE_VID, ALIENWARE_AW3225QF_PID);
@@ -1,141 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW3423DWF.cpp                      |
-|                                                           |
-|   RGBController for the Alienware AW3423DWF monitor       |
-|                                                           |
-|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AlienwareAW3423DWF.h"
-
-/**------------------------------------------------------------------*\
-    @name AW3423DWF
-    @category Accessory
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAlienwareAW3423DWFControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    name                    = "Alienware AW3423DWF";
-    vendor                  = "Alienware";
-    type                    = DEVICE_TYPE_MONITOR;
-    description             = "Alienware AW3423DWF Monitor Device";
-    location                = controller->GetLocation();
-    serial                  = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    active_mode             = 0;
-
-    SetupZones();
-}
-
-RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
-{
-    delete controller;
-}
-
-void RGBController_AlienwareAW3423DWF::SetupZones()
-{
-    zone Logo;
-    Logo.name               = "Logo";
-    Logo.type               = ZONE_TYPE_SINGLE;
-    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;
-    Number.name             = "Number";
-    Number.type             = ZONE_TYPE_SINGLE;
-    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;
-    PowerButton.name        = "Power Button";
-    PowerButton.type        = ZONE_TYPE_SINGLE;
-    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()
-{
-    /*-----------------------------------------------------*\
-    | If all three colors are the same value, speed up the  |
-    | direct mode by using the ALL target (0x0B) instead of |
-    | setting each LED individually.                        |
-    \*-----------------------------------------------------*/
-    if((colors[0] == colors[1]) && (colors[1] == colors[2]))
-    {
-        unsigned char red = RGBGetRValue(colors[0]);
-        unsigned char grn = RGBGetGValue(colors[0]);
-        unsigned char blu = RGBGetBValue(colors[0]);
-        controller->SendColor(0x0B, red, grn, blu);
-    }
-    else
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            UpdateSingleLED(led_idx);
-        }
-    }
-}
-
-void RGBController_AlienwareAW3423DWF::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AlienwareAW3423DWF::UpdateSingleLED(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);
-}
-
-void RGBController_AlienwareAW3423DWF::DeviceUpdateMode()
-{
-}
@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW3423DWF.h                        |
-|                                                           |
-|   RGBController for the Alienware AW3423DWF monitor       |
-|                                                           |
-|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "AlienwareAW3423DWFController.h"
-#include "RGBController.h"
-
-class RGBController_AlienwareAW3423DWF : public RGBController
-{
-public:
-    explicit RGBController_AlienwareAW3423DWF(AlienwareAW3423DWFController* controller_ptr);
-    ~RGBController_AlienwareAW3423DWF();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW3423DWFController* controller;
-};
@@ -1,143 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareMonitor.cpp                        |
-|                                                           |
-|   RGBController for Alienware monitors                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AlienwareMonitor.h"
-
-/**------------------------------------------------------------------*\
-    @name Alienware Monitor
-    @category Accessory
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAlienwareMonitorControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorController* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    name                    = "Alienware Monitor";
-    description             = "Alienware Monitor";
-    vendor                  = "Alienware";
-    type                    = DEVICE_TYPE_MONITOR;
-    location                = controller->GetLocation();
-    serial                  = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    active_mode             = 0;
-
-    SetupZones();
-}
-
-RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
-{
-    delete controller;
-}
-
-void RGBController_AlienwareMonitor::SetupZones()
-{
-    zone Logo;
-    Logo.name               = "Logo";
-    Logo.type               = ZONE_TYPE_SINGLE;
-    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;
-    Number.name             = "Number";
-    Number.type             = ZONE_TYPE_SINGLE;
-    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;
-    PowerButton.name        = "Power Button";
-    PowerButton.type        = ZONE_TYPE_SINGLE;
-    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()
-{
-    /*-----------------------------------------------------*\
-    | If all three colors are the same value, speed up the  |
-    | direct mode by using the ALL target (0x0B) instead of |
-    | setting each LED individually.                        |
-    \*-----------------------------------------------------*/
-    if((colors[0] == colors[1]) && (colors[1] == colors[2]))
-    {
-        unsigned char red = RGBGetRValue(colors[0]);
-        unsigned char grn = RGBGetGValue(colors[0]);
-        unsigned char blu = RGBGetBValue(colors[0]);
-        controller->SendColor(0x0B, red, grn, blu);
-    }
-    else
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            UpdateSingleLED(led_idx);
-        }
-    }
-}
-
-void RGBController_AlienwareMonitor::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AlienwareMonitor::UpdateSingleLED(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);
-}
-
-void RGBController_AlienwareMonitor::DeviceUpdateMode()
-{
-
-}
@@ -1,34 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareMonitor.h                          |
-|                                                           |
-|   RGBController for Alienware monitors                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                08 May 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareMonitorController.h"
-
-class RGBController_AlienwareMonitor : public RGBController
-{
-public:
-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        DeviceUpdateMode();
-
-private:
-AlienwareMonitorController* controller;
-};
@@ -10,7 +10,6 @@
 \*---------------------------------------------------------*/

 #include "AnnePro2Controller.h"
-#include "StringUtils.h"

 using namespace std::chrono_literals;

@@ -40,7 +39,10 @@ std::string AnnePro2Controller::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data)
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 class AnnePro2Controller
@@ -11,8 +11,9 @@

 #include "Detector.h"
 #include "AnnePro2Controller.h"
+#include "RGBController.h"
 #include "RGBController_AnnePro2.h"
-#include <hidapi.h>
+#include <hidapi/hidapi.h>

 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |
@@ -9,9 +9,12 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

+#include <stdio.h>
+#include <stdlib.h>
 #include <vector>
 #include "Detector.h"
 #include "ArcticController.h"
+#include "RGBController.h"
 #include "RGBController_Arctic.h"
 #include "find_usb_serial_port.h"

@@ -44,5 +47,5 @@ REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
 /*---------------------------------------------------------------------------------------------------------*\
 | Entries for dynamic UDEV rules                                                                            |
 |                                                                                                           |
-| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1A86, 0x7523 )                  |
+| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 )                  |
 \*---------------------------------------------------------------------------------------------------------*/
@@ -11,7 +11,6 @@

 #include <cstring>
 #include "AsusAuraCoreController.h"
-#include "StringUtils.h"

 #define AURA_CORE_MAX_MESSAGE_SIZE  64

@@ -50,7 +49,10 @@ std::string AuraCoreController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AuraCoreController::SendBrightness
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 enum AuraCoreDeviceType
@@ -15,10 +15,12 @@
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
 #include "RGBController_AsusAuraCoreLaptop.h"
-#include <hidapi.h>
+#include <hidapi/hidapi.h>

 #define AURA_CORE_VID                   0x0B05

+#define AURA_STRIX_SCAR_15_PID          0x19B6
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectAuraCoreControllers                                                              *
@@ -10,9 +10,43 @@
 \*---------------------------------------------------------*/

 #include "AsusAuraCoreLaptopController.h"
-#include "dmiinfo.h"
 #include "SettingsManager.h"
-#include "StringUtils.h"
+
+static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
+                          ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
+                          ASUSAURACORELAPTOP_LIDCOUNT       ] =
+{
+/*00        ESC  F1   F2   F3   F4   F5   F6   F7   F8   F9  */
+            21,  23,  24,  25,  26,  28,  29,  30,  31,  33,
+
+/*10        F10  F11  F12  DEL   `    1    2    3    4    5  */
+            34,  35,  36,  37,  42,  43,  44,  45,  46,  47,
+
+/*20         6    7    8    9    0    -    =   BSP  BSP  BSP */
+            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
+
+/*30        PLY  TAB   Q    W    E    R    T    Y    U    I  */
+            58,  63,  64,  65,  66,  67,  68,  69,  70,  71,
+
+/*40         O    P    [    ]    \   STP  CAP   A    S    D  */
+            72,  73,  74,  75,  76,  79,  84,  85,  86,  87,
+
+/*50         F    G    H    J    K    L    ;    '   ENT  PRV */
+            88,  89,  90,  91,  92,  93,  94,  95,  98, 100,
+
+/*60        LSH   Z    X    C    V    B    N    M    ,    .  */
+           105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
+
+/*70         /   RSH  UP   NXT LCTL  LFN LWIN LALT  SPC RALT */
+           116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
+
+/*80       RCTL  LFT  DWN  RGT  PRT KSTN  VDN  VUP MICM HPFN */
+           137, 159, 160, 161, 142, 175,   2,   3,   4,   5,
+
+/*90       ARMC  LB1  LB2  LB3  LB4  LB5  LB6 LOGO LIDL LIDR */
+             6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
+
+};

 static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
 {
@@ -32,42 +66,21 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =

 AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
 {
-    dev                     = dev_handle;
-    location                = path;
+    const uint8_t sz    = HID_MAX_STR;
+    wchar_t       tmp[sz];

-    /*---------------------------------------------------------*\
-    | The motherboard name will uniquely ID the laptop to       |
-    |   determine the metadata of the device.                   |
-    \*---------------------------------------------------------*/
-    DMIInfo dmi_info;
-    std::string dmi_name    = dmi_info.getMainboard();
-    bool not_found          = true;
+    dev                 = dev_handle;
+    location            = path;

-    for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++)
-    {
-        if(aura_core_laptop_device_list[i]->dmi_name == dmi_name)
-        {
-            /*---------------------------------------------------------*\
-            | Set device ID                                             |
-            \*---------------------------------------------------------*/
-            not_found       = false;
-            device_index    = i;
-            break;
-        }
-    }
+    hid_get_manufacturer_string(dev, tmp, sz);
+    std::wstring wName = std::wstring(tmp);
+    device_name = std::string(wName.begin(), wName.end());

-    if(not_found)
-    {
-        LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
-                  dmi_name.c_str());
-        return;
-    }
+    hid_get_product_string(dev, tmp, sz);
+    wName = std::wstring(tmp);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));

-    /*---------------------------------------------------------*\
-    | Only set power config for known devices                   |
-    \*---------------------------------------------------------*/
    SetPowerConfigFromJSON();
-    SendInitDirectMode();
 }

 AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
@@ -75,81 +88,28 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
    hid_close(dev);
 }

-const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
+std::string AsusAuraCoreLaptopController::GetDeviceName()
 {
-    return aura_core_laptop_device_list[device_index];
-}
-
-std::string AsusAuraCoreLaptopController::GetDeviceDescription()
-{
-    /*---------------------------------------------------------*\
-    | Get device name from HID manufacturer and product strings |
-    \*---------------------------------------------------------*/
-    wchar_t name_string[HID_MAX_STR];
-
-    hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
-    std::string name = StringUtils::wstring_to_string(name_string);
-
-    hid_get_product_string(dev, name_string, HID_MAX_STR);
-    name.append(" ").append(StringUtils::wstring_to_string(name_string));
-    return name;
-}
-
-unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout()
-{
-    const uint8_t index                                     = 6;
-    uint8_t result                                          = 0;
-    uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID };
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID,
-                                                                ASUSAURACORELAPTOP_CMD_LAYOUT,
-                                                                0x20,
-                                                                0x31,
-                                                                0x00,
-                                                                0x10  };
-
-    /*---------------------------------------------------------*\
-    | Clear the read buffer to ensure we read the right packet  |
-    \*---------------------------------------------------------*/
-    do
-    {
-        result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10);
-    }
-    while(result > 0);
-
-    memset(&rd_buf[1],     0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1);
-    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
-
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-    result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-
-    LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X   %02X %02X %02X {%02X}   %02X %02X %02X %02X",
-              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-              rd_buf[5],  rd_buf[6],  rd_buf[7],  rd_buf[8],  rd_buf[9],  rd_buf[10],
-              rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]);
-
-    if(result > 0)
-    {
-        return rd_buf[12];
-    }
-
-    LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI",
-              aura_core_laptop_device_list[device_index]->dmi_name.c_str());
-    return ASUSAURACORELAPTOP_LAYOUT_ANSI;
+    return device_name;
 }

 std::string AsusAuraCoreLaptopController::GetSerial()
 {
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    const uint8_t sz    = HID_MAX_STR;
+    wchar_t       tmp[sz];

-    if(ret != 0)
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
    {
-        LOG_DEBUG("[%s] Get HID Serial string failed",
-                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
+        LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str());
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return serial;
 }

 std::string AsusAuraCoreLaptopController::GetLocation()
@@ -177,74 +137,49 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t
        current_random      = random;
        current_direction   = direction;

-        if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
-        {
-            SendBrightness();
-            SendInitDirectMode();
-            return;
-        }
-
        SendUpdate();
        SendBrightness();
    }
 }

-void AsusAuraCoreLaptopController::SendInitDirectMode()
-{
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT };
-    memset(&buffer[2], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 2);
-
-    LOG_DEBUG("[%s] Resetting device for direct control", aura_core_laptop_device_list[device_index]->dmi_name.c_str());
-    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-}
-
-void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
+void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
 {
    /*---------------------------------------------------------*\
    | The keyboard zone is a set of 168 keys (indexed from 0)   |
    |   sent in 11 packets of 16 triplets. The Lid and Lightbar |
    |   zones are sent in one final packet afterwards.          |
    \*---------------------------------------------------------*/
-    const uint8_t   key_set                                 = 167;
-    const uint8_t   led_count                               = (uint8_t)colors.size();
-    const uint16_t  map_size                                = 3 * led_count;
-    const uint8_t   leds_per_packet                         = 16;
+    const uint8_t  key_set                                  = 167;
+    const uint8_t  led_count                                = 178;
+    const uint16_t map_size                                 = 3 * led_count;
+    const uint8_t leds_per_packet                           = 16;
    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
                                                                0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
-    uint8_t*        key_buf                                 = new uint8_t[map_size];
+    uint8_t key_buf[map_size];

    memset(key_buf, 0, map_size);

-    for(uint8_t led_index = 0; led_index < led_count; led_index++)
+    for(size_t led_index = 0; led_index < colors.size(); led_index++)
    {
-        std::size_t buf_idx     = (led_index * 3);
+        uint16_t offset         = 3 * packet_map[led_index];

-        key_buf[buf_idx]        = RGBGetRValue(*colors[led_index]);
-        key_buf[buf_idx + 1]    = RGBGetGValue(*colors[led_index]);
-        key_buf[buf_idx + 2]    = RGBGetBValue(*colors[led_index]);
+        key_buf[offset]         = RGBGetRValue(colors[led_index]);
+        key_buf[offset + 1]     = RGBGetGValue(colors[led_index]);
+        key_buf[offset + 2]     = RGBGetBValue(colors[led_index]);
    }

-    for(uint8_t i = 0; i < key_set; i += leds_per_packet)
+    for(size_t i = 0; i < key_set; i+=leds_per_packet)
    {
-        uint8_t leds_remaining  = key_set - i;
+        uint8_t leds_remaining  = key_set - (uint8_t)i;

        if(leds_remaining < leds_per_packet)
        {
            buffer[07]          = leds_remaining;
-
-            memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
-                   0,
-                   ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
        }

-        buffer[06]              = i;
+        buffer[06]              = (uint8_t)i;
        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));

-        LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
-                  aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-                  i,
-                  i + buffer[07]);
-
        hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
    }

@@ -252,31 +187,15 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
    buffer[5] = 0x00;
    buffer[6] = 0x00;
    buffer[7] = 0x00;
-
-    memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
-           0,
-           ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
-
-    if(led_count > key_set)
-    {
-        memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
-               &key_buf[3 * key_set],
-               (3 * (led_count - key_set)));
-    }
-
-    LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
-              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-              key_set,
-              led_count);
+    memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));

    hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
-    delete[] key_buf;
 }

 void AsusAuraCoreLaptopController::SendBrightness()
 {
-    const uint8_t index                                     = 5;
-    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};
+    const uint8_t index                                     = 2;
+    uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE]    = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };

    memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
    buffer[4] = current_brightness;
@@ -369,8 +288,6 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
        device_settings[section_power]  = pcfg;
        settings_manager->SetSettings(detector_name, device_settings);
        settings_manager->SaveSettings();
-        LOG_DEBUG("[%s] default power config saved to openrgb.json",
-                  aura_core_laptop_device_list[device_index]->dmi_name.c_str());
    }
    else
    {
@@ -381,9 +298,7 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
            if(device_settings[section_power].contains(key_name))
            {
                power_config[i].state   = device_settings[section_power][key_name];
-                LOG_DEBUG("[%s] Reading power config for %s: %s",
-                          aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-                          key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
+                LOG_DEBUG("[%s] Reading power config for %s: %s", device_name.c_str(), key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
            }
        }
    }
@@ -393,7 +308,7 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
    |   With thanks to AsusCtl for helping to decipher the packet captures          |
    |   https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150  |
    \*-----------------------------------------------------------------------------*/
-    bool flag_array[32] =
+    bool flag_array[] =
    {
        power_config[0].state,      power_config[4].state,
        power_config[1].state,      power_config[5].state,
@@ -410,9 +325,7 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
    };

    uint32_t flags      = PackPowerFlags(flag_array);
-    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X",
-              aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
-              (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
+    LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X", device_name.c_str(), (flags & 0xFF), ((flags >> 8)  & 0xFF), ((flags >> 16)  & 0xFF), flags);
    SendPowerConfig(flags);
 }

@@ -13,12 +13,11 @@

 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "RGBControllerKeyNames.h"
-#include "AsusAuraCoreLaptopDevices.h"

 #define NA                                      0xFFFFFFFF
 #define HID_MAX_STR                             255
@@ -34,7 +33,7 @@
 #define ASUSAURACORELAPTOP_POWER_ZONES          4
 #define ASUSAURACORELAPTOP_POWER_STATES         4
 #define ASUSAURACORELAPTOP_BRIGHTNESS_MIN       0
-#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       3 // No device has proven to have 256 keyboard brightness levels, only 0..3
+#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX       255

 enum
 {
@@ -84,7 +83,6 @@ enum
    ASUSAURACORELAPTOP_CMD_UPDATE               = 0xB3,
    ASUSAURACORELAPTOP_CMD_APPLY                = 0xB4,
    ASUSAURACORELAPTOP_CMD_SET                  = 0xB5,
-    ASUSAURACORELAPTOP_CMD_LAYOUT               = 0x05,
 };

 enum
@@ -94,12 +92,6 @@ enum
    ASUSAURACORELAPTOP_SPEED_FASTEST            = 0xF5, // Fastest speed
 };

-enum aura_core_laptop_layout
-{
-    ASUSAURACORELAPTOP_LAYOUT_ANSI              = 0x01,     /* US ANSI Layout                   */
-    ASUSAURACORELAPTOP_LAYOUT_ISO               = 0x02,     /* EURO ISO Layout                  */
-};
-
 struct p_state
 {
    std::string zone;
@@ -112,36 +104,33 @@ public:
    AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
    ~AsusAuraCoreLaptopController();

-    const aura_core_laptop_device*  GetDeviceData();
-    std::string                     GetDeviceDescription();
-    std::string                     GetSerial();
-    unsigned int                    GetKeyboardLayout();
-    std::string                     GetLocation();
+    std::string             GetDeviceName();
+    std::string             GetSerial();
+    std::string             GetLocation();

-    void                            SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
-    void                            SetLedsDirect(std::vector<RGBColor *>colors);
-    void                            SendInitDirectMode();
+    void                    SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
+    void                    SetLedsDirect(std::vector<RGBColor> colors);
 private:
-    hid_device*                     dev;
-    uint16_t                        device_index;
-    std::string                     location;
+    std::string             device_name;
+    std::string             location;
+    hid_device*             dev;

-    uint8_t                         current_mode;
-    uint8_t                         current_speed;
-    uint8_t                         current_direction;
+    uint8_t                 current_mode;
+    uint8_t                 current_speed;
+    uint8_t                 current_direction;

-    RGBColor                        current_c1;
-    RGBColor                        current_c2;
-    uint8_t                         current_brightness;
-    uint8_t                         current_random;
+    RGBColor                current_c1;
+    RGBColor                current_c2;
+    uint8_t                 current_brightness;
+    uint8_t                 current_random;

-    void                            SendApply();
-    void                            SendBrightness();
-    void                            SendSet();
-    void                            SendUpdate();
+    void                    SendApply();
+    void                    SendBrightness();
+    void                    SendSet();
+    void                    SendUpdate();

-    void                            SetPowerConfigFromJSON();
-    void                            SendPowerConfig(uint32_t flags);
-    uint32_t                        PackPowerFlags(bool flags[]);
-    std::vector<p_state>            PowerConfigArray();
+    void                    SetPowerConfigFromJSON();
+    void                    SendPowerConfig(uint32_t flags);
+    uint32_t                PackPowerFlags(bool flags[]);
+    std::vector<p_state>    PowerConfigArray();
 };
@@ -1,559 +0,0 @@
-#include "AsusAuraCoreLaptopDevices.h"
-
-/*-------------------------------------------------------------------------*\
-|  Aura Core Key Values                                                     |
-|    NULL values are keys that are handed to the KLM but are removed as     |
-|    a part of customisation. They are included to maintain expected key    |
-|    count is aligned to the value count.                                   |
-\*-------------------------------------------------------------------------*/
-
-std::vector<unsigned int> aura_core_laptop_15_values =
-{
-    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12         DEL  */
-        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,
-    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC        PLAY  */
-        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,
-    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \         STOP  */
-        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,
-    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR        PREV  */
-        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,
-    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT        ARWU  NEXT  */
-       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,
-    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL        ARWL  ARWD  ARWR  */
-       126,  128,  129,              131,              135,  136,  136,  137,
-};
-
-std::vector<unsigned int> aura_core_laptop_17_values =
-{
-    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
-        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
-    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
-        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
-    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
-        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
-    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
-        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
-    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
-       105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              139,        122,  123,  124,  125,
-    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
-       126,  128,  129,              131,              135,  136,  136,  137,              159,  160,  161,        144,  145,
-};
-
-std::vector<unsigned int> aura_core_laptop_18_values =
-{
-    /* ESC          F1    F2    F3    F4    F5    F6    F7    F8    F9   F10   F11   F12   NULL  NULL  PAUS                          */
-        21,         23,   24,   25,   26,   28,   29,   30,   31,   33,   34,   35,   36,    0,    0,   39,
-    /* BKTK    1     2     3     4     5     6     7     8     9     0     -     =   BSPC  NULL  NULL  NULL  NMLK  NMDV  NMTM  NMMI  */
-        42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   56,    0,    0,    0,   59,   60,   61,   62,
-    /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   NULL  NULL  NULL  NM7   NM8   NM9   NMPL  */
-        63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,   76,    0,    0,    0,   80,   81,   82,   83,
-    /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                    NM4   NM5   NM6         */
-        84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,   95,   96,   98,                    101,  102,  103,
-    /* LSFT  ISO\    Z     X     C     V     B     N     M     ,     .     /   RSFT              ARWU        NM1   NM2   NM3   NMER  */
-        105,  106,  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,  119,              121,        122,  123,  124,  125,
-    /* LCTL  LWIN  LALT              SPC               RALT  RFNC  RMNU  RCTL              ARWL  ARWD  ARWR        NM0   NMPD        */
-        126,  128,  129,              131,              135,  136,  136,  137,              141,  142,  143,        144,  145,
-};
-
-/*-------------------------------------------------------------------------*\
-|  KEYMAPS                                                                  |
-\*-------------------------------------------------------------------------*/
-keyboard_keymap_overlay_values g533zm_layout
-{
-    KEYBOARD_SIZE_SEVENTY_FIVE,
-    {
-        aura_core_laptop_15_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
-        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop
-        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous
-        {   0,      4,      13,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
-        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Next
-        {   0,      5,      12,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow
-        {   0,      5,      13,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
-        {   0,      5,      14,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
-    }
-};
-
-keyboard_keymap_overlay_values g533zw_layout
-{
-    KEYBOARD_SIZE_SEVENTY_FIVE,
-    {
-        aura_core_laptop_15_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,      15,          37,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Delete
-        {   0,      1,      15,          58,        KEY_EN_MEDIA_PLAY_PAUSE,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Play / Pause
-        {   0,      2,      15,          79,        KEY_EN_MEDIA_STOP,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Stop
-        {   0,      3,      15,         100,        KEY_EN_MEDIA_PREVIOUS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Previous
-        {   0,      4,      15,         121,        KEY_EN_MEDIA_NEXT,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Media Next
-        {   0,      5,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Function key
-        {   0,      5,       4,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Unused key
-        {   0,      5,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Func key
-        {   0,      5,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Context key
-        {   0,      5,      13,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Up Arrow
-        {   0,      5,      15,         142,        KEY_EN_PRINT_SCREEN,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Print Screen
-        {   0,      5,      16,         175,        "Keystone",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Keystone (Red only)
-        {   0,      6,      12,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Arrow on new row
-        {   0,      6,      13,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Down Arrow
-        {   0,      6,      14,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Right Arrow
-        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row before function keys
-        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Vol Up
-        {   0,      0,       4,           4,        "Mic On / Off",             KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mic On / Off
-        {   0,      0,       5,           5,        "Hyperfan",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Hyperfan
-        {   0,      0,       6,           6,        "Armoury Crate",            KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Armoury Crate
-    }
-};
-
-keyboard_keymap_overlay_values g533zw_lid_layout
-{
-    KEYBOARD_SIZE_EMPTY,
-    {
-        {   /* Values not set in empty keyboard */   },
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         167,        "Logo",                     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         176,        "Vertical Cut Left",        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         177,        "Vertical Cut Right",       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
-    }
-};
-
-keyboard_keymap_overlay_values g533zw_lightbar_layout
-{
-    KEYBOARD_SIZE_EMPTY,
-    {
-        {   /* Values not set in empty keyboard */   },
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         174,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         173,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         172,        "Lightbar L3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
-        {   0,      0,       3,         171,        "Lightbar R3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
-        {   0,      0,       4,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-        {   0,      0,       5,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
-    }
-};
-
-keyboard_keymap_overlay_values g713rw_keyboard_layout
-{
-    KEYBOARD_SIZE_FULL,
-    {
-        aura_core_laptop_17_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
-        {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
-        {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
-        {   0,      0,       5,           5,        "Key: Fan",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
-        {   0,      0,       6,           6,        "Key: ROG",                 KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
-        {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
-        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-        {   0,      6,       8,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-        {   0,      6,      10,         136,        KEY_EN_RIGHT_FUNCTION,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Fuction
-        {   0,      6,      10,         136,        KEY_EN_RIGHT_WINDOWS,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
-
-        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },
-        {   0,      1,      15,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
-        {   0,      1,      15,          38,        KEY_EN_DELETE,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Delete key
-        {   0,      1,      17,          40,        KEY_EN_PRINT_SCREEN,        KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
-        {   0,      1,      18,          41,        KEY_EN_HOME,                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,     KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      5,      12,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // gap before arrow up key
-        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
-
-        {   0,      6,      11,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key before arrow keys
-        {   0,      6,      15,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // trim extra column before numpad
-        {   0,      6,      16,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // 1 empty key between numpad 0 and .
-
-        // Close numpad gap completely
-        {   0,      1,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      2,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      3,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      4,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      5,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-        {   0,      6,      14,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-
-        // Move Arrow keys
-        {   0,      5,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Up
-        {   0,      6,      13,           0,        KEY_EN_UNUSED,              KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Remove Arrow Down
-        {   0,      6,      12,         139,        KEY_EN_UP_ARROW,            KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Shift Arrow Up
-        {   0,      7,      11,         159,        KEY_EN_LEFT_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      12,         160,        KEY_EN_DOWN_ARROW,          KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      7,      13,         161,        KEY_EN_RIGHT_ARROW,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    }
-};
-
-keyboard_keymap_overlay_values g713rw_lightbar_layout
-{
-    KEYBOARD_SIZE_EMPTY,
-    {
-        {   /* Values not set in empty keyboard */   },
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         174,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         173,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         172,        "Lightbar L3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L3
-        {   0,      0,       3,         171,        "Lightbar R3",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R3
-        {   0,      0,       4,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-        {   0,      0,       5,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R1
-    }
-};
-
-keyboard_keymap_overlay_values g713rw_test_layout
-{
-    KEYBOARD_SIZE_EMPTY,
-    {
-        {   /* Values not set in empty keyboard */   },
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,           7,        "Test01",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       1,           8,        "Test02",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       2,           9,        "Test03",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       3,          10,        "Test04",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       4,          11,        "Test05",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       5,          12,        "Test06",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       6,          13,        "Test07",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       7,          14,        "Test08",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       8,          15,        "Test09",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,       9,          16,        "Test10",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      10,          17,        "Test11",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      11,          18,        "Test12",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      12,          19,        "Test13",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      13,          20,        "Test14",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      14,          22,        "Test15",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      15,          27,        "Test16",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      16,          55,        "Test17",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      17,          57,        "Test18",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      18,          58,        "Test19",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      19,          77,        "Test20",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      20,          78,        "Test21",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      21,          79,        "Test22",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      22,          96,        "Test23",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      23,          97,        "Test24",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      24,          99,        "Test25",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      25,         100,        "Test26",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      26,         104,        "Test27",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      27,         117,        "Test28",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      28,         118,        "Test29",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      29,         120,        "Test30",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      30,         121,        "Test31",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      31,         130,        "Test32",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      32,         132,        "Test33",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      33,         133,        "Test34",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      34,         134,        "Test35",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      35,         138,        "Test36",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      36,         140,        "Test37",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      37,         141,        "Test38",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      38,         142,        "Test39",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      39,         143,        "Test40",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      40,         146,        "Test41",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      41,         147,        "Test42",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      42,         148,        "Test43",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      43,         149,        "Test44",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      44,         150,        "Test45",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      45,         151,        "Test46",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      46,         152,        "Test47",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      47,         153,        "Test48",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      48,         154,        "Test49",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      49,         155,        "Test50",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      50,         156,        "Test51",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      51,         157,        "Test52",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      52,         158,        "Test53",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      53,         162,        "Test54",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      54,         163,        "Test55",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      55,         164,        "Test56",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      56,         165,        "Test57",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      57,         166,        "Test58",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-        {   0,      0,      58,         167,        "Test59",                   KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
-    }
-};
-
-keyboard_keymap_overlay_values g733zm_layout
-{
-    KEYBOARD_SIZE_FULL,
-    {
-        aura_core_laptop_17_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-    }
-};
-
-keyboard_keymap_overlay_values g814jv_keyboard_layout
-{
-    KEYBOARD_SIZE_FULL,
-    {
-        aura_core_laptop_18_values,
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-     /*------------------------------------------------------------------------------------------------------------------------------------*\
-    | Edit Keys                                                                                                                             |
-    |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-    \*-------------------------------------------------------------------------------------------------------------------------------------*/
-     {   0,      0,       2,           2,        KEY_EN_MEDIA_VOLUME_DOWN,  KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_ROW,         },  // Insert Row and add Volume Down
-     {   0,      0,       3,           3,        KEY_EN_MEDIA_VOLUME_UP,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Volume Up
-     {   0,      0,       4,           4,        KEY_EN_MEDIA_MUTE,         KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Mute
-     {   0,      0,       5,           5,        "Key: Fan",                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "Fan" key
-     {   0,      0,       6,           6,        "Key: ROG",                KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert "ROG" key
-     {   0,      6,       8,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-     {   0,      6,       8,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove part of Spacebar
-     {   0,      6,       1,         127,        KEY_EN_LEFT_FUNCTION,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Left Fuction
-     {   0,      6,      10,         136,        KEY_EN_PRINT_SCREEN,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Replace Right Fuction with PrtSc
-     {   0,      6,      11,           0,        KEY_EN_RIGHT_WINDOWS,      KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },  // Remove Right Win Key
-     {   0,      1,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      1,      14,          38,        KEY_EN_DELETE,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          },  // Insert a Delete key
-     {   0,      1,      16,          40,        KEY_EN_PRINT_SCREEN,       KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Print Screen key
-     {   0,      1,      17,          41,        KEY_EN_HOME,               KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert a Home key
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      2,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      3,      13,          76,        KEY_EN_ANSI_BACK_SLASH,    KEY_EN_UNUSED,              KEYBOARD_OPCODE_SWAP_ONLY,          }, // Force ANSI | even on ISO layouts
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  }, // Numpad gap
-     {   0,      3,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      4,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      12,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      13,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      5,      14,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     {   0,      6,      15,           0,        KEY_EN_UNUSED,             KEY_EN_UNUSED,              KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT,  },
-     }
-};
-
-keyboard_keymap_overlay_values g814jv_lightbar_layout
-{
-    KEYBOARD_SIZE_EMPTY,
-    {
-        {   /* Values not set in empty keyboard */   },
-        {
-            /* Add more regional layout fixes here */
-        }
-    },
-    {
-        /*-------------------------------------------------------------------------------------------------------------------------------------*\
-        | Edit Keys                                                                                                                             |
-        |   Zone,   Row,    Column,     Value,      Key,                        Alternate Name,             OpCode,                             |
-        \*-------------------------------------------------------------------------------------------------------------------------------------*/
-        {   0,      0,       0,         173,        "Lightbar L1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L1
-        {   0,      0,       1,         172,        "Lightbar L2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar L2
-        {   0,      0,       2,         170,        "Lightbar R2",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-        {   0,      0,       3,         169,        "Lightbar R1",              KEY_EN_UNUSED,              KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },  // Insert Lightbar R2
-    }
-};
-
-
-/*-------------------------------------------------------------------------*\
-|  AURA CORE LAPTOP DEVICES                                                 |
-\*-------------------------------------------------------------------------*/
-
-/*-------------------------------------------------------------*\
-|  ASUS ROG Strix SCAR 15 G533ZM                                |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       7 Rows, 16 Columns                                      |
-\*-------------------------------------------------------------*/
-static const aura_core_laptop_zone g533zm_zone =
-{
-    ZONE_EN_KEYBOARD,
-    &g533zm_layout
-};
-
-static const aura_core_laptop_device g533zm_device =
-{
-    "G533ZM",
-    {
-        &g533zm_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  ASUS ROG Strix SCAR 15 G533ZW                                |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       7 Rows, 16 Columns                                      |
-\*-------------------------------------------------------------*/
-static const aura_core_laptop_zone g533zw_lid_zone =
-{
-    "Lid",
-    &g533zw_lid_layout
-};
-
-static const aura_core_laptop_zone g533zw_kb_zone =
-{
-    ZONE_EN_KEYBOARD,
-    &g533zw_layout
-};
-
-static const aura_core_laptop_zone g533zw_lightbar_zone =
-{
-    "Lightbar",
-    &g533zw_lightbar_layout
-};
-
-static const aura_core_laptop_device g533zw_device =
-{
-    "G533ZW",
-    {
-        &g533zw_kb_zone,
-        &g533zw_lid_zone,
-        &g533zw_lightbar_zone,
-        nullptr,
-        nullptr,
-        nullptr
-    }
-};
-
-/*-------------------------------------------------------------*\
-|  ASUS ROG Strix SCAR G713RW                                   |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       7 Rows, 20 Columns                                      |
-\*-------------------------------------------------------------*/
-static const aura_core_laptop_zone g713rw_keyboard_zone =
-{
-    ZONE_EN_KEYBOARD,
-    &g713rw_keyboard_layout
-};
-
-static const aura_core_laptop_zone g713rw_lightbar_zone =
-{
-    "Lightbar",
-    &g713rw_lightbar_layout
-};
-
-static const aura_core_laptop_device g713rw_device =
-{
-    "G713RW",
-    {
-        &g713rw_keyboard_zone,
-        &g713rw_lightbar_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    }
-};
-/*-------------------------------------------------------------*\
-|  ASUS ROG Strix G18 (G814JV)                                  |
-|                                                               |
-|  Zone "Keyboard"                                              |
-|       Matrix                                                  |
-|       7 Rows, 16 Columns                                      |
-\*-------------------------------------------------------------*/
-
-static const aura_core_laptop_zone g814rw_keyboard_zone =
-{
-    ZONE_EN_KEYBOARD,
-    &g814jv_keyboard_layout
-};
-
-static const aura_core_laptop_zone g814jv_lightbar_zone =
-{
-    "Lightbar",
-    &g814jv_lightbar_layout
-};
-
-static const aura_core_laptop_device g814jv_device =
-{
-    "G814JV",
-    {
-        &g814rw_keyboard_zone,
-        &g814jv_lightbar_zone,
-        nullptr,
-        nullptr,
-        nullptr,
-        nullptr
-    }
-};
-
-/*-------------------------------------------------------------------------*\
-|  DEVICE MASTER LIST                                                       |
-\*-------------------------------------------------------------------------*/
-const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
-{
-/*-----------------------------------------------------------------*\
-|  KEYBOARDS                                                        |
-\*-----------------------------------------------------------------*/
-    &g533zm_device,
-    &g533zw_device,
-    &g713rw_device,
-    &g814jv_device,
-};
-
-const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));
-const aura_core_laptop_device** aura_core_laptop_device_list = aura_core_laptop_device_list_data;
@@ -1,50 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-#include "RGBController.h"
-#include "RGBControllerKeyNames.h"
-#include "KeyboardLayoutManager.h"
-
-#define AURA_CORE_LAPTOP_ZONES_MAX      6
-
-enum aura_core_kb_layout
-{
-    AURA_CORE_LAPTOP_KB_LAYOUT_ANSI     = 0x01,     /* US ANSI Layout                   */
-    AURA_CORE_LAPTOP_KB_LAYOUT_ISO      = 0x02,     /* EURO ISO Layout                  */
-    AURA_CORE_LAPTOP_KB_LAYOUT_ABNT     = 0x03,     /* Brazilian Layout                 */
-    AURA_CORE_LAPTOP_KB_LAYOUT_JIS      = 0x04,     /* Japanese Layout                  */
-};
-
-typedef struct
-{
-    std::string                         name;
-    keyboard_keymap_overlay_values*     layout_new;
-}   aura_core_laptop_zone;
-
-typedef struct
-{
-    uint8_t                             zone;
-    uint8_t                             row;
-    uint8_t                             col;
-    uint8_t                             index;
-    const char*                         name;
-}   aura_core_laptop_led;
-
-typedef struct
-{
-    std::string                         dmi_name;
-    const aura_core_laptop_zone*        zones[AURA_CORE_LAPTOP_ZONES_MAX];
-}   aura_core_laptop_device;
-
-/*-----------------------------------------------------*\
-| Aura Core Laptop Protocol Keyboards                   |
-\*-----------------------------------------------------*/
-#define AURA_STRIX_SCAR_15_PID                      0x19B6
-
-/*-----------------------------------------------------*\
-| These constant values are defined in                  |
-| AsusAuraCoreLaptopDevices.cpp                         |
-\*-----------------------------------------------------*/
-extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT;
-extern const aura_core_laptop_device** aura_core_laptop_device_list;
@@ -11,6 +11,129 @@

 #include "RGBController_AsusAuraCoreLaptop.h"

+static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
+{
+    {  NA,  NA,  86,  87,  88,  89,  90,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA },
+    {   0,  NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,  NA,   9,  10,  11,  12,  13,  NA },
+    {  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA },
+    {  31,  NA,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  NA,  45,  NA },
+    {  46,  NA,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  NA,  58,  NA,  59,  NA },
+    {  60,  NA,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  NA,  72,  NA,  73,  NA },
+    {  74,  75,  76,  77,  NA,  NA,  NA,  78,  NA,  NA,  NA,  79,  80,  81,  82,  83,  84,  85 }
+};
+
+static const char *led_names[] =
+{
+    KEY_EN_ESCAPE,              //00
+    KEY_EN_F1,
+    KEY_EN_F2,
+    KEY_EN_F3,
+    KEY_EN_F4,
+    KEY_EN_F5,
+    KEY_EN_F6,
+    KEY_EN_F7,
+    KEY_EN_F8,
+    KEY_EN_F9,
+    KEY_EN_F10,                 //10
+    KEY_EN_F11,
+    KEY_EN_F12,
+    KEY_EN_DELETE,
+
+    KEY_EN_BACK_TICK,
+    KEY_EN_1,
+    KEY_EN_2,
+    KEY_EN_3,
+    KEY_EN_4,
+    KEY_EN_5,
+    KEY_EN_6,                   //20
+    KEY_EN_7,
+    KEY_EN_8,
+    KEY_EN_9,
+    KEY_EN_0,
+    KEY_EN_MINUS,
+    KEY_EN_EQUALS,
+    KEY_EN_BACKSPACE,
+    KEY_EN_BACKSPACE,
+    KEY_EN_BACKSPACE,
+    KEY_EN_MEDIA_PLAY_PAUSE,    //30
+
+    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,                   //40
+    KEY_EN_P,
+    KEY_EN_LEFT_BRACKET,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_ANSI_BACK_SLASH,
+    KEY_EN_MEDIA_STOP,
+
+    KEY_EN_CAPS_LOCK,
+    KEY_EN_A,
+    KEY_EN_S,
+    KEY_EN_D,
+    KEY_EN_F,                   //50
+    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_MEDIA_PREVIOUS,
+
+    KEY_EN_LEFT_SHIFT,          //60
+    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,       //70
+    KEY_EN_RIGHT_SHIFT,
+    KEY_EN_UP_ARROW,
+    KEY_EN_MEDIA_NEXT,
+
+    KEY_EN_LEFT_CONTROL,
+    KEY_EN_LEFT_FUNCTION,
+    KEY_EN_LEFT_WINDOWS,
+    KEY_EN_LEFT_ALT,
+    KEY_EN_SPACE,
+    KEY_EN_RIGHT_ALT,
+    KEY_EN_RIGHT_CONTROL,       //80
+    KEY_EN_LEFT_ARROW,
+    KEY_EN_DOWN_ARROW,
+    KEY_EN_RIGHT_ARROW,
+    KEY_EN_PRINT_SCREEN,
+    "Asus Keystone",
+
+    KEY_EN_MEDIA_VOLUME_DOWN,
+    KEY_EN_MEDIA_VOLUME_UP,
+    "Key: Mic On/Off",
+    "Key: HyperFan",
+    "Key: Armoury Crate",       //90
+
+    "Lightbar LED 1",
+    "Lightbar LED 2",
+    "Lightbar LED 3",
+    "Lightbar LED 4",
+    "Lightbar LED 5",
+    "Lightbar LED 6",
+
+    "Logo",
+    "Lid Left",
+    "Lid Right",                //99
+};
+
 /**------------------------------------------------------------------*\
    @name AsusAuraCoreLaptop
    @category DEVICE_TYPE_KEYBOARD
@@ -27,32 +150,23 @@
        * Awake (Normal Usage)
        * Sleeping
        * Shutdown / Power Off
-
-        MatrixMaps can be found in ArmouryCrate (it needs a chance to download device data)
-        Default path is:
-            C:\ProgramData\ASUS\ROG Live Service\DeviceContent\<Model name>\<Model name>.csv
-        (Model name is the code like G814JV - can be found in the error in logs)
 \*-------------------------------------------------------------------*/

 RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
 {
-    controller                              = controller_ptr;
-    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
+    controller                  = controller_ptr;

-    name                                    = aura_dev->dmi_name;
-    vendor                                  = "Asus";
-    type                                    = DEVICE_TYPE_LAPTOP;
-    description                             = controller->GetDeviceDescription();
-    serial                                  = controller->GetSerial();
-    location                                = controller->GetLocation();
+    name                        = "Asus Aura Core Laptop";
+    vendor                      = "Asus";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = controller->GetDeviceName();
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();

    mode Direct;
    Direct.name                 = "Direct";
    Direct.value                = ASUSAURACORELAPTOP_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
-    Direct.brightness_max       = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
-    Direct.brightness           = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
    Direct.color_mode           = MODE_COLORS_PER_LED;
    modes.push_back(Direct);

@@ -261,9 +375,8 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
    Off.color_mode              = MODE_COLORS_NONE;
    modes.push_back(Off);

+    Init_Controller();
    SetupZones();
-
-    SetMode(active_mode);
 }

 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
@@ -271,131 +384,70 @@ RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
    delete controller;
 }

+void RGBController_AsusAuraCoreLaptop::Init_Controller()
+{
+    /*-------------------------------------------------*\
+    | Create the keyboard zone and add the matix map    |
+    \*-------------------------------------------------*/
+    zone KB_zone;
+    KB_zone.name                = "Keyboard Zone";
+    KB_zone.type                = ZONE_TYPE_MATRIX;
+    KB_zone.leds_min            = ASUSAURACORELAPTOP_KEYCOUNT;
+    KB_zone.leds_max            = ASUSAURACORELAPTOP_KEYCOUNT;
+    KB_zone.leds_count          = ASUSAURACORELAPTOP_KEYCOUNT;
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = ASUSAURACORELAPTOP_KEY_HEIGHT;
+    KB_zone.matrix_map->width   = ASUSAURACORELAPTOP_KEY_WIDTH;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    zones.push_back(KB_zone);
+
+    zone lightbar;
+    lightbar.name               = "Lightbar Zone";
+    lightbar.type               = ZONE_TYPE_LINEAR;
+    lightbar.leds_min           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    lightbar.leds_max           = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    lightbar.leds_count         = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
+    lightbar.matrix_map         = NULL;
+
+    zones.push_back(lightbar);
+
+    zone lid;
+    lid.name                    = "Lid Zone";
+    lid.type                    = ZONE_TYPE_LINEAR;
+    lid.leds_min                = ASUSAURACORELAPTOP_LIDCOUNT;
+    lid.leds_max                = ASUSAURACORELAPTOP_LIDCOUNT;
+    lid.leds_count              = ASUSAURACORELAPTOP_LIDCOUNT;
+    lid.matrix_map              = NULL;
+
+    zones.push_back(lid);
+}
+
 void RGBController_AsusAuraCoreLaptop::SetupZones()
 {
-    std::string physical_size;
-    KEYBOARD_LAYOUT new_layout;
-    unsigned int max_led_value              = 0;
-
-    const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
-    unsigned int layout                     = controller->GetKeyboardLayout();
-
-    switch(layout)
-    {
-        case ASUSAURACORELAPTOP_LAYOUT_ISO:
-            new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
-            break;
-
-        case ASUSAURACORELAPTOP_LAYOUT_ANSI:
-        default:
-            new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
-            break;
-    }
-    LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout);
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();

    /*---------------------------------------------------------*\
-    | Fill in zones from the device data                        |
+    | Set up zones                                              |
    \*---------------------------------------------------------*/
-    for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
+    for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
    {
-        LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
+        int zone_offset = (int)leds.size();

-        if(aura_dev->zones[i] == NULL)
+        for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
        {
-            break;
-        }
-        else
-        {
-            zone new_zone;
-
-            new_zone.name                   = aura_dev->zones[i]->name;
-
-            if(aura_dev->zones[i]->layout_new != NULL)
-            {
-                KeyboardLayoutManager new_kb(new_layout,
-                                             aura_dev->zones[i]->layout_new->base_size,
-                                             aura_dev->zones[i]->layout_new->key_values);
-
-                if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY ||
-                   aura_dev->zones[i]->layout_new->edit_keys.size() > 0)
-                {
-                    /*---------------------------------------------------------*\
-                    | Minor adjustments to keyboard layout                      |
-                    \*---------------------------------------------------------*/
-                    keyboard_keymap_overlay_values* temp    = aura_dev->zones[i]->layout_new;
-                    new_kb.ChangeKeys(*temp);
-
-                    if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1)
-                    {
-                        if(new_kb.GetKeyCount() == 1)
-                        {
-                            new_zone.type               = ZONE_TYPE_SINGLE;
-                        }
-                        else
-                        {
-                            new_zone.type               = ZONE_TYPE_LINEAR;
-                        }
-                    }
-                    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);
-                    }
-
-                    /*---------------------------------------------------------*\
-                    | Create LEDs for the Matrix zone                           |
-                    |   Place keys in the layout to populate the matrix         |
-                    \*---------------------------------------------------------*/
-                    new_zone.leds_count             = new_kb.GetKeyCount();
-                    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
-                    {
-                        led new_led;
-
-                        new_led.name                = new_kb.GetKeyNameAt(led_idx);
-                        new_led.value               = new_kb.GetKeyValueAt(led_idx);
-                        max_led_value               = std::max(max_led_value, new_led.value);
-                        leds.push_back(new_led);
-                    }
-                }
-
-                /*---------------------------------------------------------*\
-                | Add 1 the max_led_value to account for the 0th index      |
-                \*---------------------------------------------------------*/
-                max_led_value++;
-            }
-
-            LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
-                      ((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
-                      new_zone.name.c_str(), new_zone.leds_count);
-            new_zone.leds_min                   = new_zone.leds_count;
-            new_zone.leds_max                   = new_zone.leds_count;
-            zones.push_back(new_zone);
+            led new_led;
+            new_led.value   = led_index + zone_offset;
+            new_led.name    = led_names[new_led.value];
+            leds.push_back(new_led);
        }
    }

    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Create a buffer map of pointers which contains the        |
-    |   layout order of colors the device expects.              |
-    \*---------------------------------------------------------*/
-    buffer_map.resize(max_led_value, &null_color);
-
-    for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        buffer_map[leds[led_idx].value] = &colors[led_idx];
-    }
 }

 void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
@@ -407,35 +459,36 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/

 void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
 {
-    for(size_t i = 85; i < leds.size(); i++)
+    controller->SetLedsDirect(colors);
+}
+
+void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; 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]));
+        colour.push_back(zones[zone].colors[i]);
    }

-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colour);
 }

-void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
+void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
 {
-    controller->SetLedsDirect(buffer_map);
-}
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);

-void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
-{
-    controller->SetLedsDirect(buffer_map);
+    controller->SetLedsDirect(colour);
 }

 void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
 {
    mode set_mode       = modes[active_mode];

+    if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
+    {
+        return;
+    }
    uint8_t random      = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
    RGBColor color1     = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
    RGBColor color2     = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
@@ -11,7 +11,6 @@

 #pragma once

-#include <algorithm>
 #include <vector>
 #include "RGBController.h"
 #include "AsusAuraCoreLaptopController.h"
@@ -32,8 +31,7 @@ public:
    void                DeviceUpdateMode();

 private:
-    RGBColor                            null_color              = 0;
-    std::vector<RGBColor *>             buffer_map;
+    void                Init_Controller();

-    AsusAuraCoreLaptopController*       controller;
+    AsusAuraCoreLaptopController*      controller;
 };
@@ -9,9 +9,13 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

+#include <stdio.h>
+#include <stdlib.h>
+#include <vector>
 #include "Detector.h"
 #include "AsusAuraGPUController.h"
 #include "LogManager.h"
+#include "RGBController.h"
 #include "RGBController_AsusAuraGPU.h"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
@@ -65,84 +69,72 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
 } /* DetectAsusAuraGPUControllers() */

 /*-----------------------------------------*\
-|  Nvidia GPUs                              |
+|  NVidia GPUs                              |
 \*-----------------------------------------*/

-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1050 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
-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_2,      0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1060_6G_GAMING,           0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1060,                     0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_8G_GAMING,           0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 OC",                    DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070_OC,                  0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1070 A8G Ti Gaming",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 A8G Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Gaming OC 11Gbps",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1080 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG Poseidon GeForce GTX 1080 Ti",                 DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_POSEIDON_GTX1080TI,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1650 SUPER A4G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_A4G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1650 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce GTX 1660 Ti Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_6G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO V2 Gaming",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_06G_EVO_V2_GAMING,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 EVO Gaming OC",         DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G EVO Gaming",  DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING_8702,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2060 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING_86FD,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 A8G Gaming",            DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2070 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Gaming",                DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Gaming OC",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 V2 Gaming OC",          DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER A8G Gaming",      DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER Gaming OC",       DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 SUPER White OC",        DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti Gaming",             DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX GeForce RTX 2080 Ti A11G Gaming",        DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
-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);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,   ASUS_GTX1050_STRIX_O2G_GAMING,              0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti 4G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_4G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 Ti O4G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix 6G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX_6G_GAMING,               0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1060 Strix"                      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,   ASUS_GTX1060_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix Gaming"               , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_GAMING,                  0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1070 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,   ASUS_GTX1070_STRIX_OC,                      0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti 8G Gaming"         , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1070 Ti A8G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1080 Strix OC"                   , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_GTX1080_STRIX,                         0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 O8G 11Gbps"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080_O8G_11GBPS,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650 SUPER OC 4G"          , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER O6G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 SUPER 6G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_GTX1660S_6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660 Ti OC 6G"             , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_GTX1660TI_OC,                      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G EVO Gaming" , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER 8G Gaming"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_DEV,         ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_8G_GAMING,           0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming"           , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER A8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G Gaming"     , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 SUPER O8G White"      , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming"        , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C,   0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming"       , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,   ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC"            , DetectAsusAuraGPUControllers,   NVIDIA_VEN,     NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,   ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A);

 /*-----------------------------------------*\
 |  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);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 480 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING,                    0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 480 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 560 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 560 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING_04BE,            0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 570 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 570 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 580 Gaming OC",                DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 580 Gaming TOP",               DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 590 Gaming",                   DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX590_STRIX_GAMING,                    0x29);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5600 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 Gaming OC",               DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700_STRIX_GAMING_OC,                0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX Radeon RX 5700 XT Gaming OC",            DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING_05C3,        0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G"               , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_VEGA10_DEV,             ASUS_SUB_VEN,   ASUS_VEGA64_STRIX,                          0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5600 XT Strix O6G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING,             0x2A);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 470 O4G Gaming"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX470_STRIX_O4G_GAMING,                0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 480 Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX480_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 560 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS11,              ASUS_SUB_VEN,   ASUS_RX560_STRIX_4G_GAMING,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O4G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 570 Strix O8G Gaming OC"          , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX570_STRIX_O8G_GAMING_OC,             0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming OC"              , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_OC,                 0x29);
+REGISTER_I2C_PCI_DETECTOR("ASUS ROG RX 580 Strix Gaming TOP"             , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX580_STRIX_GAMING_TOP,                0x29);
@@ -32,7 +32,7 @@ int RGBController_AuraGPU::GetDeviceMode()
        break;
    }

-    for(unsigned int mode = 0; mode < modes.size(); mode++)
+    for(int mode = 0; mode < modes.size(); mode++)
    {
        if(modes[mode].value == dev_mode)
        {
@@ -11,7 +11,6 @@

 #include <cstring>
 #include "AsusAuraHeadsetStandController.h"
-#include "StringUtils.h"

 AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
 {
@@ -39,7 +38,10 @@ std::string AuraHeadsetStandController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 std::string AuraHeadsetStandController::GetVersion()
@@ -11,7 +11,7 @@

 #pragma once

-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

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

 #include <cstring>
 #include "AsusAuraKeyboardController.h"
-#include "StringUtils.h"

 AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
 {
@@ -39,7 +38,10 @@ std::string AuraKeyboardController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AuraKeyboardController::SendDirect
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 class AuraKeyboardController
@@ -12,7 +12,6 @@
 #include <cstring>
 #include "AsusAuraMonitorController.h"
 #include "LogManager.h"
-#include "StringUtils.h"

 AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -41,7 +40,10 @@ std::string AuraMonitorController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 void AuraMonitorController::BeginUpdate()
@@ -11,7 +11,7 @@

 #pragma once

-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 enum
@@ -13,7 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Monitor
-    @category Accessory
+    @category LEDStrip
    @type USB
    @save :x:
    @direct :white_check_mark:
@@ -28,7 +28,7 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont

    name        = "ASUS Aura Monitor";
    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MONITOR;
+    type        = DEVICE_TYPE_LEDSTRIP;
    description = "ASUS Aura Monitor Device";
    location    = controller->GetDeviceLocation();
    serial      = controller->GetSerialString();
@@ -11,7 +11,6 @@

 #include <cstring>
 #include "AsusAuraMouseController.h"
-#include "StringUtils.h"

 AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -66,7 +65,10 @@ std::string AuraMouseController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = CleanSerial(serial_wstring);
+
+    return(return_string);
 }

 std::string AuraMouseController::GetVersion(bool wireless, int protocol)
@@ -12,7 +12,7 @@
 #pragma once

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraMouseDevices.h"

@@ -55,7 +55,6 @@
 #define AURA_ROG_KERIS_WIRELESS_AIMPOINT_2_4_PID        0x1A68
 #define AURA_ROG_KERIS_WIRELESS_AIMPOINT_BT_PID         0x1A6A
 #define AURA_TUF_M3_PID                                 0x1910
-#define AURA_TUF_M3_GEN_II_PID                          0x1A9B
 #define AURA_TUF_M5_PID                                 0x1898

 #define AURA_ROG_SPATHA_X_DOCK_FAKE_PID                 0xFFFF
@@ -637,20 +636,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
        }
    },
-    {
-        AURA_TUF_M3_GEN_II_PID, // TUF M3 Gen II
-        {
-            0,
-            0,
-            0,
-            100,
-            false,
-            1,
-            false,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
    {
        AURA_TUF_M5_PID, // TUF M5
        {
@@ -13,7 +13,6 @@
 #include <chrono>
 #include <thread>
 #include "AsusAuraMouseGen1Controller.h"
-#include "StringUtils.h"

 AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
 {
@@ -42,7 +41,10 @@ std::string AsusAuraMouseGen1Controller::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 std::string AsusAuraMouseGen1Controller::GetVersion()
@@ -13,7 +13,7 @@

 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"

 #define HID_MAX_STR 255
@@ -221,7 +221,7 @@ void RGBController_AsusROGSpatha::DeviceUpdateMode()

        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
        {
-            for(unsigned int j = 0; j < modes[active_mode].colors.size(); j++)
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
            {
                controller->SendUpdate(0x13 + j * 3 + i * 38, RGBGetRValue(modes[active_mode].colors[j]));
                controller->SendUpdate(0x14 + j * 3 + i * 38, RGBGetGValue(modes[active_mode].colors[j]));
@@ -255,7 +255,7 @@ void RGBController_AsusROGSpatha::DeviceSaveMode()

        if(modes[active_mode].value == ASUS_ROG_SPATHA_MODE_SPECTRUM_CYCLE || modes[active_mode].value == ASUS_ROG_SPATHA_MODE_BREATHING)
        {
-            for(unsigned int j = 0; j < modes[active_mode].colors.size(); j++)
+            for(int j = 0; j < modes[active_mode].colors.size(); j++)
            {
                controller->UpdateProfile(0x13 + j * 3 + i * 38, profile, RGBGetRValue(modes[active_mode].colors[j]));
                controller->UpdateProfile(0x14 + j * 3 + i * 38, profile, RGBGetGValue(modes[active_mode].colors[j]));
@@ -1,17 +1,14 @@
-/*---------------------------------------------------------*\
-| AsusAuraMousematController.cpp                            |
-|                                                           |
-|   Driver for ASUS Aura mousemat                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraMousematController.cpp           |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AsusAuraMousematController.h"
-#include "StringUtils.h"
+#include <cstring>

 AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
 {
@@ -39,7 +36,10 @@ std::string AuraMousematController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 std::string AuraMousematController::GetVersion()
@@ -1,18 +1,17 @@
-/*---------------------------------------------------------*\
-| AsusAuraMousematController.h                              |
-|                                                           |
-|   Driver for ASUS Aura mousemat                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraMousematController.h             |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>

 #pragma once

-#include <hidapi.h>
-#include "RGBController.h"

 enum
 {
@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraMousemat.cpp                        |
-|                                                           |
-|   RGBController for ASUS Aura mousemat                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.cpp       |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/10/2022   |
+\*-----------------------------------------*/

 #include "RGBController_AsusAuraMousemat.h"

@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraMousemat.h                          |
-|                                                           |
-|   RGBController for ASUS Aura mousemat                    |
-|                                                           |
-|   Mola19                                      06 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMousemat.h         |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/

 #pragma once
-
 #include "RGBController.h"
 #include "AsusAuraMousematController.h"

@@ -1,32 +1,28 @@
-/*---------------------------------------------------------*\
-| AsusAuraRyuoAIOController.cpp                             |
-|                                                           |
-|   Driver for ASUS Aura Ryuo                               |
-|                                                           |
-|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
-|   using snipets from Chris M (Dr.No)                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.cpp                                      |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/

 #include "AsusAuraRyuoAIOController.h"

 AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
-    /*-----------------------------------------------------*\
-    | Add addressable devices                               |
-    |    Manually adding device info for now                |
-    |    TODO: Implement config table accurately            |
-    \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
+	/*-----------------------------------------------------*\
+	| Add addressable devices                               |
+	|    Manually adding device info for now                |
+	|    TODO: Implement config table accurately            |
+	\*-----------------------------------------------------*/
+	device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
 }

 AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
 {
-    /*---------------------------------------------------------*\
-    | HID device is closed in the base class                    |
-    \*---------------------------------------------------------*/
+	hid_close(dev);
 }

 std::string AsusAuraRyuoAIOController::GetLocation()
@@ -36,10 +32,10 @@ std::string AsusAuraRyuoAIOController::GetLocation()

 void AsusAuraRyuoAIOController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
 {
-    /*---------------------------------------------------------*\
-    | This interface is not used in this controller however is  |
-    |   required by the abstract class                          |
-    \*---------------------------------------------------------*/
+	/*---------------------------------------------------------*\
+	| This interface is not used in this controller however is  |
+	|   required by the abstract class                          |
+	\*---------------------------------------------------------*/
 }

 void AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
@@ -1,22 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusAuraRyuoAIOController.h                               |
-|                                                           |
-|   Driver for ASUS Aura Ryuo                               |
-|                                                           |
-|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
-|   using snipets from Chris M (Dr.No)                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*-------------------------------------------------------------------*\
+|  AsusAuraRyuoAIOController.h                                        |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/

 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"

+#pragma once
+
 #define ASUSAURARYUOAIOCONTROLLER_TIMEOUT        250
 #define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR    255

@@ -1,14 +1,12 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraRyuoAIO.cpp                         |
-|                                                           |
-|   RGBController for ASUS Aura Ryuo                        |
-|                                                           |
-|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
-|   using snipets from Chris M (Dr.No)                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.cpp                                  |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/

 #include "RGBControllerKeyNames.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
@@ -180,7 +178,7 @@ void RGBController_AsusAuraRyuoAIO::ResizeZone(int /*zone*/, int /*new_size*/)

 void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
 {
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        UpdateZoneLEDs(zone_idx);
    }
@@ -205,7 +203,7 @@ void RGBController_AsusAuraRyuoAIO::DeviceUpdateMode()

 int RGBController_AsusAuraRyuoAIO::GetLED_Zone(int led_idx)
 {
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    for(int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
    {
        int zone_start = zones[zone_idx].start_idx;
        int zone_end = zone_start + zones[zone_idx].leds_count - 1;
@@ -1,21 +1,18 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraRyuoAIO.h                           |
-|                                                           |
-|   RGBController for ASUS Aura Ryuo                        |
-|                                                           |
-|   Cooper Hall (geobot19 / Geo_bot)            08 Apr 2022 |
-|   using snipets from Chris M (Dr.No)                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusAuraRyuoAIO.h                                    |
+|                                                                     |
+|  Driver for the ASUS Aura Ryuo AIO                                  |
+|    lighting controller                                              |
+|                                                                     |
+|  Cooper Hall (geobot19 / Geo_bot)          08 Apr 2022              |
+|  using snipets from Chris M (Dr.No)                                 |
+\*-------------------------------------------------------------------*/

 #pragma once
-
-#include <vector>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "AsusAuraRyuoAIOController.h"
+#include <vector>

 class RGBController_AsusAuraRyuoAIO : public RGBController
 {
@@ -1,23 +1,21 @@
-/*---------------------------------------------------------*\
-| AsusAuraTUFKeyboardController.cpp                         |
-|                                                           |
-|   Driver for ASUS Aura TUF keyboard                       |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraTUFKeyboardController.h"

-#include <cmath>
 #include <cstring>
-#include <math.h>
 #include <string>
+#include <vector>
+#include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <vector>
-#include "AsusAuraTUFKeyboardController.h"
-#include "StringUtils.h"
+#include <cmath>

 AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
 {
@@ -39,32 +37,42 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string AuraTUFKeyboardController::GetSerialString()
+std::string clean_serial(const std::wstring& wstr)
 {
-    wchar_t serial_string[HID_MAX_STR];
-    memset(serial_string, 0, sizeof(serial_string));
-
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-    if(ret != 0)
-    {
-        return("");
-    }
-
    /*-------------------------------------------------------------------------*\
    | Skip non-ASCII, trailing garbage in serial numbers. Required by the       |
    | Scope II 96, whose original firmware outputs garbage, which even differs  |
    | after computer reboots and therefore breaks OpenRGB profile matching.     |
    \*-------------------------------------------------------------------------*/
-    switch(device_pid)
+    std::string result;
+    for(wchar_t c : wstr)
    {
-        case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
-            serial_string[12] = L'\0';
-            break;
-        default:
+        // Forbid control chars and anything above final printable low-ASCII.
+        if(c < 32 || c > 126)
+        {
            break;
+        }
+
+        result += (char)c;
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    return(result);
+}
+
+std::string AuraTUFKeyboardController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = clean_serial(serial_wstring);
+
+    return(return_string);
 }

 std::string AuraTUFKeyboardController::GetVersion()
@@ -1,23 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusAuraTUFKeyboardController.h                           |
-|                                                           |
-|   Driver for ASUS Aura TUF keyboard                       |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/

-#pragma once
-
-#include <string>
-#include <vector>
-#include <hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraTUFKeyboardLayouts.h"

-#define HID_MAX_STR 128
+#include <string>
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#pragma once

 enum
 {
@@ -48,7 +45,6 @@ enum
    AURA_ROG_STRIX_FLARE_II_ANIMATE_PID                 = 0x19FC,
    AURA_ROG_STRIX_SCOPE_PID                            = 0x18F8,
    AURA_ROG_STRIX_SCOPE_RX_PID                         = 0x1951,
-    AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID                  = 0x1B12,
    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID     = 0x19F6,
    AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID     = 0x19F8,
    AURA_ROG_STRIX_SCOPE_II_PID                         = 0x1AB3,
@@ -1,21 +1,19 @@
-/*---------------------------------------------------------*\
-| AsusAuraTUFKeyboardLayouts.h                              |
-|                                                           |
-|   Layouts for ASUS Aura TUF keyboard                      |
-|                                                           |
-|   Mola19                                      02 Nov 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraTUFKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 10/02/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include <vector>
+#include <map>
+#include "RGBController.h"

 #pragma once

-#include <map>
-#include <vector>
-#include "RGBControllerKeyNames.h"
-#include "RGBController.h"
-
 enum
 {
    ASUS_TUF_K7_LAYOUT_CA    = 1,
@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraTUFKeyboard.cpp                     |
-|                                                           |
-|   RGBController for ASUS Aura TUF keyboard                |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2020                        |
+\*-----------------------------------------*/

-#include <cmath>
-#include <vector>
 #include "RGBController_AsusAuraTUFKeyboard.h"
+#include <vector>
+#include <cmath>

 /**------------------------------------------------------------------*\
    @name Asus Aura TUF Keyboard
@@ -67,7 +65,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
            case AURA_ROG_STRIX_FLARE_II_PID:
            case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
            case AURA_ROG_STRIX_SCOPE_RX_PID:
-            case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
            case AURA_ROG_STRIX_SCOPE_PID:
            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
            case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
@@ -141,7 +138,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
        Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
        Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
        if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
-
+        
        Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
        Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
        Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
@@ -420,7 +417,6 @@ void RGBController_AuraTUFKeyboard::SetupZones()
            break;
        case AURA_ROG_STRIX_SCOPE_PID:
        case AURA_ROG_STRIX_SCOPE_RX_PID:
-        case AURA_ROG_STRIX_SCOPE_RX_EVA_02_PID:
        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_USB_PID:
        case AURA_ROG_STRIX_SCOPE_NX_WIRELESS_DELUXE_2_4_PID:
            keyboard_ptr = &AsusROGStrixScopeLayouts;
@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraTUFKeyboard.h                       |
-|                                                           |
-|   RGBController for ASUS Aura TUF keyboard                |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraTUFKeyboard.h      |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/

 #pragma once
-
 #include "RGBController.h"
 #include "AsusAuraTUFKeyboardController.h"

@@ -1,16 +1,14 @@
-/*---------------------------------------------------------*\
-| AsusAuraAddressableController.cpp                         |
-|                                                           |
-|   Driver for ASUS Aura addressable controller             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraAddressableController.cpp        |
+|                                           |
+|  Driver for ASUS Aura RGB Addressable     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AsusAuraAddressableController.h"
+#include <cstring>

 AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
 {
@@ -1,21 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusAuraAddressableController.h                           |
-|                                                           |
-|   Driver for ASUS Aura addressable controller             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraAddressableController.h          |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  Addressable RGB lighting controller      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/

-#pragma once
-
-#include <string>
-#include <hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"

+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
 enum
 {
    AURA_ADDRESSABLE_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
@@ -1,16 +1,14 @@
-/*---------------------------------------------------------*\
-| AsusAuraMainboardController.cpp                           |
-|                                                           |
-|   Driver for ASUS Aura mainboard                          |
-|                                                           |
-|   Martin Hartl (inlart)                       25 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraMainboardController.cpp          |
+|                                           |
+|  Driver for ASUS Aura RGB USB mainboard   |
+|  lighting controller                      |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AsusAuraMainboardController.h"
+#include <cstring>

 AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
 {
@@ -39,7 +37,6 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
    for(int i = 0; i < num_addressable_headers; i++)
    {
        device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
-        effect_channel++;
    }
 }

@@ -1,21 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusAuraMainboardController.h                             |
-|                                                           |
-|   Driver for ASUS Aura mainboard                          |
-|                                                           |
-|   Martin Hartl (inlart)                       25 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraMainboardController.h            |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB Mainboard RGB lighting controller    |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/

-#pragma once
-
-#include <string>
-#include <hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"

+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
 enum
 {
    AURA_MAINBOARD_CONTROL_MODE_EFFECT            = 0x35,     /* Effect control mode                  */
@@ -1,18 +1,16 @@
-/*---------------------------------------------------------*\
-| AsusAuraUSBController.cpp                                 |
-|                                                           |
-|   Driver for ASUS Aura USB device                         |
-|                                                           |
-|   Martin Hartl (inlart)                       25 Apr 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusAuraUSBController.cpp                |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/

-#include <cstring>
 #include "AsusAuraUSBController.h"
 #include "LogManager.h"
-#include "StringUtils.h"
+
+#include <cstring>

 AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
 {
@@ -53,7 +51,10 @@ std::string AuraUSBController::GetSerialString()
        return("");
    }

-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }

 const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
--- a/Show More
+++ b/Show More