Initialize NZXT Hue 2 fan reporting

[FAN Controller] Initial implementation for Asus TUF Fan controller
Add basic Razer Blade 14 2021 fan control based on razer-fan-control's reverse engineering effort. Commanding zero speed sets auto fan control mode
2024-10-05 17:54:39 -05:00 · 2024-10-05 16:03:50 -05:00 · 2024-10-05 16:03:50 -05:00 · 2024-10-05 16:03:50 -05:00 · 2024-10-05 16:03:50 -05:00 · 2024-10-05 16:03:49 -05:00
3473 changed files with 456982 additions and 111475 deletions
@@ -1,6 +1,6 @@
 # These are supported funding model platforms

-github: CalcProgrammer1
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: CalcProgrammer1
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
@@ -1,21 +0,0 @@
-name: Issue Opened
-
-on:
-  issues:
-    types: [opened,reopened]
-
-jobs:
-  issue_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Greeting
-        run: gh issue comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.issue.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            For any new issue please refer to https://gitlab.com/CalcProgrammer1/OpenRGB/-/issues
@@ -1,21 +0,0 @@
-name: PR Opened
-
-on:
-  pull_request:
-    types: [opened,reopened]
-
-jobs:
-  pr_greeting:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - name: Greeting
-        run: gh pr comment "$NUMBER" --body "$BODY"
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          NUMBER: ${{ github.event.pull_request.number }}
-          BODY: >
-            This Github repo is a mirror of the main repository on Gitlab.
-            Please fork https://gitlab.com/CalcProgrammer1/OpenRGB/ and raise the appropriate merge request on Gitlab.
@@ -8,9 +8,6 @@ OpenRGB-x86_64.AppImage
 60-openrgb.rules
 debian/changelog
 fedora/OpenRGB.spec
-OpenRGB_resource.rc
-OpenRGB Windows 32-bit/
-OpenRGB Windows 64-bit/

 # Directories
 .build/
@@ -31,7 +28,6 @@ Build/
 .qmake.stash
 .vscode
 .vs
-.idea

 # Generic Files
 .DS_Store
@@ -1,34 +1,12 @@
-#-----------------------------------------------------------#
-# .gitlab-ci.yml                                            #
-#                                                           #
-#   OpenRGB GitLab CI Configuration                         #
-#                                                           #
-#   This file is part of the OpenRGB project                #
-#   SPDX-License-Identifier: GPL-2.0-or-later               #
-#-----------------------------------------------------------#
+# swy: some useful references; the MSVC part of the CI script is based on the one from bind9, by Michał Kępień:
+# https://gitlab.com/gitlab-org/ci-cd/shared-runners/images/gcp/windows-containers/blob/master/cookbooks/preinstalled-software/README.md
+# https://gitlab.isc.org/isc-projects/bind9/commit/facc6a051fcac70fbbc61cb92a37be8c3e4db5ec#587d266bb27a4dc3022bbed44dfa19849df3044c_718_731
+# https://www.kittell.net/code/powershell-unix-sed-equivalent-change-text-file/
+# https://powershell.org/forums/topic/how-to-use-ansi-vt100-formatting-in-powershell-ooh-pretty-colors/

-#-----------------------------------------------------------#
-# GitLab CI Rules                                           #
-#                                                           #
-# * For downstream forks (not on CalcProgrammer1/OpenRGB),  #
-#   run only if manually started to save CI minutes if      #
-#   GitLab hosted runners                                   #
-# * For commits to the CalcProgrammer1/OpenRGB repository,  #
-#   automatically run all jobs on the default branch,       #
-#   otherwise run them if the source is part of a merge     #
-#   request                                                 #
-#-----------------------------------------------------------#
-.downstream_rules:
-  rules:
-  - if: $CI_PROJECT_PATH != "CalcProgrammer1/OpenRGB" && $CI_PIPELINE_SOURCE == "push"
-    when: manual
-    allow_failure: true
-
-.upstream_rules:
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" && ($CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH || $CI_PIPELINE_SOURCE == "merge_request_event")'
-    when: on_success
-  - !reference [.downstream_rules, rules]
+#-----------------------------------------------------------------------#
+# OpenRGB GitLab CI Configuration                                       #
+#-----------------------------------------------------------------------#

 .shared_windows_runners:
  tags:
@@ -39,18 +17,21 @@
 stages:
  - build
  - test
-  - deploy
-
-variables:
-  GIT_DEPTH: 0

 before_script:
 - echo "started by ${GITLAB_USER_NAME}"

-#-----------------------------------------------------------#
-# Supported Devices Build Target                            #
-#-----------------------------------------------------------#
+#reusable templates
+.ccache_init: &ccache_init
+  before_script:
+    - export QT_SELECT=qt5
+    - export APPIMAGE_EXTRACT_AND_RUN=1
+
+#-----------------------------------------------------------------------#
+# Supported Devices Build Target                                        #
+#-----------------------------------------------------------------------#
 "Supported Devices":
+  <<: *ccache_init
  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
  tags:
  - linux
@@ -68,138 +49,131 @@ before_script:
    expire_in: 30 days

  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

-#-----------------------------------------------------------#
-# OpenRGB Common Appimage Build Steps                       #
-#-----------------------------------------------------------#
-.hidden_appimage_script: &appimage_script_steps
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
+#-----------------------------------------------------------------------#
+# Linux (AppImage) i386 Build Target                                    #
+#-----------------------------------------------------------------------#
+"Linux i386 AppImage":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
  tags:
  - linux
-  - ${TGT_ARCH}
+  - i386
  stage: build
  script:
  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh ${TGT_QT}
+  - ./scripts/build-appimage.sh

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_${TGT_NAME}_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_i386_${CI_COMMIT_SHORT_SHA}"
    paths:
-    - OpenRGB-${TGT_PATH}.AppImage
+    - OpenRGB-i386.AppImage
    - 60-openrgb.rules
    - README.md
    expire_in: 30 days

  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

-#-----------------------------------------------------------#
-# Linux (AppImage) i386 Build Target                        #
-#-----------------------------------------------------------#
-"Linux i386 AppImage":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) Qt6 i386 Build Target                    #
-#-----------------------------------------------------------#
-"Linux i386 AppImage Qt6":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) amd64 Build Target                       #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Linux (AppImage) amd64 Build Target                                   #
+#-----------------------------------------------------------------------#
 "Linux amd64 AppImage":
-  variables:
-    TGT_ARCH: "amd64"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}"
-    TGT_PATH: "x86_64"
-  <<: *appimage_script_steps
-  rules:
-  - !reference [.upstream_rules, rules]
-
-"Linux amd64 AppImage (Downstream)":
-  extends: "Linux amd64 AppImage"
-  rules:
-  - !reference [.downstream_rules, rules]
-  tags:
-  - "saas-linux-small-amd64"
-
-#-----------------------------------------------------------#
-# Linux (AppImage) Qt6 amd64 Build Target                   #
-#-----------------------------------------------------------#
-"Linux amd64 AppImage Qt6":
-  variables:
-    TGT_ARCH: "amd64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
-    TGT_PATH: "x86_64"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) armhf Build Target                       #
-#-----------------------------------------------------------#
-"Linux armhf AppImage":
-  variables:
-    TGT_ARCH: "armhf"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) Qt6 armhf Build Target                   #
-#-----------------------------------------------------------#
-"Linux armhf AppImage Qt6":
-  variables:
-    TGT_ARCH: "armhf"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) arm64 Build Target                       #
-#-----------------------------------------------------------#
-"Linux arm64 AppImage":
-  variables:
-    TGT_ARCH: "arm64"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# Linux (AppImage) Qt6 arm64 Build Target                   #
-#-----------------------------------------------------------#
-"Linux arm64 AppImage Qt6":
-  variables:
-    TGT_ARCH: "arm64"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
-
-#-----------------------------------------------------------#
-# OpenRGB Common Debian Build Steps                         #
-#-----------------------------------------------------------#
-.hidden_deb_script: &debian_script_steps
-  stage: build
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:$TGT_DEB-$TGT_ARCH
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
  tags:
  - linux
-  - $TGT_ARCH
+  - amd64
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_amd64_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-x86_64.AppImage
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
+
+#-----------------------------------------------------------------------#
+# Linux (AppImage) armhf Build Target                                   #
+#-----------------------------------------------------------------------#
+"Linux armhf AppImage":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
+  tags:
+  - linux
+  - armhf
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_armhf_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-armhf.AppImage
+    - 60-openrgb.rules
+    - README.md
+    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 (AppImage) arm64 Build Target                                   #
+#-----------------------------------------------------------------------#
+"Linux arm64 AppImage":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-arm64
+  tags:
+  - linux
+  - arm64
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_arm64_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-arm64.AppImage
+    - 60-openrgb.rules
+    - README.md
+    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 i386 Build Target                        #
+#-----------------------------------------------------------------------#
+"Linux i386 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
+  tags:
+  - linux
+  - i386
+  stage: build
  script:
  - ./scripts/build-package-files.sh debian/changelog
  - dpkg-architecture -l
@@ -208,100 +182,132 @@ before_script:
  - mv -v ../openrgb*.deb ./

  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_i386_deb_${CI_COMMIT_SHORT_SHA}"
    paths:
    - openrgb*.deb
    exclude:
    - openrgb-dbgsym*.deb
    expire_in: 30 days
