Add XPG Spectrix S20G to detectors for S40G

.gitlab-ci.yml

@@ -32,10 +32,7 @@ before_script:
 #-----------------------------------------------------------------------#
 "Supported Devices":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
   - qmake
@@ -45,7 +42,11 @@ before_script:
   artifacts:
     name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
     paths:
+    - ./*.md
     - Supported Devices.csv
+    exclude:
+    - README.md
+    - CONTRIBUTING.md
     expire_in: 30 days
 
   rules:
@@ -56,21 +57,18 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (AppImage) i386 Build Target                                    #
+# Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-"Linux i386 AppImage":
+"Linux 32 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
-  tags:
-  - linux
-  - i386
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_i386_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-i386.AppImage
     - 60-openrgb.rules
@@ -85,21 +83,18 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (AppImage) amd64 Build Target                                   #
+# Linux (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-"Linux amd64 AppImage":
+"Linux 64 AppImage":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - export $(dpkg-architecture)
   - ./scripts/build-appimage.sh
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_amd64_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
     paths:
     - OpenRGB-x86_64.AppImage
     - 60-openrgb.rules
@@ -107,25 +102,25 @@ before_script:
     expire_in: 30 days
 
 #-----------------------------------------------------------------------#
-# Linux (AppImage) armhf Build Target                                   #
+# Linux (.deb) Debian Buster (Legacy) 32-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux armhf AppImage":
+"Linux 32 .deb (Debian Buster)":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
-  tags:
-  - linux
-  - armhf
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
   stage: build
   script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_armhf_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - OpenRGB-armhf.AppImage
-    - 60-openrgb.rules
-    - README.md
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -136,25 +131,25 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (AppImage) arm64 Build Target                                   #
+# Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
 #-----------------------------------------------------------------------#
-"Linux arm64 AppImage":
+"Linux 64 .deb (Debian Buster)":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
-  tags:
-  - linux
-  - arm64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
   stage: build
   script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_arm64_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - OpenRGB-arm64.AppImage
-    - 60-openrgb.rules
-    - README.md
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
     expire_in: 30 days
 
   rules:
@@ -165,14 +160,69 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm i386 Build Target                        #
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
 #-----------------------------------------------------------------------#
-"Linux i386 .deb (Debian Bookworm)":
+"Linux 32 .deb (Debian Bullseye)":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
-  tags:
-  - linux
-  - i386
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bookworm 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   stage: build
   script:
   - ./scripts/build-package-files.sh debian/changelog
@@ -182,7 +232,7 @@ before_script:
   - mv -v ../openrgb*.deb ./
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_i386_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.deb
     exclude:
@@ -197,14 +247,11 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm amd64 Build Target                       #
+# Linux (.deb) Debian Bookworm 64-bit Build Target                      #
 #-----------------------------------------------------------------------#
-"Linux amd64 .deb (Debian Bookworm)":
+"Linux 64 .deb (Debian Bookworm)":
   <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
   script:
   - ./scripts/build-package-files.sh debian/changelog
@@ -214,7 +261,7 @@ before_script:
   - mv -v ../openrgb*.deb ./
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_amd64_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
     paths:
     - openrgb*.deb
     exclude:
@@ -229,28 +276,31 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm armhf Build Target                       #
+# Linux (.rpm, f35) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
-"Linux armhf .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
-  tags:
-  - linux
-  - armhf
+"Linux 64 f35 rpm":
+  image: fedora:35
   stage: build
   script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
+  - dnf install rpmdevtools dnf-plugins-core -y
+  - rpmdev-setuptree
+  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
+  - ls /root/
+  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
+  - cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
+  - cd /root/rpmbuild/SOURCES
+  - tar -cf OpenRGB.tar.gz OpenRGB/
+  - cd ..
+  - dnf builddep SPECS/OpenRGB.spec -y
+  - rpmbuild -ba SPECS/OpenRGB.spec
+  - cd RPMS/x86_64/
+  - mv openrgb*.rpm ${CI_PROJECT_DIR}/
+  - cd ${CI_PROJECT_DIR}
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_armhf_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
     paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
+    - openrgb*.rpm
     expire_in: 30 days
 
   rules:
@@ -261,42 +311,10 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Linux (.deb) Debian Bookworm arm64 Build Target                       #
+# Linux (.rpm, f36) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
-"Linux arm64 .deb (Debian Bookworm)":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
-  tags:
-  - linux
-  - arm64
-  stage: build
-  script:
-  - ./scripts/build-package-files.sh debian/changelog
-  - dpkg-architecture -l
-  - dpkg-buildpackage -us -B
-  - rm -v ../openrgb-dbgsym*.deb
-  - mv -v ../openrgb*.deb ./
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_arm64_deb_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - openrgb*.deb
-    exclude:
-    - openrgb-dbgsym*.deb
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-#-----------------------------------------------------------------------#
-# Linux (.rpm, F40) 64-bit Build Target                                 #
-#-----------------------------------------------------------------------#
-"Linux 64 F40 rpm":
-  image: fedora:40
+"Linux 64 f36 rpm":
+  image: fedora:36
   stage: build
   script:
   - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
@@ -328,9 +346,73 @@ before_script:
     allow_failure: true
 
 #-----------------------------------------------------------------------#
-# Debian i386 Bookworm test                                             #
+# Debian 32 Buster test                                                 #
 #-----------------------------------------------------------------------#
-"Debian i386 Bookworm":
+"Debian 32 Buster":
+  image: i386/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 32 .deb (Debian Buster)"
+  needs:
+  - "Linux 32 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 64 Buster":
+  image: amd64/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 32 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bullseye":
+  image: i386/debian:bullseye
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 32 .deb (Debian Bullseye)"
+  needs:
+  - "Linux 32 .deb (Debian Bullseye)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 64 Bullseye":
+  image: amd64/debian:bullseye
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Bullseye)"
+  needs:
+  - "Linux 64 .deb (Debian Bullseye)"
+
+#-----------------------------------------------------------------------#
+# Debian 32 Bookworm test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bookworm":
   image: i386/debian:bookworm
   stage: test
   script:
@@ -339,14 +421,14 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux i386 .deb (Debian Bookworm)"
+  - "Linux 32 .deb (Debian Bookworm)"
   needs:
-  - "Linux i386 .deb (Debian Bookworm)"
+  - "Linux 32 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Debian amd64 Bookworm test                                            #
+# Debian 64 Bookworm test                                               #
 #-----------------------------------------------------------------------#
-"Debian amd64 Bookworm":
+"Debian 64 Bookworm":
   image: amd64/debian:bookworm
   stage: test
   script:
@@ -355,14 +437,30 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
   needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu amd64 22.04 test                                               #
+# Ubuntu 64 20.04LTS test                                               #
 #-----------------------------------------------------------------------#
-"Ubuntu amd64 22.04LTS":
+"Ubuntu 64 20.04LTS":
+  image: ubuntu:focal
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 22.04 test                                                  #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 22.04LTS":
   image: ubuntu:jammy
   stage: test
   script:
@@ -371,40 +469,39 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
   needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu amd64 24.04 test                                               #
+# Fedora 64 v35 test                                                    #
 #-----------------------------------------------------------------------#
-"Ubuntu amd64 24.04LTS":
-  image: ubuntu:noble
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
-  needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
-
-#-----------------------------------------------------------------------#
-# Fedora 64 v40 test                                                    #
-#-----------------------------------------------------------------------#
-"Fedora 64 v40":
-  image: fedora:40
+"Fedora 64 v35":
+  image: fedora:35
   stage: test
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
   - yum -y remove openrgb
   dependencies:
-  - "Linux 64 F40 rpm"
+  - "Linux 64 f35 rpm"
   needs:
-  - "Linux 64 F40 rpm"
+  - "Linux 64 f35 rpm"
+
+#-----------------------------------------------------------------------#
+# Fedora 64 v36 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v36":
+  image: fedora:36
+  stage: test
+  script:
+  - yum -y localinstall ./openrgb*64.rpm
+  - openrgb --version
+  - yum -y remove openrgb
+  dependencies:
+  - "Linux 64 f36 rpm"
+  needs:
+  - "Linux 64 f36 rpm"
 
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #

.gitlab/CODEOWNERS

@@ -43,7 +43,6 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/EVGAGP102GPUController/
 /Controllers/EVGAPascalGPUController/
 /Controllers/EVGATuringGPUController/                       @TheRogueZeta
-/Controllers/EVGASMBusController/                           @balika011
 /Controllers/EVGAUSBController/                             @Dr_No
 /Controllers/EVisionKeyboardController/
 /Controllers/EspurnaController/

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -13,7 +13,7 @@
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "RGBController.h"
 

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.cpp

@@ -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()

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 #define HID_MAX_STR                     255

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -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).
 \*-------------------------------------------------------------------*/

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -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()

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 /*-----------------------------------------------------*\

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -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()

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -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

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -9,7 +9,7 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/
 
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -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

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 /*-----------------------------------------*\

Controllers/AOCMouseController/AOCMouseController.cpp

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

Controllers/AOCMouseController/AOCMouseController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 /*-----------------------------------------*\

Controllers/AOCMousematController/AOCMousematController.cpp

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

Controllers/AOCMousematController/AOCMousematController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 /*-----------------------------------------*\

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -15,7 +15,6 @@
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
-#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
 #include "dmiinfo.h"
 
@@ -81,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()

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

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

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -13,7 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
 #include "RGBController.h"

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -31,6 +31,7 @@ public:
     void        DeviceUpdateMode();
 
 private:
+    bool                            initializedMode;
     PolychromeUSBController*        controller;
     std::vector<PolychromeZoneInfo> zones_info;
 

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

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

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

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

Controllers/AlienwareController/AlienwareController.cpp

@@ -19,7 +19,6 @@
 #include "RGBController.h"
 #include "AlienwareController.h"
 #include "LogManager.h"
-#include "StringUtils.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -88,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             |
@@ -653,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)
@@ -680,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)

Controllers/AlienwareController/AlienwareController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 /*----------------------------------------------------------------------------------------------*\

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.cpp

@@ -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()

Controllers/AlienwareKeyboardController/AlienwareAW410KController/AlienwareAW410KController.h

@@ -13,7 +13,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.cpp

@@ -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()

Controllers/AlienwareKeyboardController/AlienwareAW510KController/AlienwareAW510KController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -7,7 +7,7 @@
 |   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/
 
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AlienwareAW510KController.h"
 #include "AlienwareAW410KController.h"

Controllers/AnnePro2Controller/AnnePro2Controller.cpp

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

Controllers/AnnePro2Controller/AnnePro2Controller.h

@@ -13,7 +13,7 @@
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 class AnnePro2Controller

Controllers/AnnePro2Controller/AnnePro2ControllerDetect.cpp

@@ -13,7 +13,7 @@
 #include "AnnePro2Controller.h"
 #include "RGBController.h"
 #include "RGBController_AnnePro2.h"
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 
 /*---------------------------------------------------------*\
 | Anne Pro 2 vendor IDs                                     |

Controllers/ArcticController/ArcticControllerDetect.cpp

@@ -47,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 )                  |
 \*---------------------------------------------------------------------------------------------------------*/