+
  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

-#-----------------------------------------------------------#
-# Linux (.deb) Debian Bookworm i386 Build Target            #
-#-----------------------------------------------------------#
-"Linux i386 .deb (Debian Bookworm)":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_DEB: "bookworm"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Trixie i386 Build Target              #
-#-----------------------------------------------------------#
-"Linux i386 .deb (Debian Trixie)":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_DEB: "trixie"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Bookworm amd64 Build Target           #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Linux (.deb) Debian Bookworm amd64 Build Target                       #
+#-----------------------------------------------------------------------#
 "Linux amd64 .deb (Debian Bookworm)":
-  variables:
-    TGT_ARCH: "amd64"
-    TGT_DEB: "bookworm"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Trixie amd64 Build Target             #
-#-----------------------------------------------------------#
-"Linux amd64 .deb (Debian Trixie)":
-  variables:
-    TGT_ARCH: "amd64"
-    TGT_DEB: "trixie"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Bookworm armhf Build Target           #
-#-----------------------------------------------------------#
-"Linux armhf .deb (Debian Bookworm)":
-  variables:
-    TGT_ARCH: "armhf"
-    TGT_DEB: "bookworm"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Trixie armhf Build Target             #
-#-----------------------------------------------------------#
-"Linux armhf .deb (Debian Trixie)":
-  variables:
-    TGT_ARCH: "armhf"
-    TGT_DEB: "trixie"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Bookworm arm64 Build Target           #
-#-----------------------------------------------------------#
-"Linux arm64 .deb (Debian Bookworm)":
-  variables:
-    TGT_ARCH: "arm64"
-    TGT_DEB: "bookworm"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.deb) Debian Trixie arm64 Build Target             #
-#-----------------------------------------------------------#
-"Linux arm64 .deb (Debian Trixie)":
-  variables:
-    TGT_ARCH: "arm64"
-    TGT_DEB: "trixie"
-  <<: *debian_script_steps
-
-#-----------------------------------------------------------#
-# Linux (.rpm, F43) 64-bit Build Target                     #
-#-----------------------------------------------------------#
-"Linux 64 F43 rpm":
-  image: fedora:43
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
+  tags:
+  - linux
+  - amd64
  stage: build
  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
+  - ./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_amd64_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 armhf Build Target                       #
+#-----------------------------------------------------------------------#
+"Linux armhf .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-armhf
+  tags:
+  - linux
+  - armhf
+  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_armhf_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 arm64 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
+  stage: build
+  script:
+  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
  - rpmdev-setuptree
  - ./scripts/build-package-files.sh fedora/OpenRGB.spec
+  - ls /root/
  - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
-  - cp -rp . /root/rpmbuild/SOURCES/OpenRGB
-  - cd /root/rpmbuild
+  - 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/
@@ -315,11 +321,15 @@ before_script:
    expire_in: 30 days

  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

-#-----------------------------------------------------------#
-# Debian i386 Bookworm test                                 #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Debian i386 Bookworm test                                             #
+#-----------------------------------------------------------------------#
 "Debian i386 Bookworm":
  image: i386/debian:bookworm
  stage: test
@@ -332,12 +342,10 @@ before_script:
  - "Linux i386 .deb (Debian Bookworm)"
  needs:
  - "Linux i386 .deb (Debian Bookworm)"
-  rules:
-  - !reference [.upstream_rules, rules]

-#-----------------------------------------------------------#
-# Debian amd64 Bookworm test                                #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Debian amd64 Bookworm test                                            #
+#-----------------------------------------------------------------------#
 "Debian amd64 Bookworm":
  image: amd64/debian:bookworm
  stage: test
@@ -350,12 +358,26 @@ before_script:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
  - "Linux amd64 .deb (Debian Bookworm)"
-  rules:
-  - !reference [.upstream_rules, rules]

-#-----------------------------------------------------------#
-# Ubuntu amd64 24.04 test                                   #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Ubuntu amd64 22.04 test                                               #
+#-----------------------------------------------------------------------#
+"Ubuntu amd64 22.04LTS":
+  image: ubuntu:jammy
+  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)"
+
+#-----------------------------------------------------------------------#
+# Ubuntu amd64 24.04 test                                               #
+#-----------------------------------------------------------------------#
 "Ubuntu amd64 24.04LTS":
  image: ubuntu:noble
  stage: test
@@ -368,36 +390,85 @@ before_script:
  - "Linux amd64 .deb (Debian Bookworm)"
  needs:
  - "Linux amd64 .deb (Debian Bookworm)"
-  rules:
-  - !reference [.upstream_rules, rules]

-#-----------------------------------------------------------#
-# Fedora 64 v43 test                                        #
-#-----------------------------------------------------------#
-"Fedora 64 v43":
-  image: fedora:43
+#-----------------------------------------------------------------------#
+# Fedora 64 v40 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v40":
+  image: fedora:40
  stage: test
  script:
-  - dnf5 -y install ./openrgb*64.rpm
+  - yum -y localinstall ./openrgb*64.rpm
  - openrgb --version
-  - dnf5 -y remove openrgb
+  - yum -y remove openrgb
  dependencies:
-  - "Linux 64 F43 rpm"
+  - "Linux 64 F40 rpm"
  needs:
-  - "Linux 64 F43 rpm"
-  rules:
-  - !reference [.upstream_rules, rules]
+  - "Linux 64 F40 rpm"

-#-----------------------------------------------------------#
-# Windows (32-bit) Build Target                             #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# Windows (32-bit) Build Target                                         #
+#-----------------------------------------------------------------------#
 "Windows 32":
  extends:
  - .shared_windows_runners
  stage: build
  script:
-  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 32
+  - $esc = "$([char]27)"
+  - $count = 0
+  - function _unix_tmsec_ { [int64](([datetime]::UtcNow)-(get-date "1/1/1970")).TotalSeconds }
+  - function _fold_start_ { param( [string]$TEXT_TAG ) $t=_unix_tmsec_; $global:count += 1; Write-Host -NoNewLine "`r`n`r`nsection_start:${t}:sect_${count}`r${esc}[0K${esc}[33m${TEXT_TAG}${esc}[39m`r`n"; }
+  - function _fold_final_ {                            $t=_unix_tmsec_;                     Write-Host -NoNewLine   "`r`n`r`nsection_end:${t}:sect_${count}`r${esc}[0K`r`n"           ; }
+
+
+  - _fold_start_ 'configuring the msvc environment variables'
+  - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
+  - '& cmd.exe /C "vcvarsall.bat x86 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }'
+  - Pop-Location
+  - _fold_final_
+
+  - _fold_start_ 'downloading precompiled versions of qtbase, qttools (for windeployqt) and jom (for a more parallel nmake)'
+  - mkdir _qt
+  - mkdir _qt_download
+  - Push-Location _qt_download
+  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
+  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
+  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - _fold_final_
+
+  - _fold_start_ 'extracting the downloaded qt binaries'
+  - 7z x qt-base.7z  '-o../_qt' -y
+  - 7z x qt-tools.7z '-o../_qt' -y
+  - 7z x qt-jom.zip  '-o../_qt' -y
+  - _fold_final_
+
+  - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
+  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019\mkspecs\qconfig.pri'
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
+  - Pop-Location
+  - _fold_final_
+
+  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
+  - mkdir _build; cd _build
+  - ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
+  - _fold_final_
+
+  - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
+  - ..\_qt\jom
+  - _fold_final_
+
+  - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
+  - ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
+  - _fold_final_
+
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 32-bit'
+  - _fold_final_
+#  cache:
+#    key: same-key
+#    paths:
+#    - C:\vcpkg\installed\
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -407,39 +478,75 @@ before_script:
    expire_in: 30 days

  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

-#-----------------------------------------------------------#
-# Windows (32-bit) Qt6 Build Target                         #
-#-----------------------------------------------------------#
-"Windows 32 Qt6":
+#-----------------------------------------------------------------------#
+# Windows (64-bit) Build Target                                         #
+#-----------------------------------------------------------------------#
+"Windows 64":
  extends:
  - .shared_windows_runners
  stage: build
  script:
-  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 32
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_32_Qt6_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - 'OpenRGB Windows 32-bit'
-    exclude:
-    - 'OpenRGB Windows 32-bit\*.qm'
-    expire_in: 30 days
+  - $esc = "$([char]27)"
+  - $count = 0
+  - function _unix_tmsec_ { [int64](([datetime]::UtcNow)-(get-date "1/1/1970")).TotalSeconds }
+  - function _fold_start_ { param( [string]$TEXT_TAG ) $t=_unix_tmsec_; $global:count += 1; Write-Host -NoNewLine "`r`n`r`nsection_start:${t}:sect_${count}`r${esc}[0K${esc}[33m${TEXT_TAG}${esc}[39m`r`n"; }
+  - function _fold_final_ {                            $t=_unix_tmsec_;                     Write-Host -NoNewLine   "`r`n`r`nsection_end:${t}:sect_${count}`r${esc}[0K`r`n"           ; }

-  rules:
-    - !reference [.upstream_rules, rules]