Controllers/AsusAuraCoreController/AsusAuraCoreController/AsusAuraCoreController.cpp

@@ -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

Controllers/AsusAuraCoreController/AsusAuraCoreController/AsusAuraCoreController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum AuraCoreDeviceType

Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp

@@ -15,7 +15,7 @@
 #include "RGBController.h"
 #include "RGBController_AsusAuraCore.h"
 #include "RGBController_AsusAuraCoreLaptop.h"
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 
 #define AURA_CORE_VID                   0x0B05
 

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp

@@ -11,7 +11,6 @@
 
 #include "AsusAuraCoreLaptopController.h"
 #include "SettingsManager.h"
-#include "StringUtils.h"
 
 static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT       +
                           ASUSAURACORELAPTOP_LIGHTBARCOUNT  +
@@ -67,19 +66,19 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
 
 AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
 {
+    const uint8_t sz    = HID_MAX_STR;
+    wchar_t       tmp[sz];
+
     dev                 = dev_handle;
     location            = path;
 
-    /*---------------------------------------------------------*\
-    | Get device name from HID manufacturer and product strings |
-    \*---------------------------------------------------------*/
-    wchar_t name_string[HID_MAX_STR];
+    hid_get_manufacturer_string(dev, tmp, sz);
+    std::wstring wName = std::wstring(tmp);
+    device_name = std::string(wName.begin(), wName.end());
 
-    hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
-    device_name = StringUtils::wstring_to_string(name_string);
-
-    hid_get_product_string(dev, name_string, HID_MAX_STR);
-    device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
+    hid_get_product_string(dev, tmp, sz);
+    wName = std::wstring(tmp);
+    device_name.append(" ").append(std::string(wName.begin(), wName.end()));
 
     SetPowerConfigFromJSON();
 }