-#-----------------------------------------------------------#
-# Windows (64-bit) Build Target                             #
-#-----------------------------------------------------------#
-"Windows 64 Base":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 5.15.0 2019 64
+  - _fold_start_ 'configuring the msvc environment variables'
+  - Push-Location "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
+  - '& cmd.exe /C "vcvarsall.bat x64 & set" | Foreach-Object { if ($_ -match "(.*?)=(.*)") { Set-Item -force -path "Env:\$($matches[1])" -value "$($matches[2])" } }'
+  - Pop-Location
+  - _fold_final_
+
+  - _fold_start_ 'downloading precompiled versions of qtbase, qttools (for windeployqt) and jom (for a more parallel nmake)'
+  - mkdir _qt
+  - mkdir _qt_download
+  - Push-Location _qt_download
+  - curl.exe -LJ -o qt-base.7z  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
+  - curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
+  - curl.exe -LJ -o qt-jom.zip  'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
+  - _fold_final_
+
+  - _fold_start_ 'extracting the downloaded qt binaries'
+  - 7z x qt-base.7z  '-o../_qt' -y
+  - 7z x qt-tools.7z '-o../_qt' -y
+  - 7z x qt-jom.zip  '-o../_qt' -y
+  - _fold_final_
+
+  - _fold_start_ 'turn the qt install from enterprise to foss; remove the licensing checks'
+  - ${qconfig-pri-folder} = '..\_qt\5.15.0\msvc2019_64\mkspecs\qconfig.pri'
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_EDITION = Enterprise', 'QT_EDITION = OpenSource') | Set-Content ${qconfig-pri-folder}
+  - (Get-Content ${qconfig-pri-folder}).replace('QT_LICHECK = licheck.exe', '')                       | Set-Content ${qconfig-pri-folder}
+  - Pop-Location
+  - _fold_final_
+
+  - _fold_start_ 'run qmake and generate the msvc nmake makefile'
+  - mkdir _build; cd _build
+  - ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
+  - _fold_final_
+
+  - _fold_start_ 'start the actual build with jom instead of nmake; for speed'
+  - ..\_qt\jom
+  - _fold_final_
+
+  - _fold_start_ 'run windeployqt to automatically copy the needed dll files'
+  - ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
+  - _fold_final_
+
+  - _fold_start_ 'Moving results for upload'
+  - mv release ../'OpenRGB Windows 64-bit'
+  - _fold_final_
+#  cache:
+#    key: same-key
+#    paths:
+#    - C:\vcpkg\installed\
  artifacts:
    name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
    paths:
@@ -448,89 +555,10 @@ before_script:
    - 'OpenRGB Windows 64-bit\*.qm'
    expire_in: 30 days

-  rules:
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
-      when: never
-
-"Windows 64":
-  extends: "Windows 64 Base"
-  rules:
-  - !reference [.upstream_rules, rules]
-
-"Windows 64 (Downstream)":
-  extends: "Windows 64 Base"
-  before_script:
-    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
-    - cd OpenRGB-Qt-Packages
-    - .\install-chocolatey.bat
-    - cd ..
-  rules:
-  - !reference [.downstream_rules, rules]
-  tags:
-  - "saas-windows-medium-amd64"
-
-#-----------------------------------------------------------#
-# Windows (64-bit) Qt6 Build Target                         #
-#-----------------------------------------------------------#
-"Windows 64 Qt6 Base":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - $ErrorActionPreference = "SilentlyContinue" ; Set-MpPreference -DisableRealtimeMonitoring $true ; $ErrorActionPreference = "Stop"
-  - scripts\build-windows.bat 6.8.3 2022 64
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_64_Qt6_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - 'OpenRGB Windows 64-bit'
-    exclude:
-    - 'OpenRGB Windows 64-bit\*.qm'
-    expire_in: 30 days
-
-  rules:
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event" || $CI_PIPELINE_SOURCE == "push"
-      when: never
-
-"Windows 64 Qt6":
-  extends: "Windows 64 Qt6 Base"
-  rules:
-  - !reference [.upstream_rules, rules]
-
-"Windows 64 Qt6 (Downstream)":
-  extends: "Windows 64 Qt6 Base"
-  before_script:
-    - git clone https://gitlab.com/OpenRGBDevelopers/OpenRGB-Qt-Packages
-    - cd OpenRGB-Qt-Packages
-    - .\install-chocolatey.bat
-    - cd ..
-  rules:
-  - !reference [.downstream_rules, rules]
-  tags:
-  - "saas-windows-medium-amd64"
-
-#-----------------------------------------------------------#
-# MacOS Build Target                                        #
-#-----------------------------------------------------------#
+#-----------------------------------------------------------------------#
+# MacOS Build Target                                                    #
+#-----------------------------------------------------------------------#
 "MacOS ARM64":
-  tags:
-  - macos
-  stage: build
-  script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - /opt/homebrew/opt/qt@5/bin/qmake OpenRGB.pro
-  - make -j16
-  - /opt/homebrew/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB.app
-    expire_in: 30 days
-
-  rules:
-  - !reference [.upstream_rules, rules]
-
-"MacOS ARM64 Qt6":
  tags:
  - macos
  stage: build
@@ -541,13 +569,19 @@ before_script:
  - macdeployqt OpenRGB.app -codesign=OpenRGB

  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_Qt6_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
    paths:
    - OpenRGB.app
    expire_in: 30 days

  rules:
-  - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: '$BUILD_MACOS =~ /.+/'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true

 "MacOS Intel":
  tags:
@@ -555,9 +589,9 @@ before_script:
  stage: build
  script:
  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/opt/qt@5/bin/qmake OpenRGB.pro
+  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/opt/qt@5/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
+  - arch -x86_64 macdeployqt OpenRGB.app -codesign=OpenRGB

  artifacts:
    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
@@ -566,50 +600,10 @@ before_script:
    expire_in: 30 days

  rules:
-  - !reference [.upstream_rules, rules]
-
-"MacOS Intel Qt6":
-  tags:
-  - macos
-  stage: build
-  script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 /usr/local/bin/macdeployqt OpenRGB.app -codesign=OpenRGB
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_Qt6_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB.app
-    expire_in: 30 days
-
-  rules:
-  - !reference [.upstream_rules, rules]
-
-#-----------------------------------------------------------#
-# Windows (64-bit) MSI Target                               #
-#-----------------------------------------------------------#
-"Windows 64 MSI":
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-i386
-  stage: deploy
-  tags:
-  - linux
-  - i386
-  script:
-  -  ls -la
-  -  ls -la "OpenRGB Windows 64-bit/"
-  -  ./scripts/build-msi.sh
-  dependencies:
-  - "Windows 64"
-  needs:
-  - "Windows 64"
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Windows_64_msi_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB_Windows_64.msi
-    expire_in: 30 days
-
-  rules:
-    - !reference [.upstream_rules, rules]
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: '$BUILD_MACOS =~ /.+/'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
@@ -23,9 +23,9 @@ Please add a link to the manufacturer's product page beneath this line
 ~"DeviceType::IDK" <!-- I Don't know -->
 ~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
 ~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
-~"DeviceType::GPU::NVidia" <!-- The device is a Nvidia GPU -->
+~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
 ~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
-~"DeviceType::WMI"  <!-- The device is controlled through Windows Management Instrumentation -->
+~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->

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

@@ -4,7 +4,7 @@
 |   Autostart implementation for FreeBSD                    |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <fstream>
@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,38 +63,39 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
        else
        {
+            //autostart_file_stream << desktop_file;
            autostart_file_stream.close();
            success = !autostart_file_stream.fail();

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

    return(success);
@@ -102,9 +103,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -117,9 +118,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
    char exepath[ PATH_MAX ];

    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
@@ -133,16 +134,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-----------------------------------------------------*\
-    | Get home and config paths                             |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    const char *home = getenv("HOME");

-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
    if(xdg_config_home != NULL)
    {
        autostart_dir = xdg_config_home;
@@ -154,9 +155,9 @@ void AutoStart::InitAutoStart(std::string name)
        autostart_dir = autostart_dir + "/.config/autostart/";
    }

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -4,7 +4,7 @@
 |   Autostart implementation for FreeBSD                    |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,7 +4,7 @@
 |   Autostart implementation for Linux                      |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <fstream>
@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,25 +63,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        std::string     desktop_file                = GenerateDesktopFile(autostart_info);
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
        else
        {
            autostart_file_stream << desktop_file;
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

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

    return(success);
@@ -104,9 +104,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -119,9 +119,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
    char exepath[ PATH_MAX ];

    ssize_t count = readlink("/proc/self/exe", exepath, PATH_MAX);
@@ -129,17 +129,17 @@ std::string AutoStart::GetExePath()
    return(std::string(exepath, (count > 0) ? count : 0));
 }

-/*---------------------------------------------------------*\
-| Linux AutoStart Implementation                            |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/

 std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
 {
-    /*-----------------------------------------------------*\
-    | Generate a .desktop file from the AutoStart           |
-    | parameters                                            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Generate a .desktop file from the AutoStart       |
+    | parameters                                        |
+    \*-------------------------------------------------*/
    std::stringstream fileContents;

    fileContents << "[Desktop Entry]"                               << std::endl;
@@ -151,9 +151,9 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
    fileContents << "Terminal=false"                                << std::endl;
    fileContents << "Type=Application"                              << std::endl;

-    /*-----------------------------------------------------*\
-    | Add the executable path and arguments                 |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Add the executable path and arguments             |
+    \*-------------------------------------------------*/
    fileContents << "Exec="              << autostart_info.path;

    if (autostart_info.args != "")
@@ -172,16 +172,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-----------------------------------------------------*\
-    | Get home and config paths                             |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get home and config paths                         |
+    \*-------------------------------------------------*/
    const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    const char *home = getenv("HOME");

-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
    if(xdg_config_home != NULL)
    {
        autostart_dir = xdg_config_home;
@@ -193,9 +193,9 @@ void AutoStart::InitAutoStart(std::string name)
        autostart_dir = autostart_dir + "/.config/autostart/";
    }

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -4,7 +4,7 @@
 |   Autostart implementation for Linux                      |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,7 +4,7 @@
 |   Autostart implementation for MacOS                      |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <fstream>
@@ -26,21 +26,21 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool            success                         = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
@@ -53,7 +53,7 @@ bool AutoStart::DisableAutoStart()
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return(success);
@@ -63,25 +63,25 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool        success                             = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        std::string     desktop_file                = GenerateLaunchAgentFile(autostart_info);
        std::ofstream   autostart_file_stream(autostart_file, std::ios::out | std::ios::trunc);

-        /*-------------------------------------------------*\
-        | Error out if the file could not be opened         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Error out if the file could not be opened     |
+        \*---------------------------------------------*/
        if(!autostart_file_stream)
        {
-            LOG_ERROR("[AutoStart] Could not open %s for writing.", autostart_file.c_str());
+            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
            success = false;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, write the file                         |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, write the file                     |
+        \*---------------------------------------------*/
        else
        {
            autostart_file_stream << desktop_file;
@@ -90,13 +90,13 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

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

    return(success);
@@ -104,9 +104,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -119,9 +119,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
    char     exepath[ PATH_MAX ];
    uint32_t exesize = PATH_MAX;

@@ -132,17 +132,17 @@ std::string AutoStart::GetExePath()
    return("");
 }

-/*---------------------------------------------------------*\
-| MacOS AutoStart Implementation                            |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Private Methods                                       |
+\*-----------------------------------------------------*/

 std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
 {
-    /*-----------------------------------------------------*\
-    | Generate a .plist file from the AutoStart             |
-    | parameters                                            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Generate a .plist file from the AutoStart         |
+    | parameters                                        |
+    \*-------------------------------------------------*/
    std::stringstream fileContents;

    fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
@@ -180,16 +180,16 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-----------------------------------------------------*\
-    | Determine where the autostart .desktop files are      |
-    | kept                                                  |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Determine where the autostart .desktop files are  |
+    | kept                                              |
+    \*-------------------------------------------------*/
    autostart_dir = getenv("HOME");
    autostart_dir = autostart_dir + "/Library/LaunchAgents/";

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_dir != "")
    {
        std::error_code ec;
@@ -4,7 +4,7 @@
 |   Autostart implementation for MacOS                      |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,7 +4,7 @@
 |   Autostart implementation for Windows                    |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <fstream>
@@ -25,34 +25,34 @@ bool AutoStart::DisableAutoStart()
    std::error_code autostart_file_remove_errcode;
    bool success                                    = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
-        /*-------------------------------------------------*\
-        | If file doesn't exist, disable is successful      |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If file doesn't exist, disable is successful  |
+        \*---------------------------------------------*/
        if(!filesystem::exists(autostart_file))
        {
            success = true;
        }
-        /*-------------------------------------------------*\
-        | Otherwise, delete the file                        |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Otherwise, delete the file                    |
+        \*---------------------------------------------*/
        else
        {
            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);

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

    return(success);
@@ -62,9 +62,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
 {
    bool success                                    = false;

-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        bool            weInitialised               = false;
@@ -79,9 +79,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);

-        /*-------------------------------------------------*\
-        | If not initialized, initialize                    |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If not initialized, initialize                |
+        \*---------------------------------------------*/
        if(result == CO_E_NOTINITIALIZED)
        {
            weInitialised                           = true;
@@ -89,10 +89,10 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
            result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
        }

-        /*-------------------------------------------------*\
-        | If successfully initialized, save a shortcut      |
-        | from the AutoStart parameters                     |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | If successfully initialized, save a shortcut  |
+        | from the AutoStart parameters                 |
+        \*---------------------------------------------*/
        if(SUCCEEDED(result))
        {
            shellLink->SetPath(exepathw.c_str());
@@ -114,9 +114,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
            shellLink->Release();
        }

-        /*-------------------------------------------------*\
-        | Uninitialize when done                            |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Uninitialize when done                        |
+        \*---------------------------------------------*/
        if(weInitialised)
        {
            CoUninitialize();
@@ -124,7 +124,7 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
    }
    else
    {
-        LOG_ERROR("[AutoStart] Could not establish correct autostart file path.");
+        LOG_ERROR("Could not establish correct autostart file path.");
    }

    return success;
@@ -132,9 +132,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)

 bool AutoStart::IsAutoStartEnabled()
 {
-    /*-----------------------------------------------------*\
-    | Check if the filename is valid                        |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Check if the filename is valid                    |
+    \*-------------------------------------------------*/
    if(autostart_file != "")
    {
        return(filesystem::exists(autostart_file));
@@ -147,9 +147,9 @@ bool AutoStart::IsAutoStartEnabled()

 std::string AutoStart::GetExePath()
 {
-    /*-----------------------------------------------------*\
-    | Create the OpenRGB executable path                    |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Create the OpenRGB executable path                |
+    \*-------------------------------------------------*/
    char exepath[MAX_PATH] = "";

    DWORD count = GetModuleFileNameA(NULL, exepath, MAX_PATH);
@@ -157,10 +157,10 @@ std::string AutoStart::GetExePath()
    return(std::string(exepath, (count > 0) ? count : 0));
 }

-/*---------------------------------------------------------*\
-| Windows AutoStart Implementation                          |
-| Private Methods                                           |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Private Methods                                       |
+\*-----------------------------------------------------*/

 void AutoStart::InitAutoStart(std::string name)
 {
@@ -168,9 +168,9 @@ void AutoStart::InitAutoStart(std::string name)

    autostart_name = name;

-    /*-----------------------------------------------------*\
-    | Get startup applications path                         |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Get startup applications path                     |
+    \*-------------------------------------------------*/
    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);

    if(SUCCEEDED(result))
@@ -185,10 +185,10 @@ void AutoStart::InitAutoStart(std::string name)
    }
 }

-/*---------------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String           |
-| (from wmi.cpp)                                            |
-\*---------------------------------------------------------*/
+/*-----------------------------------------------------*\
+| Convert an UTF8 string to a wide Unicode String       |
+| (from wmi.cpp)                                        |
+\*-----------------------------------------------------*/
 std::wstring AutoStart::utf8_decode(const std::string& str)
 {
    if(str.empty())
@@ -4,7 +4,7 @@
 |   Autostart implementation for Windows                    |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,7 +4,7 @@
 |   Autostart common implementation                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "AutoStart.h"
@@ -4,7 +4,7 @@
 |   Autostart common implementation                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -8,14 +8,18 @@ To create a merge request, log into GitLab and fork the OpenRGB project.  Push y

 * Please keep the scope of each merge request limited to one functional area.  If you wish to add a new device controller, for instance, don't also do code cleanup in another controller as part of the same merge request.
 * Explain what your merge request is changing, why you feel the change is necessary, and add any additional information you feel is needed to best understand your change in the merge request description.
-* Mark your merge request as a Draft (start title with "Draft:") until it has been fully developed and ideally tested and verified working.  Remove Draft status when you are ready for the code to be reviewed and merged.  I typically do not look at or review Draft merge requests.
+* Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
 * Follow the Style Guidelines below when making your code changes.
-* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.  I also recommend squashing your commits, though GitLab will do this as part of the merge process if you don't.
+* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
 * Do not submit a merge request using your fork's `master` branch as the source.  The `master` branch is protected by default when creating a fork and I cannot manually rebase a protected branch before merging.  If you submit a merge request with a protected `master` branch as the source, it may not get merged until you unprotect it.

-### Pipelines, Shared Runners, Quotas, and Accepting Merge Requests
+### Pipelines, Shared Runners and Quotas

-Since mid 2022, GitLab has severely limited the usage of shared runners to all free users.  With that in mind, most pipeline jobs are skipped on forked copies of the project.  Only the Windows 64bit and Linux AppImage amd64 jobs are run on forks, and only if you have permission and available CI minutes on your account.  Unfortunately, with the ever tightening restrictions GitLab has on free CI usage, even to public projects with an open source license, you likely will not be able to utilize the CI builds for your own fork unless you set up your own runners.  Because of this, I no longer require a successful CI run in order to accept a merge request as it is an unreasonable ask given the current CI situation.  If your merge request requires additional verification, I may choose to merge it into a branch instead of into `master` so that my own runners can run the full set of jobs and then I will pull it into master after any verification or changes.  This also means that any build breakages inadvertently caused by merging a merge request may result in the merge being backed out, in which case I will either fix it myself or leave a message on the merge request to rework and resubmit a fixed version.
+Since mid 2022 Gitlab has limited the usage of shared runners to all projects and whilst quite geneorous quotas are allowed
+ for open source projects it is possible to exhaust them. With that in mind not all jobs within the pipeline build are
+ triggered to automatically run with every push to your branch with the exception of the Windows 64bit and Linux Appimage 64bit
+ jobs. If you need to test or share another build you can still start it manually from your pipeline queue.
+ Once a merge request is created all architectures and platforms will be compiled to ensure that they are ready to merge.

 Please refer to the following link for [further information relating to minutes and quotas](https://docs.gitlab.com/ee/ci/pipelines/cicd_minutes.html).

@@ -54,18 +58,12 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 * Capitalize hexadecimal literals (`0xFF` not `0xff`) except in the udev rules file (which must be lowercase to work)
 * No space between keyword and open parenthesis (`if(TRUE)` not `if (TRUE)`).  There are some instances of this that haven't been cleaned up in the code.
 * Generally, `snake_case` is used for variable names and `CamelCase` is used for function and class names
-* Add a header comment to new files with the filename, description, original author, date, and SPDX license identifier.  You can copy one from an existing file to preserve formatting.
-* Line up `=` on a tab stop when doing a lot of assignments together
+* Add a header comment to new files with the filename, description, original author, and date (this is missing on most Detect files)
+* Line up `=` when doing a lot of assignments together
 * Use this comment box style when adding comments:
-    * Try to start the comment box on the same column as the code directly beneath it and end on column 61 if possible.  See the example below:

 ```
-/*---------------------------------------------------------*\
-| This is a comment                                         |
-\*---------------------------------------------------------*/
+/*--------------------------------*\
+| This is a comment                |
+\*_-------------------------------*/
 ```
-
-## Translating
-
-Translation files are located in [`OpenRGB/qt/i18n/`](https://gitlab.com/CalcProgrammer1/OpenRGB/-/tree/master/qt/i18n), where languages are formatted using ISO 639-1 format: `OpenRGB_xx_XX.ts` — `xx_XX` representing the language code.
-In order to translate a file, you need to [fork](https://gitlab.com/CalcProgrammer1/OpenRGB/-/forks/new) the project, create a new file for your language with `lupdate` (or edit an exisiting one), edit the file with `qtlinguist`, commit, push, and create a merge request.
@@ -4,7 +4,7 @@
 |   List of named color constants                           |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #ifndef COLORS_H
@@ -7,7 +7,7 @@
 |   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 /*-----------------------------------------------------*\
@@ -15,6 +15,7 @@
 \*-----------------------------------------------------*/
 #include <hidapi.h>
 #include "Detector.h"
+#include "RGBController.h"

 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
@@ -33,8 +34,9 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id, name);
+        BloodyMouseController* controller           = new BloodyMouseController(dev, info->path, info->product_id);
        RGBController_BloodyMouse* rgb_controller   = new RGBController_BloodyMouse(controller);
+        rgb_controller->name                        = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -46,16 +48,16 @@ void DetectBloodyB820R(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path, name);
+        BloodyB820RController*     controller     = new BloodyB820RController(dev, info->path);
        RGBController_BloodyB820R* rgb_controller = new RGBController_BloodyB820R(controller);
+        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }

-REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
-REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
-REGISTER_HID_DETECTOR_IPU("Bloody W90 Pro",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_PRO_PID,     2,      0xFF33,     0x054D);
-REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",  DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
-REGISTER_HID_DETECTOR_IPU("Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
+REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W60_PRO_PID,     2,      0xFF33,     0x0529);
+REGISTER_HID_DETECTOR_IPU("Bloody W70 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W70_MAX_PID,     2,      0xFF33,     0x0518);
+REGISTER_HID_DETECTOR_IPU("Bloody W90 Max",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_W90_MAX_PID,     2,      0xFF33,     0x053D);
+REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS",         DetectA4TechMouseControllers,       A4_TECH_VID,    BLOODY_MP_50RS_PID,     2,      0xFFF2,     0x6009);
+REGISTER_HID_DETECTOR_IPU("A4Tech Bloody B820R",    DetectBloodyB820R,                  A4_TECH_VID,    BLOODY_B820R_PID,       2,      0xFF52,     0x0210);
@@ -6,7 +6,7 @@
 |   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "BloodyB820RController.h"
@@ -20,11 +20,10 @@
 | the second packet.                                                                    |
 \*-------------------------------------------------------------------------------------*/

-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name)
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
 {
    dev                 = dev_handle;
    location            = path;
-    name                = dev_name;

    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
 }
@@ -53,11 +52,6 @@ std::string BloodyB820RController::GetLocation()
    return("HID: " + location);
 }

-std::string BloodyB820RController::GetName()
-{
-    return(name);
-}
-
 void  BloodyB820RController::SendControlPacket(uint8_t data)
 {
    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]    = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
@@ -6,7 +6,7 @@
 |   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -39,17 +39,15 @@ enum
 class BloodyB820RController
 {
 public:
-    BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name);
+    BloodyB820RController(hid_device* dev_handle, const char* path);
    ~BloodyB820RController();

    std::string     GetSerial();
    std::string     GetLocation();
-    std::string     GetName();

    void            SetLEDDirect(std::vector<RGBColor> colors);
    void            SendControlPacket(uint8_t data);
 private:
    std::string     location;
-    std::string     name;
    hid_device*     dev;
 };
@@ -6,7 +6,7 @@
 |   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBControllerKeyNames.h"
@@ -154,7 +154,7 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 {
    controller                  = controller_ptr;

-    name                        = controller->GetName();
+    name                        = "Bloody B820R";
    vendor                      = "A4Tech";
    type                        = DEVICE_TYPE_KEYBOARD;
    description                 = "A4Tech Bloody Keyboard";
@@ -6,7 +6,7 @@
 |   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,18 +6,17 @@
 |   Chris M (Dr_No)                             30 Jun 2022 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "BloodyMouseController.h"
 #include "StringUtils.h"

-BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name)
+BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
 {
    dev                 = dev_handle;
    location            = path;
    pid                 = product_id;
-    name                = dev_name;

    InitDevice();
 }
@@ -50,11 +49,6 @@ std::string BloodyMouseController::GetLocation()
    return("HID: " + location);
 }

-std::string BloodyMouseController::GetName()
-{
-    return(name);
-}
-
 void BloodyMouseController::InitDevice()
 {
    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
@@ -6,7 +6,7 @@
 |   Chris M (Dr_No)                             30 Jun 2022 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -21,7 +21,6 @@
 #define BLOODY_W60_PRO_PID                          0x37EA
 #define BLOODY_W70_MAX_PID                          0x79EF
 #define BLOODY_W90_MAX_PID                          0x3666
-#define BLOODY_W90_PRO_PID                          0x39B6

 /*-----------------------------------------------------*\
 | Mousemat product IDs                                  |
@@ -50,20 +49,18 @@ enum
 class BloodyMouseController
 {
 public:
-    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name);
+    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
    ~BloodyMouseController();

    uint16_t        GetPid();
    std::string     GetSerial();
    std::string     GetLocation();
-    std::string     GetName();

    void            SetLedsDirect(std::vector<RGBColor> colors);

 private:
    uint16_t        pid;
    std::string     location;
-    std::string     name;
    hid_device*     dev;

    void            InitDevice();
@@ -6,7 +6,7 @@
 |   Chris M (Dr_No)                             30 Jun 2022 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_BloodyMouse.h"
@@ -71,7 +71,6 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
            type                = DEVICE_TYPE_MOUSE;
    }

-    name                        = controller->GetName();
    vendor                      = "Bloody";
    description                 = "Controller compatible with the Bloody W60 Pro and MP 50RS";
    serial                      = controller->GetSerial();
@@ -112,7 +111,6 @@ void RGBController_BloodyMouse::SetupZones()
            break;
        case BLOODY_W70_MAX_PID:
        case BLOODY_W90_MAX_PID:
-        case BLOODY_W90_PRO_PID:
            layout = w90_max;
            break;
        case BLOODY_MP_50RS_PID:
@@ -6,7 +6,7 @@
 |   Chris M (Dr_No)                             30 Jun 2022 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -1,195 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXController.cpp                                        |
-|                                                           |
-|   Driver for Philips amBX Gaming lights                   |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "AMBXController.h"
-#include "LogManager.h"
-#include "StringUtils.h"
-#include <cstring>
-#include <thread>
-#include <chrono>
-
-AMBXController::AMBXController(const char* path)
-{
-    initialized      = false;
-    usb_context      = nullptr;
-    dev_handle       = nullptr;
-
-    location = "USB: ";
-    location += path;
-
-    // Initialize libusb in this instance
-    if(libusb_init(&usb_context) < 0)
-    {
-        return;
-    }
-
-    // Get the device list
-    libusb_device** device_list;
-    ssize_t device_count = libusb_get_device_list(usb_context, &device_list);
-
-    if(device_count < 0)
-    {
-        return;
-    }
-
-    for(ssize_t i = 0; i < device_count; i++)
-    {
-        libusb_device* device = device_list[i];
-        struct libusb_device_descriptor desc;
-
-        if(libusb_get_device_descriptor(device, &desc) != LIBUSB_SUCCESS)
-        {
-            continue;
-        }
-
-        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
-        {
-            uint8_t bus = libusb_get_bus_number(device);
-            uint8_t address = libusb_get_device_address(device);
-
-            char current_path[32];
-            snprintf(current_path, sizeof(current_path), "%d-%d", bus, address);
-
-            if(strcmp(path, current_path) == 0)
-            {
-                // Try to open this device
-                if(libusb_open(device, &dev_handle) != LIBUSB_SUCCESS)
-                {
-                    continue;
-                }
-
-                // Try to detach the kernel driver if attached
-                if(libusb_kernel_driver_active(dev_handle, 0))
-                {
-                    libusb_detach_kernel_driver(dev_handle, 0);
-                }
-
-                // Set auto-detach for Windows compatibility
-                libusb_set_auto_detach_kernel_driver(dev_handle, 1);
-
-                // Claim the interface
-                if(libusb_claim_interface(dev_handle, 0) != LIBUSB_SUCCESS)
-                {
-                    libusb_close(dev_handle);
-                    dev_handle = nullptr;
-                    continue;
-                }
-
-                // Get string descriptor for serial number if available
-                if(desc.iSerialNumber != 0)
-                {
-                    unsigned char serial_str[256];
-                    int serial_result = libusb_get_string_descriptor_ascii(dev_handle, desc.iSerialNumber,
-                                                                         serial_str, sizeof(serial_str));
-                    if(serial_result > 0)
-                    {
-                        serial = std::string(reinterpret_cast<char*>(serial_str), serial_result);
-                    }
-                }
-
-                // Successfully opened and claimed the device
-                initialized = true;
-                break;
-            }
-        }
-    }
-
-    libusb_free_device_list(device_list, 1);
-}
-
-AMBXController::~AMBXController()
-{
-    if(initialized)
-    {
-        // Turn off all lights before closing
-        unsigned int led_ids[5] =
-        {
-            AMBX_LIGHT_LEFT,
-            AMBX_LIGHT_RIGHT,
-            AMBX_LIGHT_WALL_LEFT,
-            AMBX_LIGHT_WALL_CENTER,
-            AMBX_LIGHT_WALL_RIGHT
-        };
-
-        RGBColor colors[5] = { 0, 0, 0, 0, 0 };
-        SetLEDColors(led_ids, colors, 5);
-    }
-
-    if(dev_handle != nullptr)
-    {
-        // Release the interface
-        libusb_release_interface(dev_handle, 0);
-
-        // Close the device
-        libusb_close(dev_handle);
-        dev_handle = nullptr;
-    }
-
-    if(usb_context != nullptr)
-    {
-        libusb_exit(usb_context);
-        usb_context = nullptr;
-    }
-}
-
-std::string AMBXController::GetDeviceLocation()
-{
-    return location;
-}
-
-std::string AMBXController::GetSerialString()
-{
-    return serial;
-}
-
-bool AMBXController::IsInitialized()
-{
-    return initialized;
-}
-
-void AMBXController::SendPacket(unsigned char* packet, unsigned int size)
-{
-    if(!initialized || dev_handle == nullptr)
-    {
-        return;
-    }
-
-    int actual_length = 0;
-    libusb_interrupt_transfer(dev_handle, AMBX_ENDPOINT_OUT, packet, size, &actual_length, 100);
-}
-
-void AMBXController::SetLEDColor(unsigned int led, RGBColor color)
-{
-    if(!initialized)
-    {
-        return;
-    }
-
-    unsigned char color_buf[6] =
-    {
-        AMBX_PACKET_HEADER,
-        static_cast<unsigned char>(led),
-        AMBX_SET_COLOR,
-        (unsigned char)RGBGetRValue(color),
-        (unsigned char)RGBGetGValue(color),
-        (unsigned char)RGBGetBValue(color)
-    };
-
-    SendPacket(color_buf, 6);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AMBXController::SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count)
-{
-    for(unsigned int i = 0; i < count; i++)
-    {
-        SetLEDColor(leds[i], colors[i]);
-    }
-}
@@ -1,57 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXController.h                                          |
-|                                                           |
-|   Driver for Philips amBX Gaming lights                   |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include <string>
-
-#ifdef _WIN32
-#include "dependencies/libusb-1.0.27/include/libusb.h"
-#else
-#include <libusb.h>
-#endif
-
-#define AMBX_VID                            0x0471
-#define AMBX_PID                            0x083F
-#define AMBX_ENDPOINT_OUT                   0x02
-#define AMBX_PACKET_HEADER                  0xA1
-#define AMBX_SET_COLOR                      0x03
-
-enum
-{
-    AMBX_LIGHT_LEFT         = 0x0B,
-    AMBX_LIGHT_RIGHT        = 0x1B,
-    AMBX_LIGHT_WALL_LEFT    = 0x2B,
-    AMBX_LIGHT_WALL_CENTER  = 0x3B,
-    AMBX_LIGHT_WALL_RIGHT   = 0x4B
-};
-
-class AMBXController
-{
-public:
-    AMBXController(const char* path);
-    ~AMBXController();
-
-    std::string     GetDeviceLocation();
-    std::string     GetSerialString();
-
-    bool            IsInitialized();
-    void            SetLEDColor(unsigned int led, RGBColor color);
-    void            SetLEDColors(unsigned int* leds, RGBColor* colors, unsigned int count);
-
-private:
-    libusb_context*          usb_context;
-    libusb_device_handle*    dev_handle;
-    std::string              location;
-    std::string              serial;
-    bool                     initialized;
-
-    void                    SendPacket(unsigned char* packet, unsigned int size);
-};
@@ -1,83 +0,0 @@
-/*---------------------------------------------------------*\
-| AMBXControllerDetect.cpp                                  |
-|                                                           |
-|   Detector for Philips amBX Gaming lights                 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "Detector.h"
-#include "AMBXController.h"
-#include "RGBController.h"
-#include "RGBController_AMBX.h"
-
-#ifdef _WIN32
-#include "dependencies/libusb-1.0.27/include/libusb.h"
-#else
-#include <libusb.h>
-#endif
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAMBXControllers                                                                  *
-*                                                                                          *
-*       Detect Philips amBX Gaming devices                                                 *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAMBXControllers()
-{
-    libusb_context* ctx = NULL;
-
-    if(libusb_init(&ctx) < 0)
-    {
-        return;
-    }
-
-    libusb_device** devs;
-    ssize_t num_devs = libusb_get_device_list(ctx, &devs);
-
-    if(num_devs <= 0)
-    {
-        libusb_exit(ctx);
-        return;
-    }
-
-    for(ssize_t i = 0; i < num_devs; i++)
-    {
-        libusb_device* dev = devs[i];
-        libusb_device_descriptor desc;
-
-        if(libusb_get_device_descriptor(dev, &desc) != 0)
-        {
-            continue;
-        }
-
-        if(desc.idVendor == AMBX_VID && desc.idProduct == AMBX_PID)
-        {
-            uint8_t bus = libusb_get_bus_number(dev);
-            uint8_t address = libusb_get_device_address(dev);
-            char device_path[32];
-            snprintf(device_path, sizeof(device_path), "%d-%d", bus, address);
-
-            // Use the AMBXController to handle opening and initializing
-            AMBXController* controller = new AMBXController(device_path);
-
-            if(controller->IsInitialized())
-            {
-                RGBController_AMBX* rgb_controller = new RGBController_AMBX(controller);
-                ResourceManager::get()->RegisterRGBController(rgb_controller);
-            }
-            else
-            {
-                delete controller;
-            }
-        }
-    }
-
-    libusb_free_device_list(devs, 1);
-    libusb_exit(ctx);
-}
-
-REGISTER_DETECTOR("Philips amBX", DetectAMBXControllers);
@@ -1,179 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AMBX.cpp                                    |
-|                                                           |
-|   RGB Controller for Philips amBX Gaming lights           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_AMBX.h"
-
-/**------------------------------------------------------------------*\
-    @name Philips amBX
-    @category Accessory
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAMBXControllers
-    @comment The Philips amBX Gaming lights system includes left and right
-    lights and a wall-washer bar with three zones.
-\*-------------------------------------------------------------------*/
-
-RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
-{
-    controller = controller_ptr;
-
-    name        = "Philips amBX";
-    vendor      = "Philips";
-    type        = DEVICE_TYPE_ACCESSORY;
-    description = "Philips amBX Gaming Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = 0;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_AMBX::~RGBController_AMBX()
-{
-    delete controller;
-}
-
-void RGBController_AMBX::SetupZones()
-{
-    // Set up zones
-    zone side_lights_zone;
-    side_lights_zone.name       = "Side Lights";
-    side_lights_zone.type       = ZONE_TYPE_LINEAR;
-    side_lights_zone.leds_min   = 2;
-    side_lights_zone.leds_max   = 2;
-    side_lights_zone.leds_count = 2;
-    side_lights_zone.matrix_map = NULL;
-    zones.push_back(side_lights_zone);
-
-    zone wallwasher_zone;
-    wallwasher_zone.name       = "Wallwasher";
-    wallwasher_zone.type       = ZONE_TYPE_LINEAR;
-    wallwasher_zone.leds_min   = 3;
-    wallwasher_zone.leds_max   = 3;
-    wallwasher_zone.leds_count = 3;
-    wallwasher_zone.matrix_map = NULL;
-    zones.push_back(wallwasher_zone);
-
-    // Set up LEDs
-    led left_light;
-    left_light.name  = "Left";
-    left_light.value = AMBX_LIGHT_LEFT;
-    leds.push_back(left_light);
-
-    led right_light;
-    right_light.name  = "Right";
-    right_light.value = AMBX_LIGHT_RIGHT;
-    leds.push_back(right_light);
-
-    led wall_left;
-    wall_left.name  = "Wall Left";
-    wall_left.value = AMBX_LIGHT_WALL_LEFT;
-    leds.push_back(wall_left);
-
-    led wall_center;
-    wall_center.name  = "Wall Center";
-    wall_center.value = AMBX_LIGHT_WALL_CENTER;
-    leds.push_back(wall_center);
-
-    led wall_right;
-    wall_right.name  = "Wall Right";
-    wall_right.value = AMBX_LIGHT_WALL_RIGHT;
-    leds.push_back(wall_right);
-
-    SetupColors();
-}
-
-void RGBController_AMBX::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    // This device does not support resizing zones
-}
-
-void RGBController_AMBX::DeviceUpdateLEDs()
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    unsigned int led_values[5];
-    RGBColor led_colors[5];
-
-    for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        led_values[led_idx] = leds[led_idx].value;
-        led_colors[led_idx] = colors[led_idx];
-    }
-
-    controller->SetLEDColors(led_values, led_colors, static_cast<unsigned int>(leds.size()));
-}
-
-void RGBController_AMBX::UpdateZoneLEDs(int zone)
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    unsigned int start_idx = 0;
-    unsigned int zone_size = 0;
-
-    // Calculate start index and size
-    for(unsigned int z_idx = 0; z_idx < zones.size(); z_idx++)
-    {
-        if(z_idx == (unsigned int)zone)
-        {
-            zone_size = zones[z_idx].leds_count;
-            break;
-        }
-
-        start_idx += zones[z_idx].leds_count;
-    }
-
-    unsigned int led_values[5];
-    RGBColor led_colors[5];
-
-    for(unsigned int led_idx = 0; led_idx < zone_size; led_idx++)
-    {
-        unsigned int current_idx = start_idx + led_idx;
-        led_values[led_idx] = leds[current_idx].value;
-        led_colors[led_idx] = colors[current_idx];
-    }
-
-    controller->SetLEDColors(led_values, led_colors, zone_size);
-}
-
-void RGBController_AMBX::UpdateSingleLED(int led)
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    unsigned int led_value = leds[led].value;
-    RGBColor color = colors[led];
-    controller->SetLEDColor(led_value, color);
-}
-
-void RGBController_AMBX::DeviceUpdateMode()
-{
-    if(!controller->IsInitialized())
-    {
-        return;
-    }
-
-    DeviceUpdateLEDs();
-}
@@ -1,32 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AMBX.h                                      |
-|                                                           |
-|   RGB Controller for Philips amBX Gaming lights           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AMBXController.h"
-
-class RGBController_AMBX : public RGBController
-{
-public:
-    RGBController_AMBX(AMBXController* controller_ptr);
-    ~RGBController_AMBX();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AMBXController* controller;
-};
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,12 +6,13 @@
 |   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*---------------------------------------------------------*\