@@ -96,15 +95,21 @@ std::string AsusAuraCoreLaptopController::GetDeviceName()
 
 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", 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()

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h

@@ -13,7 +13,7 @@
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ResourceManager.h"

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -90,7 +90,6 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1080 Ti Gaming"            , Detec
 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 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 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);
@@ -132,13 +131,10 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Vega 64 Strix"                       , Detec
 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 RX 5700 XT Strix 08G Gaming"         , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_NAVI10_DEV,             ASUS_SUB_VEN,   ASUS_RX5700XT_STRIX_O8G_GAMING_05C3,        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 STRIX 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 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);
-REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX 590 Gaming"                 , DetectAsusAuraGPUControllers,   AMD_GPU_VEN,    AMD_POLARIS_DEV,            ASUS_SUB_VEN,   ASUS_RX590_STRIX_GAMING,                    0x29);

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -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)
         {

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.cpp

@@ -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()

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.h

@@ -11,7 +11,7 @@
 
 #pragma once
 
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.cpp

@@ -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

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.h

@@ -13,7 +13,7 @@
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 class AuraKeyboardController

Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.cpp

@@ -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()

Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.h

@@ -11,7 +11,7 @@
 
 #pragma once
 
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -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_ACCESSORY;
+    type        = DEVICE_TYPE_LEDSTRIP;
     description = "ASUS Aura Monitor Device";
     location    = controller->GetDeviceLocation();
     serial      = controller->GetSerialString();

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.cpp

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

Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.h

@@ -12,7 +12,7 @@
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraMouseDevices.h"
 

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.cpp

@@ -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()

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.h

@@ -13,7 +13,7 @@
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 #define HID_MAX_STR 255

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

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

Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.cpp

@@ -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()

Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h

@@ -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
 {

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -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"
 

Controllers/AsusAuraUSBController/AsusAuraMousematController/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"
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp

@@ -1,14 +1,12 @@
-/*---------------------------------------------------------*\
-| 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"
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.h

@@ -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
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

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

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.h

@@ -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
 {

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.cpp

@@ -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)
 {
@@ -71,7 +69,10 @@ std::string AuraTUFKeyboardController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring serial_wstring = serial_string;
+    std::string return_string = clean_serial(serial_wstring);
+
+    return(return_string);
 }
 
 std::string AuraTUFKeyboardController::GetVersion()

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.h

@@ -1,21 +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 "RGBController.h"
+#include "AsusAuraTUFKeyboardLayouts.h"
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
-#include "RGBController.h"
-#include "AsusAuraTUFKeyboardLayouts.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
 
 enum
 {

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardLayouts.h

@@ -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,

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -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
@@ -140,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;

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.h

@@ -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"
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.cpp

@@ -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)
 {

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.h

@@ -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                  */

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp

@@ -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)
 {

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.h

@@ -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                  */

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.cpp

@@ -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

Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.h

@@ -1,21 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusAuraUSBController.h                                   |
-|                                                           |
-|   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.h                  |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/
 
-#pragma once
+#include "RGBController.h"
+#include "LogManager.h"
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
-#include "RGBController.h"
-#include "LogManager.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
 
 enum
 {
@@ -105,6 +104,7 @@ protected:
         );
 private:
     char                        device_name[16];
+    unsigned int                led_count;
 
     void GetConfigTable();
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp

@@ -1,13 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraMainboard.cpp                       |
-|                                                           |
-|   RGBController for ASUS Aura mainboard                   |
-|                                                           |
-|   rytypete                                    30 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMainboard.cpp      |
+|                                           |
+|  RGB controller for Asus Aura USB         |
+|  mainboards                               |
+|                                           |
+|  rytypete 8/30/2023                       |
+|  based on RGBController_AsusAuraUSB.cpp   |
+|  code                                     |
+\*-----------------------------------------*/
 
 #include "RGBController_AsusAuraMainboard.h"
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.h

@@ -1,16 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraMainboard.h                         |
-|                                                           |
-|   RGBController for ASUS Aura mainboard                   |
-|                                                           |
-|   rytypete                                    30 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraMainboard.h        |
+|                                           |
+|  RGB controller for Asus Aura USB         |
+|  mainboards                               |
+|                                           |
+|  rytypete 8/30/2023                       |
+|  based on RGBController_AsusAuraUSB.h     |
+|  code                                     |
+\*-----------------------------------------*/
 
 #pragma once
-
 #include "RGBController_AsusAuraUSB.h"
 #include "AsusAuraMainboardController.h"
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraUSB.cpp                             |
-|                                                           |
-|   RGBController for ASUS Aura USB device                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraUSB.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
 
 #include "RGBController_AsusAuraUSB.h"
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusAuraUSB.h                               |
-|                                                           |
-|   RGBController for ASUS Aura USB device                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                18 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusAuraUSB.h              |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
 
 #pragma once
-
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"
 

Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

@@ -1,14 +1,3 @@
-/*---------------------------------------------------------*\
-| AsusAuraUSBControllerDetect.cpp                           |
-|                                                           |
-|   Detector for ASUS Aura USB devices                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <stdexcept>
-#include <hidapi.h>
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
 #include "AsusAuraHeadsetStandController.h"
@@ -36,6 +25,8 @@
 #include "RGBController_AsusROGStrixEvolve.h"
 #include "RGBController_AsusAuraMonitor.h"
 #include "RGBController_AsusAuraRyuoAIO.h"
+#include <stdexcept>
+#include <hidapi/hidapi.h>
 #include "dmiinfo.h"
 
 #define AURA_USB_VID                                  0x0B05

Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.cpp

@@ -1,17 +1,14 @@
-/*---------------------------------------------------------*\
-| AsusROGAllyController.cpp                                 |
-|                                                           |
-|   Driver for ASUS ROG Ally                                |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusROGAllyController.cpp                |
+|                                           |
+|  Driver for ASUS ROG Ally lighting        |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "AsusROGAllyController.h"
-#include "StringUtils.h"
+#include <cstring>
 
 ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
 {
@@ -41,7 +38,10 @@ std::string ROGAllyController::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 ROGAllyController::GetVersion()
@@ -57,7 +57,7 @@ void ROGAllyController::SendInitialization()
 
     usb_buf[0x00]   = 0x5D;
     usb_buf[0x01]   = 0xB9;
-
+    
     hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
 
     memset(usb_buf, 0x00, sizeof(usb_buf));
@@ -77,7 +77,7 @@ void ROGAllyController::SendInitialization()
     usb_buf[0x0C]   = 0x6E;
     usb_buf[0x0D]   = 0x63;
     usb_buf[0x0E]   = 0x2E;
-
+    
     hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
 }
 
@@ -175,3 +175,4 @@ void ROGAllyController::SaveMode()
 
     hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
 }
+

Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.h

@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AsusROGAllyController.h                                   |
-|                                                           |
-|   Driver for ASUS ROG Ally                                |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusROGAllyController.h                  |
+|                                           |
+|  Definitions and types for ASUS ROG Ally  |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
 
 #pragma once
 
-#include <hidapi.h>
-#include "RGBController.h"
-
 enum
 {
     ROG_ALLY_MODE_STATIC           = 0,
@@ -48,7 +46,7 @@ public:
     std::string GetVersion();
 
     void SendInitialization();
-
+    
     void UpdateBrightness
         (
             unsigned char           brightness

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusROGAlly.cpp                             |
-|                                                           |
-|   RGBController for ASUS ROG Ally                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusROGAlly.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus ROG Ally  |
+|  controller driver                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AsusROGAlly.h"
 

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.h

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusROGAlly.h                               |
-|                                                           |
-|   RGBController for ASUS ROG Ally                         |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                12 Jul 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusROGAlly.cpp            |
+|                                           |
+|  Generic RGB Interface for Asus ROG Ally  |
+|  controller driver                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/12/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp

@@ -1,13 +1,12 @@
-/*---------------------------------------------------------*\
-| AsusROGStrixLCController.cpp                              |
-|                                                           |
-|   Driver for ASUS Aura liquid cooler                      |
-|                                                           |
-|   Chris M (Dr_No)                             17 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  AsusROGStrixLCController.cpp                                       |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
 
 #include "AsusROGStrixLCController.h"
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h

@@ -1,21 +1,20 @@
-/*---------------------------------------------------------*\
-| AsusROGStrixLCController.h                                |
-|                                                           |
-|   Driver for ASUS Aura liquid cooler                      |
-|                                                           |
-|   Chris M (Dr_No)                             17 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*-------------------------------------------------------------------*\
+|  AsusROGStrixLCController.h                                         |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 #include "AsusAuraUSBController.h"
 
+#pragma once
+
 #define ROGSTRIXLC_CONTROLLER_TIMEOUT 250
 #define HID_MAX_STR 255
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -1,13 +1,12 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusROGStrixLC.cpp                          |
-|                                                           |
-|   RGBController for ASUS Aura liquid cooler               |
-|                                                           |
-|   Chris M (Dr_No)                             17 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusROGStrixLC.cpp                                   |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
 
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AsusROGStrixLC.h"
@@ -181,7 +180,7 @@ void RGBController_AsusROGStrixLC::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_AsusROGStrixLC::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);
     }
@@ -206,7 +205,7 @@ void RGBController_AsusROGStrixLC::DeviceUpdateMode()
 
 int RGBController_AsusROGStrixLC::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;

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusROGStrixLC.h                            |
-|                                                           |
-|   RGBController for ASUS Aura liquid cooler               |
-|                                                           |
-|   Chris M (Dr_No)                             17 Jan 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  RGBController_AsusROGStrixLC.h                                     |
+|                                                                     |
+|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
+|    of lighting controllers                                          |
+|                                                                     |
+|  Chris M (Dr_No)          17 Jan 2022                               |
+|                                                                     |
+\*-------------------------------------------------------------------*/
 
 #pragma once
-
-#include <vector>
 #include "LogManager.h"
 #include "RGBController.h"
 #include "AsusROGStrixLCController.h"
+#include <vector>
 
 class RGBController_AsusROGStrixLC : public RGBController
 {

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/AsusCerberusKeyboardController.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| AsusCerberusKeyboardController.cpp                        |
-|                                                           |
-|   Driver for ASUS Cerberus keyboard                       |
-|                                                           |
-|   Mola19                                      28 May 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusCerberusKeyboardController.cpp       |
+|                                           |
+|  Driver for ASUS Cerberus USB lighting    |
+|  controller                               |
+|                                           |
+|  Mola19 05/28/2022                        |
+\*-----------------------------------------*/
 
 #include <cmath>
 #include <cstring>
@@ -17,7 +15,6 @@
 #include <string.h>
 #include <vector>
 #include "AsusCerberusKeyboardController.h"
-#include "StringUtils.h"
 
 #define ASUS_CERBERUS_KB_PACKET_SIZE 8
 
@@ -48,7 +45,10 @@ std::string AsusCerberusKeyboardController::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 AsusCerberusKeyboardController::GetVersion()

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/AsusCerberusKeyboardController.h

@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AsusCerberusKeyboardController.h                          |
-|                                                           |
-|   Driver for ASUS Cerberus keyboard                       |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusCerberusKeyboardController.h         |
+|                                           |
+|  Definitions and types for ASUS Cerberus  |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
 
 #pragma once
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum
@@ -27,6 +25,7 @@ enum
     CERBERUS_KEYBOARD_MODE_CUSTOM       = 7,
 };
 
+
 class AsusCerberusKeyboardController
 {
 public:

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusCerberusKeyboard.cpp                    |
-|                                                           |
-|   RGBController for ASUS Cerberus keyboard                |
-|                                                           |
-|   Mola19                                      28 May 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusCerberusKeyboard.cpp   |
+|                                           |
+|  Generic RGB Interface for Asus Cerberus  |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 05/28/2022                        |
+\*-----------------------------------------*/
 
 #include <cmath>
 #include <vector>
@@ -25,11 +23,12 @@
     @comment
 \*-------------------------------------------------------------------*/
 
+
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
 
-static unsigned int matrix_map[6][24] =
-{
+
+static unsigned int matrix_map[6][24] = {
     {   0,  NA,   9,  15,  20,  25,  NA,  35,  40,  45,  50,  56,  62,  67,  72,  NA,  75,  79,  84,  NA,  NA,  NA,  NA,  NA },
     {   1,   6,  10,  16,  21,  26,  30,  36,  41,  46,  51,  57,  63,  68,  NA,  NA,  76,  80,  85,  NA,  88,  93,  97, 102 },
     {   2,  NA,  11,  17,  22,  27,  31,  37,  42,  47,  52,  58,  64,  69,  NA,  NA,  77,  81,  86,  NA,  89,  94,  98, 103 },

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.h

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusCerberusKeyboard.h                      |
-|                                                           |
-|   RGBController for ASUS Cerberus keyboard                |
-|                                                           |
-|   Mola19                                      03 Mar 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusCerberusKeyboard.h     |
+|                                           |
+|  Generic RGB Interface for Asus Cerberus  |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 03/03/2021                        |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AsusLegacyUSBController/AsusLegacyUSBControllerDetect.cpp

@@ -1,14 +1,5 @@
-/*---------------------------------------------------------*\
-| AsusLegacyUSBControllerDetect.cpp                         |
-|                                                           |
-|   Detector for ASUS legacy USB devices                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include <stdexcept>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
 #include "AsusCerberusKeyboardController.h"
 #include "AsusSagarisKeyboardController.h"
@@ -64,6 +55,7 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,    ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
-REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard, ASUS_USB_VID,        ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);
-REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,       ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech",  DetectAsusCerberusMech,  ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID,  1, 0xFF01, 1);
+REGISTER_HID_DETECTOR_IPU("ASUS Sagaris GK1100", DetectAsusSagarisKeyboard,       ASUS_USB_VID,        ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);
+
+REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw,     ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/AsusSagarisKeyboardController.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| AsusSagarisKeyboardController.cpp                         |
-|                                                           |
-|   Driver for ASUS Sagaris keyboard                        |
-|                                                           |
-|   Mola19                                      20 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusSagarisKeyboardController.cpp        |
+|                                           |
+|  Driver for ASUS Sagaris USB lighting     |
+|  controller                               |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
 
 #include <cstring>
 #include <math.h>
@@ -16,7 +14,6 @@
 #include <vector>
 #include "AsusSagarisKeyboardController.h"
 #include "LogManager.h"
-#include "StringUtils.h"
 
 #define ASUS_SAGARIS_KB_PACKET_SIZE 65
 
@@ -52,7 +49,10 @@ std::string AsusSagarisKeyboardController::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);
 }
 
 sagaris_mode AsusSagarisKeyboardController::GetMode()

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/AsusSagarisKeyboardController.h

@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AsusSagarisKeyboardController.h                           |
-|                                                           |
-|   Driver for ASUS Sagaris keyboard                        |
-|                                                           |
-|   Mola19                                      20 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusSagarisKeyboardController.h          |
+|                                           |
+|  Definitions and types for ASUS Sagaris   |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
 
 #pragma once
 
 #include <string>
 #include <vector>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 enum

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusSagarisKeyboard.cpp                     |
-|                                                           |
-|   RGBController for ASUS Sagaris keyboard                 |
-|                                                           |
-|   Mola19                                      20 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusSagarisKeyboard.cpp    |
+|                                           |
+|  Generic RGB Interface for Asus Sagaris   |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
 
 #include <iostream>
 #include <vector>
@@ -26,129 +24,129 @@
 
 RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;
 
-    name                        = "ASUS Sagaris Keyboard";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "ASUS Sagaris Keyboard Device";
-    version                     = controller->GetVersion();
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
+    name        = "ASUS Sagaris Keyboard";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "ASUS Sagaris Keyboard Device";
+    version    = controller->GetVersion();
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Off;
-    Off.name                    = "Off";
-    Off.value                   = SAGARIS_KEYBOARD_MODE_OFF;
-    Off.flags                   = MODE_FLAG_AUTOMATIC_SAVE;
-    Off.color_mode              = MODE_COLORS_NONE;
+    Off.name                     = "Off";
+    Off.value                    = SAGARIS_KEYBOARD_MODE_OFF;
+    Off.flags                    = MODE_FLAG_AUTOMATIC_SAVE;
+    Off.color_mode               = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
-    Static.name                 = "Static";
-    Static.value                = SAGARIS_KEYBOARD_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
+    Static.name                  = "Static";
+    Static.value                 = SAGARIS_KEYBOARD_MODE_STATIC;
+    Static.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Static.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Static.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Static.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min            = 1;
+    Static.colors_max            = 1;
     Static.colors.resize(1);
     modes.push_back(Static);
 
     mode Spiral;
-    Spiral.name                 = "Spiral";
-    Spiral.value                = SAGARIS_KEYBOARD_MODE_SPRIAL;
-    Spiral.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Spiral.brightness_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Spiral.brightness_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Spiral.brightness           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Spiral.speed_min            = SAGARIS_KEYBOARD_SPEED_MIN;
-    Spiral.speed_max            = SAGARIS_KEYBOARD_SPEED_MAX;
-    Spiral.speed                = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Spiral.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Spiral.colors_min           = 7;
-    Spiral.colors_max           = 7;
+    Spiral.name                  = "Spiral";
+    Spiral.value                 = SAGARIS_KEYBOARD_MODE_SPRIAL;
+    Spiral.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Spiral.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Spiral.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Spiral.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Spiral.speed_min             = SAGARIS_KEYBOARD_SPEED_MIN;
+    Spiral.speed_max             = SAGARIS_KEYBOARD_SPEED_MAX;
+    Spiral.speed                 = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Spiral.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Spiral.colors_min            = 7;
+    Spiral.colors_max            = 7;
     Spiral.colors.resize(7);
     modes.push_back(Spiral);
 
     mode Custom;
-    Custom.name                 = "Custom";
-    Custom.value                = SAGARIS_KEYBOARD_MODE_CUSTOM;
-    Custom.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Custom.brightness_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Custom.brightness_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Custom.brightness           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Custom.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Custom.colors_min           = 7;
-    Custom.colors_max           = 7;
+    Custom.name                  = "Custom";
+    Custom.value                 = SAGARIS_KEYBOARD_MODE_CUSTOM;
+    Custom.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
+    Custom.brightness_min        = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Custom.brightness_max        = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Custom.brightness            = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Custom.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Custom.colors_min            = 7;
+    Custom.colors_max            = 7;
     Custom.colors.resize(7);
     modes.push_back(Custom);
 
     mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = SAGARIS_KEYBOARD_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min         = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.speed_max         = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.speed             = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min        = 7;
-    Breathing.colors_max        = 7;
+    Breathing.name               = "Breathing";
+    Breathing.value              = SAGARIS_KEYBOARD_MODE_BREATHING;
+    Breathing.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
+    Breathing.speed_min          = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Breathing.speed_max          = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Breathing.speed              = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Breathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.colors_min         = 7;
+    Breathing.colors_max         = 7;
     Breathing.colors.resize(7);
     modes.push_back(Breathing);
 
     mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = SAGARIS_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Reactive.brightness_min     = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness         = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Reactive.speed_min          = SAGARIS_KEYBOARD_SPEED_MIN;
-    Reactive.speed_max          = SAGARIS_KEYBOARD_SPEED_MAX;
-    Reactive.speed              = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min         = 1;
-    Reactive.colors_max         = 1;
+    Reactive.name                = "Reactive";
+    Reactive.value               = SAGARIS_KEYBOARD_MODE_REACTIVE;
+    Reactive.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Reactive.brightness_min      = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Reactive.brightness_max      = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Reactive.brightness          = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Reactive.speed_min           = SAGARIS_KEYBOARD_SPEED_MIN;
+    Reactive.speed_max           = SAGARIS_KEYBOARD_SPEED_MAX;
+    Reactive.speed               = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Reactive.color_mode          = MODE_COLORS_MODE_SPECIFIC;
+    Reactive.colors_min          = 1;
+    Reactive.colors_max          = 1;
     Reactive.colors.resize(1);
     modes.push_back(Reactive);
 
     mode Starry_Night;
-    Starry_Night.name           = "Starry Night";
-    Starry_Night.value          = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Starry_Night.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN;
-    Starry_Night.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX;
-    Starry_Night.brightness     = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Starry_Night.speed_min      = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Starry_Night.speed_max      = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Starry_Night.speed          = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.colors_min     = 7;
-    Starry_Night.colors_max     = 7;
+    Starry_Night.name            = "Starry Night";
+    Starry_Night.value           = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
+    Starry_Night.flags           = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Starry_Night.brightness_min  = SAGARIS_KEYBOARD_SPEED_MIN;
+    Starry_Night.brightness_max  = SAGARIS_KEYBOARD_SPEED_MAX;
+    Starry_Night.brightness      = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Starry_Night.speed_min       = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Starry_Night.speed_max       = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Starry_Night.speed           = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Starry_Night.color_mode      = MODE_COLORS_MODE_SPECIFIC;
+    Starry_Night.colors_min      = 7;
+    Starry_Night.colors_max      = 7;
     Starry_Night.colors.resize(7);
     modes.push_back(Starry_Night);
 
     mode Laser;
-    Laser.name                  = "Laser";
-    Laser.value                 = SAGARIS_KEYBOARD_MODE_LASER;
-    Laser.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Laser.brightness_min        = SAGARIS_KEYBOARD_SPEED_MIN;
-    Laser.brightness_max        = SAGARIS_KEYBOARD_SPEED_MAX;
-    Laser.brightness            = SAGARIS_KEYBOARD_SPEED_DEFAULT;
-    Laser.speed_min             = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
-    Laser.speed_max             = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
-    Laser.speed                 = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Laser.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Laser.colors_min            = 7;
-    Laser.colors_max            = 7;
+    Laser.name                   = "Laser";
+    Laser.value                  = SAGARIS_KEYBOARD_MODE_LASER;
+    Laser.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    Laser.brightness_min         = SAGARIS_KEYBOARD_SPEED_MIN;
+    Laser.brightness_max         = SAGARIS_KEYBOARD_SPEED_MAX;
+    Laser.brightness             = SAGARIS_KEYBOARD_SPEED_DEFAULT;
+    Laser.speed_min              = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
+    Laser.speed_max              = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
+    Laser.speed                  = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
+    Laser.color_mode             = MODE_COLORS_MODE_SPECIFIC;
+    Laser.colors_min             = 7;
+    Laser.colors_max             = 7;
     Laser.colors.resize(7);
     modes.push_back(Laser);
 
     SetupZones();
 
-    sagaris_mode current_mode   = controller->GetMode();
+    sagaris_mode current_mode = controller->GetMode();
 
     active_mode = current_mode.mode;
     last_mode   = current_mode.mode;
@@ -157,7 +155,7 @@ RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagaris
 
     current_colors = controller->GetColors();
 
-    for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
+    for(int i = 0; i < modes[active_mode].colors.size(); i++)
     {
         modes[active_mode].colors[i] = current_colors[i];
     }
@@ -206,19 +204,19 @@ void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
     if(last_mode != active_mode)
     {
         last_mode = active_mode;
-        for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
         {
             modes[active_mode].colors[i] = current_colors[i];
         }
     }
     else
     {
-        for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
         {
             current_colors[i] = modes[active_mode].colors[i];
         }
 
-        for(unsigned int i = 0; i < modes[active_mode].colors.size(); i++)
+        for(int i = 0; i < modes[active_mode].colors.size(); i++)
         {
             /*-----------------------------------------*\
             | This device uses 4bit colorValues (0-16)  |
@@ -241,10 +239,7 @@ void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
 
     uint8_t mode = modes[active_mode].value;
 
-    if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT)
-    {
-        colorIndex = 7;
-    }
+    if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7;
 
     controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
 }

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.h

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusSagarisKeyboard.h                       |
-|                                                           |
-|   RGBController for ASUS Sagaris keyboard                 |
-|                                                           |
-|   Mola19                                      20 Aug 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusSagarisKeyboard.h      |
+|                                           |
+|  Generic RGB Interface for Asus Sagaris   |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 08/20/2023                        |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AsusLegacyUSBController/AsusStrixClawController/AsusStrixClawController.cpp

@@ -1,18 +1,15 @@
-/*---------------------------------------------------------*\
-| AsusStrixClawController.cpp                               |
-|                                                           |
-|   Driver for ASUS Strix Claw mouse                        |
-|                                                           |
-|   Mola19                                      06 Aug 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusStrixClawController.cpp              |
+|                                           |
+|  Driver for ASUS Strix USB                |
+|  lighting controller                      |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
 
 #include <cstring>
 #include <string>
 #include "AsusStrixClawController.h"
-#include "StringUtils.h"
 
 StrixClawController::StrixClawController(hid_device* dev_handle, const char* path)
 {
@@ -40,7 +37,10 @@ std::string StrixClawController::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 StrixClawController::GetVersion()

Controllers/AsusLegacyUSBController/AsusStrixClawController/AsusStrixClawController.h

@@ -1,18 +1,16 @@
-/*---------------------------------------------------------*\
-| AsusStrixClawController.h                                 |
-|                                                           |
-|   Driver for ASUS Strix Claw mouse                        |
-|                                                           |
-|   Mola19                                      06 Aug 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AsusStrixClawController.h                |
+|                                           |
+|  Definitions and types for ASUS           |
+|  Legacy USB RGB lighting controller       |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
 
 #pragma once
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "RGBController.h"
 
 #define HID_MAX_STR 255

Controllers/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusStrixClaw.cpp                           |
-|                                                           |
-|   RGBController for ASUS Strix Claw mouse                 |
-|                                                           |
-|   Mola19                                      06 Aug 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusStrixClaw.cpp          |
+|                                           |
+|  Generic RGB Interface for Asus           |
+|  Legacy USB controller driver             |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
 
 #include "RGBController_AsusStrixClaw.h"
 
@@ -104,17 +102,17 @@ void RGBController_StrixClaw::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_StrixClaw::DeviceUpdateLEDs()
 {
-
+    
 }
 
 void RGBController_StrixClaw::UpdateZoneLEDs(int /*zone*/)
 {
-
+    
 }
 
 void RGBController_StrixClaw::UpdateSingleLED(int /*led*/)
 {
-
+    
 }
 
 void RGBController_StrixClaw::DeviceUpdateMode()

Controllers/AsusLegacyUSBController/AsusStrixClawController/RGBController_AsusStrixClaw.h

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AsusStrixClaw.h                             |
-|                                                           |
-|   RGBController for ASUS Strix Claw mouse                 |
-|                                                           |
-|   Mola19                                      06 Aug 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AsusStrixClaw.h            |
+|                                           |
+|  Generic RGB Interface for Asus           |
+|  Legacy USB controller driver             |
+|                                           |
+|  Mola19 08/06/2022                        |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AsusTUFLaptopController/AsusTUFLaptopController_Linux.cpp

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AsusTUFLaptopController_Linux.cpp                         |
-|                                                           |
-|   Driver for ASUS TUF laptop                              |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include <string>
 #include "AsusTUFLaptopController_Linux.h"
 

Controllers/AsusTUFLaptopController/AsusTUFLaptopController_Linux.h

@@ -1,13 +1,5 @@
-/*---------------------------------------------------------*\
-| AsusTUFLaptopController_Linux.h                           |
-|                                                           |
-|   Driver for ASUS TUF laptop                              |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+#ifndef ASUSTUFLAPTOPLINUXCONTROLLER_H
+#define ASUSTUFLAPTOPLINUXCONTROLLER_H
 
 #include "RGBController.h"
 
@@ -41,3 +33,5 @@ public:
             unsigned char   blue
             );
 };
+
+#endif // ASUSTUFLAPTOPLINUXCONTROLLER_H