@@ -35,12 +36,11 @@
 void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
+    if( dev )
    {
        AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-
+        // Constructor sets the name
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_AMDWraithPrism.h"
@@ -137,17 +137,17 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()

 void RGBController_AMDWraithPrism::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | LED maps                                              |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | LED maps                                                  |
+    \*---------------------------------------------------------*/
    const unsigned int logo_leds[1]  =  { 0x00 };
    const unsigned int fan_leds[1]   =  { 0x01 };
-    const unsigned int ring_leds[15] =  { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10,
-                                          0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
+    const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
+                                          0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };

-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
    zone logo_zone;
    logo_zone.name          = "Logo";
    logo_zone.type          = ZONE_TYPE_SINGLE;
@@ -169,15 +169,15 @@ void RGBController_AMDWraithPrism::SetupZones()
    zone ring_zone;
    ring_zone.name          = "Ring";
    ring_zone.type          = ZONE_TYPE_LINEAR;
-    ring_zone.leds_min      = 15;
-    ring_zone.leds_max      = 15;
-    ring_zone.leds_count    = 15;
+    ring_zone.leds_min      = 14;
+    ring_zone.leds_max      = 14;
+    ring_zone.leds_count    = 14;
    ring_zone.matrix_map    = NULL;
    zones.push_back(ring_zone);

-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
    for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
    {
        led logo_led;
@@ -194,7 +194,7 @@ void RGBController_AMDWraithPrism::SetupZones()
        leds.push_back(fan_led);
    }

-    for(unsigned int led_idx = 0; led_idx < 15; led_idx++)
+    for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
    {
        led ring_led;
        ring_led.name       = "Ring LED";
@@ -207,44 +207,37 @@ void RGBController_AMDWraithPrism::SetupZones()

 void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
 {
-    /*-----------------------------------------------------*\
-    | This device does not support resizing zones           |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
 }

 void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
 {
    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
    {
-        unsigned char   led_ids[17];
-        RGBColor        color_buf[17];
-        unsigned int    leds_count;
+        unsigned char   led_ids[15];
+        RGBColor        color_buf[15];
+        unsigned int    leds_count = 0;

-        /*-------------------------------------------------*\
-        | Send logo and fan LEDs in the first packet        |
-        \*-------------------------------------------------*/
-        leds_count = 0;
-        for(std::size_t led_idx = 0; led_idx < 2; led_idx++)
+        for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
        {
            led_ids[leds_count]     = (unsigned char)leds[led_idx].value;
            color_buf[leds_count]   = colors[led_idx];

            leds_count++;
-        }
-        controller->SendDirectPacket(leds_count, led_ids, color_buf);

-        /*-------------------------------------------------*\
-        | Send all ring LEDs in the second packet           |
-        \*-------------------------------------------------*/
-        leds_count = 0;
-        for(std::size_t led_idx = 0; led_idx < ( colors.size() - 2 ); led_idx++)
+            if(leds_count >= 15)
+            {
+                controller->SendDirectPacket(15, led_ids, color_buf);
+                leds_count = 0;
+            }
+        }
+
+        if(leds_count > 0)
        {
-            led_ids[leds_count]     = (unsigned char)leds[led_idx + 2].value;
-            color_buf[leds_count]   = colors[led_idx + 2];
-
-            leds_count++;
+            controller->SendDirectPacket(leds_count, led_ids, color_buf);
        }
-        controller->SendDirectPacket(leds_count, led_ids, color_buf);
    }
    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
    {
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                10 May 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <chrono>
@@ -17,11 +17,10 @@

 using namespace std::chrono_literals;

-AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-    name        = dev_name;
 }

 AOCKeyboardController::~AOCKeyboardController()
@@ -34,11 +33,6 @@ std::string AOCKeyboardController::GetDeviceLocation()
    return("HID " + location);
 }

-std::string AOCKeyboardController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCKeyboardController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                10 May 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -64,11 +64,10 @@ enum
 class AOCKeyboardController
 {
 public:
-    AOCKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCKeyboardController(hid_device* dev_handle, const char* path);
    ~AOCKeyboardController();

    std::string GetDeviceLocation();
-    std::string GetDeviceName();
    std::string GetSerialString();

    void SetLightingConfig
@@ -89,7 +88,6 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
-    std::string             name;

    void SendStartPacket();
    void SendEndPacket();
@@ -6,11 +6,12 @@
 |   Adam Honse (CalcProgrammer1)                10 May 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*-----------------------------------------------------*\
@@ -34,8 +35,9 @@ void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path, name);
+        AOCKeyboardController*     controller     = new AOCKeyboardController(dev, info->path);
        RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
+        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                10 May 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_AOCKeyboard.h"
@@ -52,7 +52,7 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 {
    controller                      = controller_ptr;

-    name                            = controller->GetDeviceName();
+    name                            = "AOC Keyboard Device";
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "AOC Keyboard Device";
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                10 May 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,18 +6,17 @@
 |   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

-AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-    name        = dev_name;
 }

 AOCMouseController::~AOCMouseController()
@@ -30,11 +29,6 @@ std::string AOCMouseController::GetDeviceLocation()
    return("HID " + location);
 }

-std::string AOCMouseController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCMouseController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -56,11 +56,10 @@ enum
 class AOCMouseController
 {
 public:
-    AOCMouseController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCMouseController(hid_device* dev_handle, const char* path);
    ~AOCMouseController();

    std::string GetDeviceLocation();
-    std::string GetDeviceName();
    std::string GetSerialString();

    void SendDirect
@@ -80,5 +79,4 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
-    std::string             name;
 };
@@ -6,11 +6,12 @@
 |   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*-----------------------------------------------------*\
@@ -33,8 +34,9 @@ void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)

    if(dev)
    {
-        AOCMouseController*     controller     = new AOCMouseController(dev, info->path, name);
+        AOCMouseController*     controller     = new AOCMouseController(dev, info->path);
        RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
+        rgb_controller->name                   = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_AOCMouse.h"
@@ -26,7 +26,7 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 {
    controller                      = controller_ptr;

-    name                            = controller->GetDeviceName();
+    name                            = "AOC Mouse Device";
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_MOUSE;
    description                     = "AOC Mouse Device";
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,18 +6,17 @@
 |   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

-AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
+AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-    name        = dev_name;
 }

 AOCMousematController::~AOCMousematController()
@@ -30,11 +29,6 @@ std::string AOCMousematController::GetDeviceLocation()
    return("HID " + location);
 }

-std::string AOCMousematController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCMousematController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -55,11 +55,10 @@ enum
 class AOCMousematController
 {
 public:
-    AOCMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AOCMousematController(hid_device* dev_handle, const char* path);
    ~AOCMousematController();

    std::string GetDeviceLocation();
-    std::string GetDeviceName();
    std::string GetSerialString();

    void SendDirect
@@ -79,5 +78,4 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
-    std::string             name;
 };
@@ -6,11 +6,12 @@
 |   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*-----------------------------------------------------*\
@@ -33,8 +34,9 @@ void DetectAOCMousematControllers(hid_device_info* info, const std::string& name

    if(dev)
    {
-        AOCMousematController*     controller     = new AOCMousematController(dev, info->path, name);
+        AOCMousematController*     controller     = new AOCMousematController(dev, info->path);
        RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
+        rgb_controller->name                      = name;

        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_AOCMousemat.h"
@@ -26,7 +26,7 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 {
    controller                      = controller_ptr;

-    name                            = controller->GetDeviceName();
+    name                            = "AOC Mousemat Device";
    vendor                          = "AOC";
    type                            = DEVICE_TYPE_MOUSEMAT;
    description                     = "AOC Mousemat Device";
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,10 +7,11 @@
 |   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
+#include <stdio.h>
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
@@ -324,7 +325,6 @@ void PolychromeUSBController::WriteAllZones
        | Send packet                                           |
        \*-----------------------------------------------------*/
        hid_write(dev, usb_buf, 65);
-        hid_read(dev, usb_buf, 64);

        /*-----------------------------------------------------*\
        | Zero out buffer                                       |
@@ -7,7 +7,7 @@
 |   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,13 +7,19 @@
 |   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -7,7 +7,7 @@
 |   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <string.h>
@@ -7,7 +7,7 @@
 |   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "ASRockASRRGBSMBusController.h"
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_ASRockASRRGBSMBus.h"
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,7 +7,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "LogManager.h"
@@ -7,7 +7,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
@@ -6,7 +6,7 @@
 |   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,7 +7,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBController_ASRockPolychromeV2SMBus.h"
@@ -7,7 +7,7 @@
 |   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,15 +7,18 @@
 |   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

+#include <stdio.h>
+#include <stdlib.h>
 #include <vector>
 #include "Detector.h"
 #include "ASRockASRRGBSMBusController.h"
 #include "ASRockPolychromeV1SMBusController.h"
 #include "ASRockPolychromeV2SMBusController.h"
 #include "LogManager.h"
+#include "RGBController.h"
 #include "RGBController_ASRockASRRGBSMBus.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"
 #include "RGBController_ASRockPolychromeV2SMBus.h"
@@ -6,7 +6,7 @@
 |   Gabriel Marcano (gemarcano)                 21 Apr 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
@@ -99,11 +99,6 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];

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

+    /*-----------------------------------------------------*\
+    | Check if the device reports the wrong number of zones |
+    \*-----------------------------------------------------*/
+    unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
+
    /*-----------------------------------------------------*\
    | Initialize Alienware zones                            |
    \*-----------------------------------------------------*/
@@ -6,7 +6,7 @@
 |   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,11 +4,12 @@
 |   Detector for Dell Alienware RGB USB controller          |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

 /*---------------------------------------------------------*\
@@ -6,7 +6,7 @@
 |   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <thread>
@@ -6,7 +6,7 @@
 |   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -7,18 +7,17 @@
 |   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

-AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name)
+AlienwareAW410KController::AlienwareAW410KController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-    name        = dev_name;

    SendCommit();
 }
@@ -33,11 +32,6 @@ std::string AlienwareAW410KController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string AlienwareAW410KController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AlienwareAW410KController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -7,7 +7,7 @@
 |   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -75,11 +75,10 @@ struct SelectedButtons
 class AlienwareAW410KController
 {
 public:
-    AlienwareAW410KController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AlienwareAW410KController(hid_device* dev_handle, const char* path);
    ~AlienwareAW410KController();

    std::string GetDeviceLocation();
-    std::string GetDeviceName();
    std::string GetSerialString();

    void        SendInitialize();
@@ -141,7 +140,6 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
-    std::string             name;

    void        SendMode
                    (
@@ -7,7 +7,7 @@
 |   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <iterator>
@@ -176,7 +176,7 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 {
    controller                      = controller_ptr;

-    name                            = controller->GetDeviceName();
+    name                            = "Alienware AW410K Keyboard Device";
    vendor                          = "Alienware";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "Alienware AW410K Keyboard Device";
@@ -7,7 +7,7 @@
 |   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,18 +6,17 @@
 |   Mohamad Sallal (msallal)                    22 May 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

-AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name)
+AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
 {
    dev         = dev_handle;
    location    = path;
-    name        = dev_name;

    SendCommit();
 }
@@ -32,11 +31,6 @@ std::string AlienwareAW510KController::GetDeviceLocation()
    return("HID: " + location);
 }

-std::string AlienwareAW510KController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AlienwareAW510KController::GetSerialString()
 {
    wchar_t serial_string[128];
@@ -6,7 +6,7 @@
 |   Mohamad Sallal (msallal)                    22 May 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -77,11 +77,10 @@ struct SelectedKeys
 class AlienwareAW510KController
 {
 public:
-    AlienwareAW510KController(hid_device* dev_handle, const char* path, std::string dev_name);
+    AlienwareAW510KController(hid_device* dev_handle, const char* path);
    ~AlienwareAW510KController();

    std::string GetDeviceLocation();
-    std::string GetDeviceName();
    std::string GetSerialString();

    void        SendInitialize();
@@ -143,7 +142,6 @@ public:
 private:
    hid_device*             dev;
    std::string             location;
-    std::string             name;

    void        SendMode
                    (
@@ -6,7 +6,7 @@
 |   Mohamad Sallal (msallal)                    22 May 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <iterator>
@@ -175,7 +175,7 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 {
    controller                      = controller_ptr;

-    name                            = controller->GetDeviceName();
+    name                            = "Alienware AW510K Keyboard Device";
    vendor                          = "Alienware";
    type                            = DEVICE_TYPE_KEYBOARD;
    description                     = "Alienware AW510K Keyboard Device";
@@ -6,7 +6,7 @@
 |   Mohamad Sallal (msallal)                    22 May 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -4,13 +4,14 @@
 |   Detector for Alienware Keyboard                         |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

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

 #include "AnnePro2Controller.h"
@@ -6,7 +6,7 @@
 |   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,11 +6,12 @@
 |   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

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

@@ -40,12 +41,11 @@
 void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
 {
    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
+    if( dev )
    {
        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
-
+        // Constructor sets the name
        ResourceManager::get()->RegisterRGBController(rgb_controller);
    }
 }
@@ -6,7 +6,7 @@
 |   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include "RGBControllerKeyNames.h"
@@ -6,7 +6,7 @@
 |   Sergey Gavrilov (DrZlo13)                   06 Jun 2021 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
@@ -6,7 +6,7 @@
 |   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #include <cstring>
@@ -76,9 +76,9 @@ void ArcticController::SetChannels(std::vector<RGBColor> colors)
    {
        const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;

-        buffer[offset + 0x00] = (char)std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
-        buffer[offset + 0x01] = (char)std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
-        buffer[offset + 0x02] = (char)std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
+        buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
+        buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
+        buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
    }

    serialport.serial_write(buffer, sizeof(buffer));
@@ -6,7 +6,7 @@
 |   Armin Wolf (Wer-Wolf)                       09 Jan 2023 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
 \*---------------------------------------------------------*/

 #pragma once
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Honse	75e1f42c23	Initialize NZXT Hue 2 fan reporting	2024-10-05 17:54:39 -05:00
Dmitry K	af23c04007	[FAN Controller] Initial implementation for Asus TUF Fan controller	2024-10-05 16:03:50 -05:00
Adam Honse	779c15e41c	Add basic Razer Blade 14 2021 fan control based on razer-fan-control's reverse engineering effort. Commanding zero speed sets auto fan control mode	2024-10-05 16:03:50 -05:00
Scott Wilde	a6915868d2	fix fan box initial values	2024-10-05 16:03:50 -05:00
Scott Wilde	7266e4131a	Initial commit for KrakenX fan controller Commits squashed and amended for code style by Adam Honse <[email protected]>	2024-10-05 16:03:50 -05:00
Adam Honse	b5105ed096	Add Fan Controller for FanBus Devices	2024-10-05 16:03:49 -05:00
Adam Honse	156cbfab0f	More hidapi changes for windows	2024-10-05 16:03:49 -05:00
Adam Honse	289f14214f	Fix fan controller UI	2024-10-05 16:03:49 -05:00
Adam Honse	4fc1e84001	Adjust packet sizes for hidapi byte 0	2024-10-05 16:03:49 -05:00
Adam Honse	188d8592ce	Join fan update thread before deleting fan tab	2024-10-05 16:03:49 -05:00
Adam Honse	73051af251	Select the main tab by default, not the fan tab	2024-10-05 16:03:49 -05:00
Adam Honse	9a960a7d48	Initial NZXT Smart Device V2 fan controller. Use a thread to process fan updates to avoid locking up the dialog.	2024-10-05 16:03:49 -05:00
Adam Honse	d3a36fc184	FanController implementation for Corsair Commander Pro	2024-10-05 16:03:49 -05:00
Adam Honse	f995eb8021	Initial fan controller API and Thermaltake Riing controller implementation	2024-10-05 16:03:49 -05:00