Add Translations field to SDK protocol

.github/FUNDING.yml

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

.github/workflows/issue_opened.yml

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

.github/workflows/pr_opened.yml

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

.gitignore

@@ -28,7 +28,6 @@ Build/
 .qmake.stash
 .vscode
 .vs
-.idea
 
 # Generic Files
 .DS_Store

.gitlab-ci.yml

@@ -7,22 +7,6 @@
 #-----------------------------------------------------------------------#
 # OpenRGB GitLab CI Configuration                                       #
 #-----------------------------------------------------------------------#
-.fork_local_runner_rules:
-  rules:
-  - if: $CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB" || $CI_PIPELINE_SOURCE == "push"
-    when: on_success
-
-.fork_gitlab_runner_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"'
-    when: on_success
-  - !reference [.fork_gitlab_runner_rules, rules]
 
 .shared_windows_runners:
   tags:
@@ -33,22 +17,22 @@
 stages:
   - build
   - test
-  - deploy
-
-variables:
-  GIT_DEPTH: 0
 
 before_script:
  - echo "started by ${GITLAB_USER_NAME}"
 
+#reusable templates
+.ccache_init: &ccache_init
+  before_script:
+    - export QT_SELECT=qt5
+    - export APPIMAGE_EXTRACT_AND_RUN=1
+
 #-----------------------------------------------------------------------#
 # Supported Devices Build Target                                        #
 #-----------------------------------------------------------------------#
 "Supported Devices":
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-amd64
-  tags:
-  - linux
-  - amd64
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
   stage: build
   script:
   - qmake
@@ -58,142 +42,217 @@ before_script:
   artifacts:
     name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
     paths:
+    - ./*.md
     - Supported Devices.csv
+    exclude:
+    - README.md
+    - CONTRIBUTING.md
     expire_in: 30 days
 
   rules:
-    - !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                                   #
+# Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-.hidden_appimage_script: &appimage_script_steps
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-${TGT_ARCH}
-  tags:
-  - linux
-  - ${TGT_ARCH}
+"Linux 32 AppImage":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
   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_32_${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 (AppImage) 64-bit Build Target                                  #
 #-----------------------------------------------------------------------#
-"Linux i386 AppImage":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_QT: ""
-    TGT_NAME: "${TGT_ARCH}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
+"Linux 64 AppImage":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
+  stage: build
+  script:
+  - export $(dpkg-architecture)
+  - ./scripts/build-appimage.sh
 
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - OpenRGB-x86_64.AppImage
+    - 60-openrgb.rules
+    - README.md
+    expire_in: 30 days
+
 #-----------------------------------------------------------------------#
-# Linux (AppImage) Qt6 i386 Build Target                                #
+# Linux (.deb) Debian Buster (Legacy) 32-bit Build Target               #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Buster)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
-"Linux i386 AppImage Qt6":
-  variables:
-    TGT_ARCH: "i386"
-    TGT_QT: "qt6"
-    TGT_NAME: "${TGT_ARCH}_${TGT_QT^}"
-    TGT_PATH: "${TGT_ARCH}"
-  <<: *appimage_script_steps
+# Linux (.deb) Debian Buster (Legacy) 64-bit Build Target               #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Buster)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
 
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
 #-----------------------------------------------------------------------#
-# Linux (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 [.fork_local_runner_rules, rules]
+# Linux (.deb) Debian Bullseye 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
 
-"Linux amd64 AppImage (gitlab.com runner)":
-  extends: "Linux amd64 AppImage"
   rules:
-  - !reference [.fork_gitlab_runner_rules, rules]
-  tags:
-  - "saas-linux-small-amd64"
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
 
 #-----------------------------------------------------------------------#
-# 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 (.deb) Debian Bullseye 64-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 64 .deb (Debian Bullseye)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage -us -B
+  - rm -v ../openrgb-dbgsym*.*deb
+  - mv -v ../openrgb*.deb ./
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.*deb
+    expire_in: 30 days
 
-#-----------------------------------------------------------------------#
-# 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
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
 
-#-----------------------------------------------------------------------#
-# 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 (.deb) Debian Bookworm 32-bit Build Target                      #
+#-----------------------------------------------------------------------#
+"Linux 32 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
+  stage: build
+  script:
+  - ./scripts/build-package-files.sh debian/changelog
+  - dpkg-architecture -l
+  - dpkg-buildpackage --target-arch i386 -us -B
+  - rm -v ../openrgb-dbgsym*.deb
+  - mv -v ../openrgb*.deb ./
 
-#-----------------------------------------------------------------------#
-# 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
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.deb
+    exclude:
+    - openrgb-dbgsym*.deb
+    expire_in: 30 days
 
-#-----------------------------------------------------------------------#
-# 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
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
 
 #-----------------------------------------------------------------------#
-# OpenRGB Common Debian Build Steps                                     #
+# Linux (.deb) Debian Bookworm 64-bit Build Target                      #
 #-----------------------------------------------------------------------#
-.hidden_deb_script: &debian_script_steps
+"Linux 64 .deb (Debian Bookworm)":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
   stage: build
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:$TGT_DEB-$TGT_ARCH
-  tags:
-  - linux
-  - $TGT_ARCH
   script:
   - ./scripts/build-package-files.sh debian/changelog
   - dpkg-architecture -l
@@ -202,100 +261,36 @@ before_script:
   - mv -v ../openrgb*.deb ./
 
   artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_${TGT_ARCH}_deb_${CI_COMMIT_SHORT_SHA}"
+    name: "${CI_PROJECT_NAME}_Linux_64_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 (.rpm, f35) 64-bit 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 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, F40) 64-bit Build Target                                 #
-#-----------------------------------------------------------------------#
-"Linux 64 F40 rpm":
-  image: fedora:40
+"Linux 64 f35 rpm":
+  image: fedora:35
   stage: build
   script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel git -y
+  - dnf install rpmdevtools dnf-plugins-core -y
   - rpmdev-setuptree
   - ./scripts/build-package-files.sh fedora/OpenRGB.spec
+  - ls /root/
   - cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
-  - cp -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/
@@ -309,12 +304,115 @@ 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                                             #
+# Linux (.rpm, f36) 64-bit Build Target                                 #
 #-----------------------------------------------------------------------#
-"Debian i386 Bookworm":
+"Linux 64 f36 rpm":
+  image: fedora:36
+  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 ../OpenRGB /root/rpmbuild/SOURCES/ -r
+  - cd /root/rpmbuild/SOURCES
+  - tar -cf OpenRGB.tar.gz OpenRGB/
+  - cd ..
+  - dnf builddep SPECS/OpenRGB.spec -y
+  - rpmbuild -ba SPECS/OpenRGB.spec
+  - cd RPMS/x86_64/
+  - mv openrgb*.rpm ${CI_PROJECT_DIR}/
+  - cd ${CI_PROJECT_DIR}
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - openrgb*.rpm
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+  - if: $CI_PIPELINE_SOURCE == "push"
+    when: manual
+    allow_failure: true
+
+#-----------------------------------------------------------------------#
+# Debian 32 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 32 Buster":
+  image: i386/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 32 .deb (Debian Buster)"
+  needs:
+  - "Linux 32 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Buster test                                                 #
+#-----------------------------------------------------------------------#
+"Debian 64 Buster":
+  image: amd64/debian:buster
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Debian 32 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bullseye":
+  image: i386/debian:bullseye
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 32 .deb (Debian Bullseye)"
+  needs:
+  - "Linux 32 .deb (Debian Bullseye)"
+
+#-----------------------------------------------------------------------#
+# Debian 64 Bullseye test                                               #
+#-----------------------------------------------------------------------#
+"Debian 64 Bullseye":
+  image: amd64/debian:bullseye
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Bullseye)"
+  needs:
+  - "Linux 64 .deb (Debian Bullseye)"
+
+#-----------------------------------------------------------------------#
+# Debian 32 Bookworm test                                               #
+#-----------------------------------------------------------------------#
+"Debian 32 Bookworm":
   image: i386/debian:bookworm
   stage: test
   script:
@@ -323,14 +421,14 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux i386 .deb (Debian Bookworm)"
+  - "Linux 32 .deb (Debian Bookworm)"
   needs:
-  - "Linux i386 .deb (Debian Bookworm)"
+  - "Linux 32 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Debian amd64 Bookworm test                                            #
+# Debian 64 Bookworm test                                               #
 #-----------------------------------------------------------------------#
-"Debian amd64 Bookworm":
+"Debian 64 Bookworm":
   image: amd64/debian:bookworm
   stage: test
   script:
@@ -339,14 +437,30 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
   needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu amd64 22.04 test                                               #
+# Ubuntu 64 20.04LTS test                                               #
 #-----------------------------------------------------------------------#
-"Ubuntu amd64 22.04LTS":
+"Ubuntu 64 20.04LTS":
+  image: ubuntu:focal
+  stage: test
+  script:
+  - apt update
+  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
+  - openrgb --version
+  - apt remove -y openrgb
+  dependencies:
+  - "Linux 64 .deb (Debian Buster)"
+  needs:
+  - "Linux 64 .deb (Debian Buster)"
+
+#-----------------------------------------------------------------------#
+# Ubuntu 64 22.04 test                                                  #
+#-----------------------------------------------------------------------#
+"Ubuntu 64 22.04LTS":
   image: ubuntu:jammy
   stage: test
   script:
@@ -355,40 +469,39 @@ before_script:
   - openrgb --version
   - apt remove -y openrgb
   dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
   needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
+  - "Linux 64 .deb (Debian Bookworm)"
 
 #-----------------------------------------------------------------------#
-# Ubuntu amd64 24.04 test                                               #
+# Fedora 64 v35 test                                                    #
 #-----------------------------------------------------------------------#
-"Ubuntu amd64 24.04LTS":
-  image: ubuntu:noble
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux amd64 .deb (Debian Bookworm)"
-  needs:
-  - "Linux amd64 .deb (Debian Bookworm)"
-
-#-----------------------------------------------------------------------#
-# Fedora 64 v40 test                                                    #
-#-----------------------------------------------------------------------#
-"Fedora 64 v40":
-  image: fedora:40
+"Fedora 64 v35":
+  image: fedora:35
   stage: test
   script:
   - yum -y localinstall ./openrgb*64.rpm
   - openrgb --version
   - yum -y remove openrgb
   dependencies:
-  - "Linux 64 F40 rpm"
+  - "Linux 64 f35 rpm"
   needs:
-  - "Linux 64 F40 rpm"
+  - "Linux 64 f35 rpm"
+
+#-----------------------------------------------------------------------#
+# Fedora 64 v36 test                                                    #
+#-----------------------------------------------------------------------#
+"Fedora 64 v36":
+  image: fedora:36
+  stage: test
+  script:
+  - yum -y localinstall ./openrgb*64.rpm
+  - openrgb --version
+  - yum -y remove openrgb
+  dependencies:
+  - "Linux 64 f36 rpm"
+  needs:
+  - "Linux 64 f36 rpm"
 
 #-----------------------------------------------------------------------#
 # Windows (32-bit) Build Target                                         #
@@ -398,8 +511,61 @@ before_script:
   - .shared_windows_runners
   stage: build
   script:
-  - Set-MpPreference -DisableRealtimeMonitoring $true
-  - 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:
@@ -409,39 +575,75 @@ before_script:
     expire_in: 30 days
 
   rules:
-    - !reference [.upstream_rules, rules]
-
-#-----------------------------------------------------------------------#
-# Windows (32-bit) Qt6 Build Target                                     #
-#-----------------------------------------------------------------------#
-"Windows 32 Qt6":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - Set-MpPreference -DisableRealtimeMonitoring $true
-  - 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
-
-  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 (64-bit) Build Target                                         #
 #-----------------------------------------------------------------------#
-"Windows 64 Base":
+"Windows 64":
   extends:
   - .shared_windows_runners
   stage: build
   script:
-  - Set-MpPreference -DisableRealtimeMonitoring $true
-  - scripts\build-windows.bat 5.15.0 2019 64
+  - $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 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:
@@ -450,68 +652,6 @@ 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 [.fork_local_runner_rules, rules]
-
-"Windows 64 (gitlab.com runner)":
-  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 [.fork_gitlab_runner_rules, rules]
-  tags:
-  - "saas-windows-medium-amd64"
-
-#-----------------------------------------------------------------------#
-# Windows (64-bit) Qt6 Build Target                                     #
-#-----------------------------------------------------------------------#
-"Windows 64 Qt6 Base":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - Set-MpPreference -DisableRealtimeMonitoring $true
-  - 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 [.fork_local_runner_rules, rules]
-
-"Windows 64 Qt6 (gitlab.com runner)":
-  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 [.fork_gitlab_runner_rules, rules]
-  tags:
-  - "saas-windows-medium-amd64"
-
 #-----------------------------------------------------------------------#
 # MacOS Build Target                                                    #
 #-----------------------------------------------------------------------#
@@ -564,30 +704,3 @@ before_script:
   - if: $CI_PIPELINE_SOURCE == "push"
     when: manual
     allow_failure: true
-
-#-----------------------------------------------------------------------#
-# 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]

.gitlab/CODEOWNERS

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

.gitlab/issue_templates/New Device.md

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

AutoStart/AutoStart-FreeBSD.cpp

@@ -1,20 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.cpp                                     |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+#include "AutoStart-FreeBSD.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 #include <fstream>
 #include <iostream>
 #include <limits.h>
 #include <unistd.h>
 #include <sstream>
-#include "AutoStart-FreeBSD.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| FreeBSD AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -26,21 +23,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 +50,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 +60,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 +100,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 +115,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 +131,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 +152,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;

AutoStart/AutoStart-FreeBSD.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-FreeBSD.h                                       |
-|                                                           |
-|   Autostart implementation for FreeBSD                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Linux.cpp

@@ -1,20 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.cpp                                       |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+#include "AutoStart-Linux.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <unistd.h>
 #include <linux/limits.h>
-#include "AutoStart-Linux.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| Linux AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -26,21 +23,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 +50,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 +60,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 +87,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 +101,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,27 +116,27 @@ 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);
-
+    
     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 +148,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 != "")
@@ -162,7 +159,7 @@ std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
     }
 
     fileContents << std::endl;
-
+    
     return(fileContents.str());
 }
 
@@ -172,16 +169,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,15 +190,15 @@ 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;
 
         bool success = true;
-
+        
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-Linux.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Linux.h                                         |
-|                                                           |
-|   Autostart implementation for Linux                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-MacOS.cpp

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.cpp                                       |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+#include "AutoStart-MacOS.h"
+#include "LogManager.h"
+#include "filesystem.h"
 
 #include <fstream>
 #include <sstream>
 #include <iostream>
 #include <unistd.h>
+
 #include <mach-o/dyld.h>
-#include "AutoStart-MacOS.h"
-#include "LogManager.h"
-#include "filesystem.h"
+
+/*-----------------------------------------------------*\
+| MacOS AutoStart Implementation                        |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -26,21 +24,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 +51,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 +61,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 +88,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 +102,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 +117,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 +130,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;
@@ -154,7 +152,7 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
     fileContents << "    <key>ProgramArguments</key>"                                                                               << std::endl;
     fileContents << "    <array>"                                                                                                   << std::endl;
     fileContents << "        <string>" << autostart_info.path << "</string>"                                                        << std::endl;
-
+    
     if(autostart_info.args != "")
     {
         std::istringstream arg_parser(autostart_info.args);
@@ -165,12 +163,12 @@ std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
             fileContents << "        <string>" << arg << "</string>"                                                                << std::endl;
         }
     }
-
+    
     fileContents << "    </array>"                                                                                                  << std::endl;
     fileContents << "    <key>RunAtLoad</key><true/>"                                                                               << std::endl;
     fileContents << "</dict>"                                                                                                       << std::endl;
     fileContents << "</plist>"                                                                                                      << std::endl;
-
+    
     return(fileContents.str());
 }
 
@@ -180,22 +178,22 @@ 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;
 
         bool success = true;
-
+        
         if(!filesystem::exists(autostart_dir))
         {
             success = filesystem::create_directories(autostart_dir, ec);

AutoStart/AutoStart-MacOS.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-MacOS.h                                         |
-|                                                           |
-|   Autostart implementation for MacOS                      |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart-Windows.cpp

@@ -1,19 +1,17 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.cpp                                     |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <fstream>
-#include <iostream>
-#include <shlobj.h>
 #include "AutoStart-Windows.h"
 #include "LogManager.h"
 #include "filesystem.h"
+
+#include <fstream>
+#include <iostream>
+
 #include "windows.h"
+#include <shlobj.h>
+
+/*-----------------------------------------------------*\
+| Windows AutoStart Implementation                      |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
 
 AutoStart::AutoStart(std::string name)
 {
@@ -25,34 +23,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 +60,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 +77,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,21 +87,21 @@ 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());
             shellLink->SetArguments(argumentsw.c_str());
             shellLink->SetDescription(descriptionw.c_str());
             shellLink->SetIconLocation(iconw.c_str(), 0);
-
+            
             IPersistFile* persistFile;
-
+            
             result                                  = shellLink->QueryInterface(IID_IPersistFile, (void**)&persistFile);
-
+            
             if(SUCCEEDED(result))
             {
                 result                              = persistFile->Save(startupfilepathw.c_str(), TRUE);
@@ -114,9 +112,9 @@ bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
             shellLink->Release();
         }
 
-        /*-------------------------------------------------*\
-        | Uninitialize when done                            |
-        \*-------------------------------------------------*/
+        /*---------------------------------------------*\
+        | Uninitialize when done                        |
+        \*---------------------------------------------*/
         if(weInitialised)
         {
             CoUninitialize();
@@ -124,7 +122,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 +130,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,20 +145,20 @@ 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);
-
+    
     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 +166,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 +183,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())
@@ -199,8 +197,8 @@ std::wstring AutoStart::utf8_decode(const std::string& str)
     int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), nullptr, 0);
 
     std::wstring wstrTo(size_needed, 0);
-
+    
     MultiByteToWideChar(CP_UTF8, 0, &str[0], (int) str.size(), &wstrTo[0], size_needed);
-
+    
     return(wstrTo);
 }

AutoStart/AutoStart-Windows.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart-Windows.h                                       |
-|                                                           |
-|   Autostart implementation for Windows                    |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

AutoStart/AutoStart.cpp

@@ -1,14 +1,10 @@
-/*---------------------------------------------------------*\
-| AutoStart.cpp                                             |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "AutoStart.h"
 
+/*-----------------------------------------------------*\
+| Common AutoStart Implementation                       |
+| Public Methods                                        |
+\*-----------------------------------------------------*/
+
 std::string AutoStartInterface::GetAutoStartFile()
 {
     return(autostart_file);

AutoStart/AutoStart.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| AutoStart.h                                               |
-|                                                           |
-|   Autostart common implementation                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #pragma once
 
 #include <string>

CONTRIBUTING.md

@@ -67,8 +67,3 @@ OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake buil
 | 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.

Colors.h

@@ -1,12 +1,3 @@
-/*---------------------------------------------------------*\
-| Colors.h                                                  |
-|                                                           |
-|   List of named color constants                           |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #ifndef COLORS_H
 #define COLORS_H
 

Controllers/A4TechController/A4Tech_Detector.cpp

@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| A4TechDetector.cpp                                        |
-|                                                           |
-|   Detector for A4Tech Devices                             |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-------------------------------------------------------------------*\
+|  A4TechDetector.cpp                                                 |
+|                                                                     |
+|  Driver for A4Tech Devices Detector                                 |
+|                                                                     |
+|  Chris M (Dr_No)                              30 Jun 2022           |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)    01 Apr 2024           |
+|                                                                     |
+\*-------------------------------------------------------------------*/
 
 /*-----------------------------------------------------*\
 | OpenRGB includes                                      |
 \*-----------------------------------------------------*/
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
 #include "Detector.h"
+#include "RGBController.h"
 
 /*-----------------------------------------------------*\
 | A4 Tech specific includes                             |
@@ -33,8 +32,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 +46,15 @@ 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 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);

Controllers/A4TechController/BloodyB820RController.cpp

@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.cpp                                          |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "BloodyB820RController.h"
+
+/*--------------------------------------------------------------------------------------*\
+ * The controller for this device should pass a packet of 64 bytes where the subsequent *
+ * two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control *
+ * or information bytes and colors bytes starts from index 6. Moreover, the first pack- *
+ * et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on  *
+ * the second packet.                                                                   *
+\*--------------------------------------------------------------------------------------*/
+
+BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path)
+{
+    dev                 = dev_handle;
+    location            = path;
+
+    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
+}
+
+BloodyB820RController::~BloodyB820RController()
+{
+    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
+    hid_close(dev);
+}
+
+std::string BloodyB820RController::GetSerial()
+{
+    const int szTemp    = HID_MAX_STR;
+    wchar_t   tmpName[szTemp];
+
+    hid_get_serial_number_string(dev, tmpName, szTemp);
+    std::wstring wName  = std::wstring(tmpName);
+    std::string serial  = std::string(wName.begin(), wName.end());
+
+    return serial;
+}
+
+std::string BloodyB820RController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyB820RController::SendControlPacket(uint8_t data)
+{
+    uint8_t buffer[BLOODY_B820R_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+
+    buffer[BLOODY_B820R_MODE_BYTE]                   = 0;
+    buffer[BLOODY_B820R_DATA_BYTE]                   = data;
+
+    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
+}
+
+void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
+{
+
+    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
+    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
+    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
+    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
+    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
+    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
+
+    /*-----------------------------------------------------------------*\
+    | Set up Direct packet                                              |
+    |   packet_map is the index of the Key from full_matrix_map and     |
+    |   the value is the position in the direct packet buffer           |
+    \*-----------------------------------------------------------------*/
+
+
+    for(size_t i = 0; i < colors.size(); i++)
+    {
+        RGBColor    color                     = colors[i];
+        uint8_t     offset                    = BLOODY_B820R_RGB_OFFSET;
+        uint8_t     buffer_idx                = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
+        uint8_t*    buffers[2][3]             =
+                {
+                        {r1_buffer, g1_buffer, b1_buffer},
+                        {r2_buffer, g2_buffer, b2_buffer}
+                };
+
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
+        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
+    }
+
+    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
+    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyB820RController.h

@@ -0,0 +1,51 @@
+/*-------------------------------------------------------------------*\
+|  BloodyB820RController.h                                            |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+#define NA                                      0xFFFFFFFF
+#define HID_MAX_STR                             255
+
+#define BLOODY_B820R_RGB_BUFFER_SIZE    58
+#define BLOODY_B820R_RGB_OFFSET         6
+#define BLOODY_B820R_PACKET_SIZE        64
+#define BLOODY_B820R_KEYCOUNT           104
+#define BLOODY_B820R_MODE_BYTE          3
+#define BLOODY_B820R_DATA_BYTE          8
+#define BLOODY_B820R_GAIN_CONTROL       0x01
+#define BLOODY_B820R_RELEASE_CONTROL    0x00
+
+/*---------------------------------------------------------*\
+| Bloody B820R product ID                                    |
+\*---------------------------------------------------------*/
+#define BLOODY_B820R_PID                               0xFA10
+
+enum
+{
+    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
+};
+
+class BloodyB820RController
+{
+public:
+    BloodyB820RController(hid_device* dev_handle, const char* path);
+    ~BloodyB820RController();
+
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLEDDirect(std::vector<RGBColor> colors);
+    void            SendControlPacket(uint8_t data);
+private:
+    std::string     location;
+    hid_device*     dev;
+};

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.cpp

@@ -1,110 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "BloodyB820RController.h"
-#include "StringUtils.h"
-
-/*-------------------------------------------------------------------------------------*\
-| The controller for this device should pass a packet of 64 bytes where the subsequent  |
-| two packets are for RED, GREEN, and BLUE respectively. The first 6 bytes are control  |
-| or information bytes and colors bytes starts from index 6. Moreover, the first pack-  |
-| et of each RGB contains color for 58 keys and the rest (104 - 58 == 46) are send on   |
-| the second packet.                                                                    |
-\*-------------------------------------------------------------------------------------*/
-
-BloodyB820RController::BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name)
-{
-    dev                 = dev_handle;
-    location            = path;
-    name                = dev_name;
-
-    SendControlPacket(BLOODY_B820R_GAIN_CONTROL);
-}
-
-BloodyB820RController::~BloodyB820RController()
-{
-    SendControlPacket(BLOODY_B820R_RELEASE_CONTROL);
-    hid_close(dev);
-}
-
-std::string BloodyB820RController::GetSerial()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-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 };
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-
-    buffer[BLOODY_B820R_MODE_BYTE]              = 0;
-    buffer[BLOODY_B820R_DATA_BYTE]              = data;
-
-    hid_send_feature_report(dev, buffer, BLOODY_B820R_PACKET_SIZE);
-}
-
-void BloodyB820RController::SetLEDDirect(std::vector<RGBColor> colors)
-{
-
-    uint8_t r1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x07, 0x00, 0x00 };
-    uint8_t r2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x08, 0x00, 0x00 };
-    uint8_t g1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x09, 0x00, 0x00 };
-    uint8_t g2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0A, 0x00, 0x00 };
-    uint8_t b1_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0B, 0x00, 0x00 };
-    uint8_t b2_buffer[BLOODY_B820R_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x0C, 0x00, 0x00 };
-
-    /*-----------------------------------------------------------------*\
-    | Set up Direct packet                                              |
-    |   packet_map is the index of the Key from full_matrix_map and     |
-    |   the value is the position in the direct packet buffer           |
-    \*-----------------------------------------------------------------*/
-    for(size_t i = 0; i < colors.size(); i++)
-    {
-        RGBColor    color                       = colors[i];
-        uint8_t     offset                      = BLOODY_B820R_RGB_OFFSET;
-        uint8_t     buffer_idx                  = offset + i % BLOODY_B820R_RGB_BUFFER_SIZE;
-        uint8_t*    buffers[2][3]               =
-                {
-                        {r1_buffer, g1_buffer, b1_buffer},
-                        {r2_buffer, g2_buffer, b2_buffer}
-                };
-
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][0][buffer_idx] = RGBGetRValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][1][buffer_idx] = RGBGetGValue(color);
-        buffers[i >= BLOODY_B820R_RGB_BUFFER_SIZE][2][buffer_idx] = RGBGetBValue(color);
-    }
-
-    hid_send_feature_report(dev, r1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, r2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, g2_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b1_buffer, BLOODY_B820R_PACKET_SIZE);
-    hid_send_feature_report(dev, b2_buffer, BLOODY_B820R_PACKET_SIZE);
-}

Controllers/A4TechController/BloodyB820RController/BloodyB820RController.h

@@ -1,55 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyB820RController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody B820R Keyboard                 |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-#define HID_MAX_STR                     255
-
-#define BLOODY_B820R_RGB_BUFFER_SIZE    58
-#define BLOODY_B820R_RGB_OFFSET         6
-#define BLOODY_B820R_PACKET_SIZE        64
-#define BLOODY_B820R_KEYCOUNT           104
-#define BLOODY_B820R_MODE_BYTE          3
-#define BLOODY_B820R_DATA_BYTE          8
-#define BLOODY_B820R_GAIN_CONTROL       0x01
-#define BLOODY_B820R_RELEASE_CONTROL    0x00
-
-/*---------------------------------------------------------*\
-| Bloody B820R product ID                                   |
-\*---------------------------------------------------------*/
-#define BLOODY_B820R_PID                            0xFA10
-
-enum
-{
-    BLOODY_B820R_MODE_DIRECT     = 0x01,    // Direct LED control - Independently set LEDs in zone
-};
-
-class BloodyB820RController
-{
-public:
-    BloodyB820RController(hid_device* dev_handle, const char* path, std::string dev_name);
-    ~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;
-};

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -1,253 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_BloodyB820R.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int matrix_map[6][21] =
-    {
-        {0,  NA, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, NA, NA,  NA,  NA,  13, 14,  15},
-        {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,  32,  33,  34, 35,  36},
-        {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,  53,  54,  55, 56,  57},
-        {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA,  NA,  71,  72, 73,  NA},
-        {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86,  NA,  87,  88, 89,  90},
-        {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
-    };
-
-static const char *led_names[] =
-    {
-        KEY_EN_ESCAPE,              //00
-        KEY_EN_F1,
-        KEY_EN_F2,
-        KEY_EN_F3,
-        KEY_EN_F4,
-        KEY_EN_F5,
-        KEY_EN_F6,
-        KEY_EN_F7,
-        KEY_EN_F8,
-        KEY_EN_F9,
-        KEY_EN_F10,
-        KEY_EN_F11,
-        KEY_EN_F12,
-        KEY_EN_PRINT_SCREEN,
-        KEY_EN_SCROLL_LOCK,
-        KEY_EN_PAUSE_BREAK,
-
-        KEY_EN_BACK_TICK,           //10
-        KEY_EN_1,
-        KEY_EN_2,
-        KEY_EN_3,
-        KEY_EN_4,
-        KEY_EN_5,
-        KEY_EN_6,
-        KEY_EN_7,
-        KEY_EN_8,
-        KEY_EN_9,
-        KEY_EN_0,
-        KEY_EN_MINUS,
-        KEY_EN_EQUALS,
-        KEY_EN_BACKSPACE,
-        KEY_EN_INSERT,
-        KEY_EN_HOME,
-        KEY_EN_PAGE_UP,
-        KEY_EN_NUMPAD_LOCK,
-        KEY_EN_NUMPAD_DIVIDE,
-        KEY_EN_NUMPAD_TIMES,
-        KEY_EN_NUMPAD_MINUS,
-
-        KEY_EN_TAB,                 //20
-        KEY_EN_Q,
-        KEY_EN_W,
-        KEY_EN_E,
-        KEY_EN_R,
-        KEY_EN_T,
-        KEY_EN_Y,
-        KEY_EN_U,
-        KEY_EN_I,
-        KEY_EN_O,
-        KEY_EN_P,
-        KEY_EN_LEFT_BRACKET,
-        KEY_EN_RIGHT_BRACKET,
-        KEY_EN_ANSI_BACK_SLASH,
-        KEY_EN_DELETE,
-        KEY_EN_END,
-        KEY_EN_PAGE_DOWN,
-        KEY_EN_NUMPAD_7,
-        KEY_EN_NUMPAD_8,
-        KEY_EN_NUMPAD_9,
-        KEY_EN_NUMPAD_PLUS,
-
-        KEY_EN_CAPS_LOCK,           //30
-        KEY_EN_A,
-        KEY_EN_S,
-        KEY_EN_D,
-        KEY_EN_F,
-        KEY_EN_G,
-        KEY_EN_H,
-        KEY_EN_J,
-        KEY_EN_K,
-        KEY_EN_L,
-        KEY_EN_SEMICOLON,
-        KEY_EN_QUOTE,
-        KEY_EN_ANSI_ENTER,
-        KEY_EN_NUMPAD_4,
-        KEY_EN_NUMPAD_5,
-        KEY_EN_NUMPAD_6,
-
-        KEY_EN_LEFT_SHIFT,          //40
-        KEY_EN_Z,
-        KEY_EN_X,
-        KEY_EN_C,
-        KEY_EN_V,
-        KEY_EN_B,
-        KEY_EN_N,
-        KEY_EN_M,
-        KEY_EN_COMMA,
-        KEY_EN_PERIOD,
-        KEY_EN_FORWARD_SLASH,
-        KEY_EN_RIGHT_SHIFT,
-        KEY_EN_UP_ARROW,
-        KEY_EN_NUMPAD_1,
-        KEY_EN_NUMPAD_2,
-        KEY_EN_NUMPAD_3,
-        KEY_EN_NUMPAD_ENTER,
-
-        KEY_EN_LEFT_CONTROL,        //50
-        KEY_EN_LEFT_WINDOWS,
-        KEY_EN_LEFT_ALT,
-        KEY_EN_SPACE,
-        KEY_EN_RIGHT_ALT,
-        KEY_EN_RIGHT_FUNCTION,
-        KEY_EN_MENU,
-        KEY_EN_RIGHT_CONTROL,
-        KEY_EN_LEFT_ARROW,
-        KEY_EN_DOWN_ARROW,
-        KEY_EN_RIGHT_ARROW,
-        KEY_EN_NUMPAD_0,
-        KEY_EN_NUMPAD_PERIOD
-    };
-
-/**------------------------------------------------------------------*\
-    @name A4Tech Bloody B820R
-    @category Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectBloodyB820R
-    @comment The A4Tech Bloody B820R keyboard controller currently
-        supports the full size (ANSI layout).
-\*-------------------------------------------------------------------*/
-
-RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetName();
-    vendor                      = "A4Tech";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "A4Tech Bloody Keyboard";
-    serial                      = controller->GetSerial();
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = BLOODY_B820R_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    SetupZones();
-}
-
-RGBController_BloodyB820R::~RGBController_BloodyB820R()
-{
-    delete controller;
-}
-
-void RGBController_BloodyB820R::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Create the Keyboard zone and add the matrix map   |
-    \*-------------------------------------------------*/
-    zone KB_zone;
-    KB_zone.name                = ZONE_EN_KEYBOARD;
-    KB_zone.type                = ZONE_TYPE_MATRIX;
-    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
-    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
-
-    KB_zone.matrix_map          = new matrix_map_type;
-    KB_zone.matrix_map->height  = 6;
-    KB_zone.matrix_map->width   = 21;
-    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
-    zones.push_back(KB_zone);
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
-    {
-        led new_led;
-        new_led.name        = led_names[led_index];
-        new_led.value       = led_index;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-
-void RGBController_BloodyB820R::DeviceUpdateLEDs()
-{
-    controller->SetLEDDirect(colors);
-}
-
-void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
-{
-    std::vector<RGBColor> colour;
-
-    for(size_t i = 0; i < zones[zone].leds_count; i++)
-    {
-        colour.push_back(zones[zone].colors[i]);
-    }
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::UpdateSingleLED(int led)
-{
-    std::vector<RGBColor> colour;
-    colour.push_back(colors[led]);
-
-    controller->SetLEDDirect(colour);
-}
-
-void RGBController_BloodyB820R::DeviceUpdateMode()
-{
-    /* This device does not support modes yet */
-}

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.h

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyB820R.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody B820R Keyboard          |
-|                                                           |
-|   Mohammed Julfikar Ali Mahbub (o-julfikar)   01 Apr 2024 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "BloodyB820RController.h"
-
-class RGBController_BloodyB820R : public RGBController
-{
-public:
-    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
-    ~RGBController_BloodyB820R();
-
-    void    SetupZones();
-    void    ResizeZone(int zone, int new_size);
-
-    void    DeviceUpdateLEDs();
-    void    UpdateZoneLEDs(int zone);
-    void    UpdateSingleLED(int led);
-
-    void    DeviceUpdateMode();
-
-private:
-    BloodyB820RController* controller;
-};

Controllers/A4TechController/BloodyMouseController.cpp

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.cpp                                            |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include "BloodyMouseController.h"
+#include "LogManager.h"
+
+BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
+{
+    dev                 = dev_handle;
+    location            = path;
+    pid                 = product_id;
+
+    InitDevice();
+}
+
+BloodyMouseController::~BloodyMouseController()
+{
+    hid_close(dev);
+}
+
+uint16_t BloodyMouseController::GetPid()
+{
+    return pid;
+}
+
+std::string BloodyMouseController::GetSerial()
+{
+    const uint8_t   sz  = HID_MAX_STR;
+    wchar_t         tmp[sz];
+
+    int ret             = hid_get_serial_number_string(dev, tmp, sz);
+
+    if (ret != 0)
+    {
+        LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
+        return("");
+    }
+
+    std::wstring w_tmp  = std::wstring(tmp);
+    std::string serial  = std::string(w_tmp.begin(), w_tmp.end());
+
+    return serial;
+}
+
+std::string BloodyMouseController::GetLocation()
+{
+    return("HID: " + location);
+}
+
+void  BloodyMouseController::InitDevice()
+{
+    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+
+    buffer[BLOODYMOUSE_MODE_BYTE]                   = 0;
+    buffer[BLOODYMOUSE_DATA_BYTE]                   = 1;
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}
+
+void  BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
+{
+    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
+
+    for(uint8_t i = 0; i < colors.size(); i++)
+    {
+        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
+
+        buffer[offset]                              = RGBGetRValue(colors[i]);
+        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
+        buffer[offset + 2]                          = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
+}

Controllers/A4TechController/BloodyMouseController.h

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------*\
+|  BloodyMouseController.h                                              |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+#include "RGBController.h"
+
+#pragma once
+
+/*-----------------------------------------------------*\
+| Mouse product IDs                                     |
+\*-----------------------------------------------------*/
+#define BLOODY_W60_PRO_PID                          0x37EA
+#define BLOODY_W90_MAX_PID                          0x3666
+
+/*-----------------------------------------------------*\
+| Mousemat product IDs                                  |
+\*-----------------------------------------------------*/
+#define BLOODY_MP_50RS_PID                          0xFA60
+
+#define HID_MAX_STR 255
+#define BLOODYMOUSE_WRITE_PACKET_SIZE   64
+
+#define BLOODYMOUSE_BRIGHTNESS_MIN      0
+#define BLOODYMOUSE_BRIGHTNESS_MAX      255
+
+enum
+{
+    BLOODYMOUSE_MODE_DIRECT             = 0x01, //Direct Led Control - Independently set LEDs in zone
+};
+
+enum
+{
+    BLOODYMOUSE_REPORT_BYTE             = 1,
+    BLOODYMOUSE_COMMAND_BYTE            = 2,
+    BLOODYMOUSE_MODE_BYTE               = 3,
+    BLOODYMOUSE_DATA_BYTE               = 8,
+};
+
+class BloodyMouseController
+{
+public:
+    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
+    ~BloodyMouseController();
+
+    uint16_t        GetPid();
+    std::string     GetSerial();
+    std::string     GetLocation();
+
+    void            SetLedsDirect(std::vector<RGBColor> colors);
+private:
+    uint16_t        pid;
+    std::string     location;
+    hid_device*     dev;
+
+    void            InitDevice();
+};

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp

@@ -1,84 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.cpp                                 |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   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)
-{
-    dev                 = dev_handle;
-    location            = path;
-    pid                 = product_id;
-    name                = dev_name;
-
-    InitDevice();
-}
-
-BloodyMouseController::~BloodyMouseController()
-{
-    hid_close(dev);
-}
-
-uint16_t BloodyMouseController::GetPid()
-{
-    return(pid);
-}
-
-std::string BloodyMouseController::GetSerial()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    return(StringUtils::wstring_to_string(serial_string));
-}
-
-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 };
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-
-    buffer[BLOODYMOUSE_MODE_BYTE]                   = 0;
-    buffer[BLOODYMOUSE_DATA_BYTE]                   = 1;
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-}
-
-void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
-{
-    uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE]   = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
-
-    for(uint8_t i = 0; i < colors.size(); i++)
-    {
-        uint8_t offset                              = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
-
-        buffer[offset]                              = RGBGetRValue(colors[i]);
-        buffer[offset + 1]                          = RGBGetGValue(colors[i]);
-        buffer[offset + 2]                          = RGBGetBValue(colors[i]);
-    }
-
-    hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
-}

Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h

@@ -1,70 +0,0 @@
-/*---------------------------------------------------------*\
-| BloodyMouseController.h                                   |
-|                                                           |
-|   Driver for A4Tech Bloody Mouse                          |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
-/*-----------------------------------------------------*\
-| Mouse product IDs                                     |
-\*-----------------------------------------------------*/
-#define BLOODY_W60_PRO_PID                          0x37EA
-#define BLOODY_W70_MAX_PID                          0x79EF
-#define BLOODY_W90_MAX_PID                          0x3666
-#define BLOODY_W90_PRO_PID                          0x39B6
-
-/*-----------------------------------------------------*\
-| Mousemat product IDs                                  |
-\*-----------------------------------------------------*/
-#define BLOODY_MP_50RS_PID                          0xFA60
-
-#define HID_MAX_STR                     255
-#define BLOODYMOUSE_WRITE_PACKET_SIZE   64
-
-#define BLOODYMOUSE_BRIGHTNESS_MIN      0
-#define BLOODYMOUSE_BRIGHTNESS_MAX      255
-
-enum
-{
-    BLOODYMOUSE_MODE_DIRECT             = 0x01, //Direct Led Control - Independently set LEDs in zone
-};
-
-enum
-{
-    BLOODYMOUSE_REPORT_BYTE             = 1,
-    BLOODYMOUSE_COMMAND_BYTE            = 2,
-    BLOODYMOUSE_MODE_BYTE               = 3,
-    BLOODYMOUSE_DATA_BYTE               = 8,
-};
-
-class BloodyMouseController
-{
-public:
-    BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id, std::string dev_name);
-    ~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();
-};

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h

@@ -1,43 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.h                               |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include "RGBController.h"
-#include "BloodyMouseController.h"
-
-struct mouse_zone
-{
-    std::string             name;
-    std::vector<uint8_t>    zone_leds;
-};
-
-typedef std::vector<mouse_zone> mouse_layout;
-
-class RGBController_BloodyMouse : public RGBController
-{
-public:
-    RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
-    ~RGBController_BloodyMouse();
-
-    void                    SetupZones();
-    void                    ResizeZone(int zone, int new_size);
-
-    void                    DeviceUpdateLEDs();
-    void                    UpdateZoneLEDs(int zone);
-    void                    UpdateSingleLED(int led);
-
-    void                    DeviceUpdateMode();
-
-private:
-    BloodyMouseController*  controller;
-};

Controllers/A4TechController/RGBController_BloodyB820R.cpp

@@ -0,0 +1,247 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.cpp                                      |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                 |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "RGBControllerKeyNames.h"
+#include "RGBController_BloodyB820R.h"
+
+static unsigned int matrix_map[6][21] =
+        {
+                {0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA, NA, NA, 13, 14, 15},
+                {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36},
+                {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
+                {58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, NA, NA, NA, NA, 71, 72, 73, NA},
+                {74, NA, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, NA, NA, 86, NA, 87, 88, 89, 90},
+                {91, 92, 93, 94, NA, NA, NA, NA, NA, NA, 95, 96, 97, 98, 99, 100, 101, 102, NA, 103, NA},
+        };
+
+static const char *led_names[] =
+        {
+                KEY_EN_ESCAPE,              //00
+                KEY_EN_F1,
+                KEY_EN_F2,
+                KEY_EN_F3,
+                KEY_EN_F4,
+                KEY_EN_F5,
+                KEY_EN_F6,
+                KEY_EN_F7,
+                KEY_EN_F8,
+                KEY_EN_F9,
+                KEY_EN_F10,                 
+                KEY_EN_F11,
+                KEY_EN_F12,
+                KEY_EN_PRINT_SCREEN,
+                KEY_EN_SCROLL_LOCK,
+                KEY_EN_PAUSE_BREAK,
+
+                KEY_EN_BACK_TICK,           //10
+                KEY_EN_1,
+                KEY_EN_2,
+                KEY_EN_3,
+                KEY_EN_4,                   
+                KEY_EN_5,
+                KEY_EN_6,
+                KEY_EN_7,
+                KEY_EN_8,
+                KEY_EN_9,
+                KEY_EN_0,
+                KEY_EN_MINUS,
+                KEY_EN_EQUALS,
+                KEY_EN_BACKSPACE,
+                KEY_EN_INSERT,
+                KEY_EN_HOME,
+                KEY_EN_PAGE_UP,
+                KEY_EN_NUMPAD_LOCK,
+                KEY_EN_NUMPAD_DIVIDE,
+                KEY_EN_NUMPAD_TIMES,
+                KEY_EN_NUMPAD_MINUS,
+
+                KEY_EN_TAB,                 //20
+                KEY_EN_Q,
+                KEY_EN_W,
+                KEY_EN_E,
+                KEY_EN_R,
+                KEY_EN_T,
+                KEY_EN_Y,
+                KEY_EN_U,
+                KEY_EN_I,
+                KEY_EN_O,
+                KEY_EN_P,
+                KEY_EN_LEFT_BRACKET,
+                KEY_EN_RIGHT_BRACKET,
+                KEY_EN_ANSI_BACK_SLASH,
+                KEY_EN_DELETE,
+                KEY_EN_END,
+                KEY_EN_PAGE_DOWN,
+                KEY_EN_NUMPAD_7,
+                KEY_EN_NUMPAD_8,
+                KEY_EN_NUMPAD_9,
+                KEY_EN_NUMPAD_PLUS,
+
+                KEY_EN_CAPS_LOCK,           //30
+                KEY_EN_A,
+                KEY_EN_S,
+                KEY_EN_D,
+                KEY_EN_F,
+                KEY_EN_G,
+                KEY_EN_H,
+                KEY_EN_J,
+                KEY_EN_K,
+                KEY_EN_L,
+                KEY_EN_SEMICOLON,
+                KEY_EN_QUOTE,
+                KEY_EN_ANSI_ENTER,
+                KEY_EN_NUMPAD_4,
+                KEY_EN_NUMPAD_5,
+                KEY_EN_NUMPAD_6,
+
+                KEY_EN_LEFT_SHIFT,          //40
+                KEY_EN_Z,
+                KEY_EN_X,
+                KEY_EN_C,
+                KEY_EN_V,
+                KEY_EN_B,
+                KEY_EN_N,
+                KEY_EN_M,
+                KEY_EN_COMMA,
+                KEY_EN_PERIOD,
+                KEY_EN_FORWARD_SLASH,
+                KEY_EN_RIGHT_SHIFT,
+                KEY_EN_UP_ARROW,
+                KEY_EN_NUMPAD_1,
+                KEY_EN_NUMPAD_2,
+                KEY_EN_NUMPAD_3,
+                KEY_EN_NUMPAD_ENTER,
+
+                KEY_EN_LEFT_CONTROL,        //50
+                KEY_EN_LEFT_WINDOWS,
+                KEY_EN_LEFT_ALT,
+                KEY_EN_SPACE,
+                KEY_EN_RIGHT_ALT,
+                KEY_EN_RIGHT_FUNCTION,
+                KEY_EN_MENU,
+                KEY_EN_RIGHT_CONTROL,
+                KEY_EN_LEFT_ARROW,
+                KEY_EN_DOWN_ARROW,
+                KEY_EN_RIGHT_ARROW,
+                KEY_EN_NUMPAD_0,
+                KEY_EN_NUMPAD_PERIOD
+        };
+
+/**------------------------------------------------------------------*\
+    @name A4Tech Bloody B820R
+    @category Keyboard
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors A4TechDetector
+    @comment The A4Tech Bloody B820R keyboard controller currently
+        supports the full size (ANSI layout).
+\*-------------------------------------------------------------------*/
+
+RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *controller_ptr)
+{
+    controller                  = controller_ptr;
+
+    name                        = "Bloody B820R";
+    vendor                      = "A4Tech";
+    type                        = DEVICE_TYPE_KEYBOARD;
+    description                 = "A4Tech Bloody Keyboard";
+    serial                      = controller->GetSerial();
+    location                    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name                 = "Direct";
+    Direct.value                = BLOODY_B820R_MODE_DIRECT;
+    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode           = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_BloodyB820R::~RGBController_BloodyB820R()
+{
+    delete controller;
+}
+
+void RGBController_BloodyB820R::SetupZones()
+{
+    /*-------------------------------------------------*\
+    | Create the Keyboard zone and add the matrix map   |
+    \*-------------------------------------------------*/
+    zone KB_zone;
+    KB_zone.name                = ZONE_EN_KEYBOARD;
+    KB_zone.type                = ZONE_TYPE_MATRIX;
+    KB_zone.leds_min            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_max            = BLOODY_B820R_KEYCOUNT;
+    KB_zone.leds_count          = BLOODY_B820R_KEYCOUNT;
+
+    KB_zone.matrix_map          = new matrix_map_type;
+    KB_zone.matrix_map->height  = 6;
+    KB_zone.matrix_map->width   = 21;
+    KB_zone.matrix_map->map     = (unsigned int *)&matrix_map;
+    zones.push_back(KB_zone);
+
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(unsigned int led_index = 0; led_index < BLOODY_B820R_KEYCOUNT; led_index++)
+    {
+        led new_led;
+        new_led.name        = led_names[led_index];
+        new_led.value       = led_index;
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_BloodyB820R::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+
+void RGBController_BloodyB820R::DeviceUpdateLEDs()
+{
+    controller->SetLEDDirect(colors);
+}
+
+void RGBController_BloodyB820R::UpdateZoneLEDs(int zone)
+{
+    std::vector<RGBColor> colour;
+    for(size_t i = 0; i < zones[zone].leds_count; i++)
+    {
+        colour.push_back(zones[zone].colors[i]);
+    }
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::UpdateSingleLED(int led)
+{
+    std::vector<RGBColor> colour;
+    colour.push_back(colors[led]);
+
+    controller->SetLEDDirect(colour);
+}
+
+void RGBController_BloodyB820R::DeviceUpdateMode()
+{
+    /* This device does not support modes yet */
+}

Controllers/A4TechController/RGBController_BloodyB820R.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------*\
+|  RGBController_BloodyB820R.h                                |
+|                                                                     |
+|  Driver for A4Tech Bloody B820R Keyboard Controller                   |
+|                                                                     |
+|  Mohammed Julfikar Ali Mahbub (o-julfikar)          01 Apr 2024     |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "BloodyB820RController.h"
+#include <vector>
+
+class RGBController_BloodyB820R : public RGBController
+{
+public:
+    RGBController_BloodyB820R(BloodyB820RController* controller_ptr);
+    ~RGBController_BloodyB820R();
+
+    void    SetupZones();
+    void    ResizeZone(int zone, int new_size);
+
+    void    DeviceUpdateLEDs();
+    void    UpdateZoneLEDs(int zone);
+    void    UpdateSingleLED(int led);
+
+    void    DeviceUpdateMode();
+
+private:
+    BloodyB820RController* controller;
+};

Controllers/A4TechController/RGBController_BloodyMouse.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_BloodyMouse.cpp                             |
-|                                                           |
-|   RGBController for A4Tech Bloody Mouse                   |
-|                                                           |
-|   Chris M (Dr_No)                             30 Jun 2022 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.cpp                                        |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
 
 #include "RGBController_BloodyMouse.h"
 
@@ -71,7 +69,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();
@@ -110,9 +107,7 @@ void RGBController_BloodyMouse::SetupZones()
         case BLOODY_W60_PRO_PID:
             layout = w60_pro;
             break;
-        case BLOODY_W70_MAX_PID:
         case BLOODY_W90_MAX_PID:
-        case BLOODY_W90_PRO_PID:
             layout = w90_max;
             break;
         case BLOODY_MP_50RS_PID:
@@ -130,7 +125,7 @@ void RGBController_BloodyMouse::SetupZones()
 
         zone new_zone;
         new_zone.name           = mz.name;
-        new_zone.leds_min       = (unsigned int)mz.zone_leds.size();
+        new_zone.leds_min       = mz.zone_leds.size();
         new_zone.leds_max       = new_zone.leds_min;
         new_zone.leds_count     = new_zone.leds_min;
         new_zone.type           = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;

Controllers/A4TechController/RGBController_BloodyMouse.h

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------*\
+|  RGBController_BloodyMouse.h                                          |
+|                                                                       |
+|  Driver for BloodyMouse USB Controller                                |
+|                                                                       |
+|  Chris M (Dr_No)          30 Jun 2022                                 |
+|                                                                       |
+\*---------------------------------------------------------------------*/
+
+#pragma once
+#include <vector>
+#include "RGBController.h"
+#include "BloodyMouseController.h"
+
+struct mouse_zone
+{
+    std::string             name;
+    std::vector<uint8_t>    zone_leds;
+};
+
+typedef std::vector<mouse_zone> mouse_layout;
+
+class RGBController_BloodyMouse : public RGBController
+{
+public:
+    RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
+    ~RGBController_BloodyMouse();
+
+    void                    SetupZones();
+    void                    ResizeZone(int zone, int new_size);
+
+    void                    DeviceUpdateLEDs();
+    void                    UpdateZoneLEDs(int zone);
+    void                    UpdateSingleLED(int led);
+
+    void                    DeviceUpdateMode();
+
+private:
+    BloodyMouseController*  controller;
+};

Controllers/AMBXController/AMBXController.cpp

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

Controllers/AMBXController/AMBXController.h

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

Controllers/AMBXController/AMBXControllerDetect.cpp

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

Controllers/AMBXController/RGBController_AMBX.cpp

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

Controllers/AMBXController/RGBController_AMBX.h

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

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -1,24 +1,21 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.cpp                              |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Driver for AMD Wraith Prism RGB lighting |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
 
+#include "AMDWraithPrismController.h"
 #include <cstring>
 #include <stdio.h>
 #include <stdlib.h>
-#include "AMDWraithPrismController.h"
-#include "StringUtils.h"
 
 AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
 {
-    dev                         = dev_handle;
-    location                    = path;
+    dev         = dev_handle;
+    location    = path;
 
     current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
     current_fan_speed           = 0xFF;
@@ -56,7 +53,10 @@ std::string AMDWraithPrismController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string AMDWraithPrismController::GetFirmwareVersionString()

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismController.h                                |
-|                                                           |
-|   Driver for AMD Wraith Prism                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Definitions and types for AMD Wraith     |
+|  Prism lighting controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
 
 #include <string>
-#include <hidapi.h>
+#include <hidapi/hidapi.h>
+
 #include "RGBController.h"
 
+#pragma once
+
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
 #define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
 

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -1,28 +1,11 @@
-/*---------------------------------------------------------*\
-| AMDWraithPrismControllerDetect.cpp                        |
-|                                                           |
-|   Detector for AMD Wraith Prism                           |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                06 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
 #include "Detector.h"
 #include "AMDWraithPrismController.h"
+#include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
+#include <hidapi/hidapi.h>
 
-/*---------------------------------------------------------*\
-| AMD Wraith Prism vendor ID                                |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_VID                        0x2516
-
-/*---------------------------------------------------------*\
-| AMD Wraith Prism product ID                               |
-\*---------------------------------------------------------*/
-#define AMD_WRAITH_PRISM_PID                        0x0051
+#define AMD_WRAITH_PRISM_VID 0x2516
+#define AMD_WRAITH_PRISM_PID 0x0051
 
 /******************************************************************************************\
 *                                                                                          *
@@ -35,12 +18,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);
     }
 }

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.cpp                          |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.cpp         |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_AMDWraithPrism.h"
 
@@ -27,14 +25,14 @@
 
 RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* controller_ptr)
 {
-    controller                  = controller_ptr;
+    controller  = controller_ptr;
 
-    name                        = "AMD Wraith Prism";
-    vendor                      = "Cooler Master";
-    type                        = DEVICE_TYPE_COOLER;
-    description                 = "AMD Wraith Prism Device";
-    version                     = controller->GetFirmwareVersionString();
-    location                    = controller->GetLocationString();
+    name        = "AMD Wraith Prism";
+    vendor      = "Cooler Master";
+    type        = DEVICE_TYPE_COOLER;
+    description = "AMD Wraith Prism Device";
+    version     = controller->GetFirmwareVersionString();
+    location    = controller->GetLocationString();
 
     mode Direct;
     Direct.name                 = "Direct";
@@ -140,8 +138,8 @@ void RGBController_AMDWraithPrism::SetupZones()
     /*---------------------------------------------------------*\
     | LED maps                                                  |
     \*---------------------------------------------------------*/
-    const unsigned int logo_leds[1]  =  { 0x00 };
-    const unsigned int fan_leds[1]   =  { 0x01 };
+    const unsigned int logo_leds[1] =   { 0x00 };
+    const unsigned int fan_leds[1] =    { 0x01 };
     const unsigned int ring_leds[14] =  { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
                                           0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
 
@@ -181,24 +179,24 @@ void RGBController_AMDWraithPrism::SetupZones()
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led logo_led;
-        logo_led.name       = "Logo LED";
-        logo_led.value      = logo_leds[led_idx];
+        logo_led.name = "Logo LED";
+        logo_led.value = logo_leds[led_idx];
         leds.push_back(logo_led);
     }
 
     for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
     {
         led fan_led;
-        fan_led.name        = "Fan LED";
-        fan_led.value       = fan_leds[led_idx];
+        fan_led.name = "Fan LED";
+        fan_led.value = fan_leds[led_idx];
         leds.push_back(fan_led);
     }
 
     for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
     {
         led ring_led;
-        ring_led.name       = "Ring LED";
-        ring_led.value      = ring_leds[led_idx];
+        ring_led.name = "Ring LED";
+        ring_led.value = ring_leds[led_idx];
         leds.push_back(ring_led);
     }
 

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.h

@@ -1,16 +1,13 @@
-/*---------------------------------------------------------*\
-| RGBController_AMDWraithPrism.h                            |
-|                                                           |
-|   RGBController for AMD Wraith Prism                      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                25 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.h           |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
 
 #pragma once
-
 #include "RGBController.h"
 #include "AMDWraithPrismController.h"
 

Controllers/AOCKeyboardController/AOCKeyboardController.cpp

@@ -1,27 +1,24 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.cpp                                 |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCKeyboardController.cpp                |
+|                                           |
+|  Driver for AOC Keyboard lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
-#include <chrono>
-#include <cstring>
-#include <thread>
 #include "AOCKeyboardController.h"
-#include "StringUtils.h"
+
+#include <cstring>
+#include <chrono>
+#include <thread>
 
 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 +31,6 @@ std::string AOCKeyboardController::GetDeviceLocation()
     return("HID " + location);
 }
 
-std::string AOCKeyboardController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCKeyboardController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -49,7 +41,10 @@ std::string AOCKeyboardController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 void AOCKeyboardController::SetLightingConfig

Controllers/AOCKeyboardController/AOCKeyboardController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardController.h                                   |
-|                                                           |
-|   Driver for AOC keyboard                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCKeyboardController.h                  |
+|                                           |
+|  Definitions and types for AOC keyboard   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Keyboard Modes                        |
 \*-----------------------------------------*/
@@ -64,11 +62,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 +86,6 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 
     void SendStartPacket();
     void SendEndPacket();

Controllers/AOCKeyboardController/AOCKeyboardControllerDetect.cpp

@@ -1,20 +1,10 @@
-/*---------------------------------------------------------*\
-| AOCKeyboardControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC keyboard                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AOCKeyboardController.h"
+#include "RGBController.h"
 #include "RGBController_AOCKeyboard.h"
 
 /*-----------------------------------------------------*\
-| AOC Keyboard IDs                                      |
+| AOC Mousemat IDs                                      |
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GK500_PID                               0x1178
@@ -34,12 +24,13 @@ 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);
     }
 }
 
 REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID,   0xFF19, 0xFF19);
-REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2, 0xFF19, 0xFF19);
+REGISTER_HID_DETECTOR_PU("AOC GK500",  DetectAOCKeyboardControllers,   AOC_VID,    AOC_GK500_PID_2,   0xFF19, 0xFF19);

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.cpp                             |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCKeyboard.h"
 #include "KeyboardLayoutManager.h"
@@ -35,10 +32,10 @@ layout_values aoc_keyboard_offset_values =
             75,   76,   91,   62,   48,   64,   50,   65,   66,   67,   97,   68,   84,   70,   59,   74,   89,    58,   73,   88,  103,
         /* TAB     Q     W     E     R     T     Y     U     I     O     P     [     ]     \   DEL   END   PGDN   NP7   NP8   NP9   NP+ */
             60,   61,   47,   78,   33,   49,   35,   80,   51,   52,   53,   69,   99,   25,   44,   29,   14,    43,   28,   13,  102,
-        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "     #   ENTR                     NP4   NP5   NP6       */
-            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,    0,   10,                      57,   72,   87,
-        /* LSFT    \     Z     X     C     V     B     N     M     ,     .     /   RSFT             ARWU          NP1   NP2   NP3  NPEN */
-            30,    0,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,               11,          42,   27,   12,  101,
+        /* CPLK    A     S     D     F     G     H     J     K     L     ;     "   ENTR                           NP4   NP5   NP6       */
+            45,   46,   32,   93,   18,   34,   20,   95,   36,   37,   38,   54,   10,                            57,   72,   87,
+        /* LSFT    Z     X     C     V     B     N     M     ,     .     /   RSFT                   ARWU          NP1   NP2   NP3  NPEN */
+            30,   31,   17,    2,    3,   19,    5,    6,   21,   22,   23,   39,                     11,          42,   27,   12,  101,
         /* LCTL  LWIN  LALT               SPC              RALT  RFNC  RMNU  RCTL              ARWL ARWD   ARWR   NP0         NP.       */
             15,    0,    1,                4,                7,    8,   24,    9,               26,   41,   56,    71,         86
     },
@@ -50,14 +47,14 @@ layout_values aoc_keyboard_offset_values =
 
 RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_KEYBOARD;
-    description                     = "AOC Keyboard Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Keyboard Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "AOC Keyboard Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Static;
     Static.name                     = "Static";
@@ -291,7 +288,7 @@ void RGBController_AOCKeyboard::SetupZones()
     | Create LEDs for the Matrix zone                           |
     |   Place keys in the layout to populate the matrix         |
     \*---------------------------------------------------------*/
-    for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
+    for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
     {
         led new_led;
 
@@ -302,6 +299,8 @@ void RGBController_AOCKeyboard::SetupZones()
 
     zones.push_back(new_zone);
 
+
+
     SetupColors();
 }
 

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCKeyboard.h                               |
-|                                                           |
-|   RGBController for AOC keyboard                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                10 May 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCKeyboard.h              |
+|                                           |
+|  Generic RGB Interface for AOC keyboard   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/10/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AOCMouseController/AOCMouseController.cpp

@@ -1,23 +1,19 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.cpp                                    |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMouseController.cpp                   |
+|                                           |
+|  Driver for AOC Mouse lighting controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMouseController.h"
 
 #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 +26,6 @@ std::string AOCMouseController::GetDeviceLocation()
     return("HID " + location);
 }
 
-std::string AOCMouseController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCMouseController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -45,7 +36,10 @@ std::string AOCMouseController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 /*-------------------------------------------------------------------------------------------------*\

Controllers/AOCMouseController/AOCMouseController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCMouseController.h                                      |
-|                                                           |
-|   Driver for AOC mouse                                    |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMouseController.h                     |
+|                                           |
+|  Definitions and types for AOC mouse      |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |
@@ -56,11 +54,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 +77,4 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 };

Controllers/AOCMouseController/AOCMouseControllerDetect.cpp

@@ -1,20 +1,10 @@
-/*---------------------------------------------------------*\
-| AOCMouseControllerDetect.cpp                              |
-|                                                           |
-|   Detector for AOC mouse                                  |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AOCMouseController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMouse.h"
 
 /*-----------------------------------------------------*\
-| AOC Mouse IDs                                         |
+| AOC Mousemat IDs                                      |
 \*-----------------------------------------------------*/
 #define AOC_VID                                     0x3938
 #define AOC_GM500_PID                               0x1179
@@ -33,8 +23,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);
     }

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.cpp                                |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.cpp               |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCMouse.h"
 
@@ -24,14 +21,14 @@
 
 RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_MOUSE;
-    description                     = "AOC Mouse Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Mouse Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "AOC Mouse Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";

Controllers/AOCMouseController/RGBController_AOCMouse.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMouse.h                                  |
-|                                                           |
-|   RGBController for AOC mouse                             |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                20 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMouse.h                 |
+|                                           |
+|  Generic RGB Interface for AOC mouse      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/20/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/AOCMousematController/AOCMousematController.cpp

@@ -1,23 +1,20 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.cpp                                 |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMousematController.cpp                |
+|                                           |
+|  Driver for AOC Mousemat lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "AOCMousematController.h"
 
 #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 +27,6 @@ std::string AOCMousematController::GetDeviceLocation()
     return("HID " + location);
 }
 
-std::string AOCMousematController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AOCMousematController::GetSerialString()
 {
     wchar_t serial_string[128];
@@ -45,7 +37,10 @@ std::string AOCMousematController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 /*-------------------------------------------------------------------------------------------------*\

Controllers/AOCMousematController/AOCMousematController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AOCMousematController.h                                   |
-|                                                           |
-|   Driver for AOC mousemat                                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AOCMousematController.h                  |
+|                                           |
+|  Definitions and types for AOC mousemat   |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*-----------------------------------------*\
 | AOC Mousemat Modes                        |
 |   Note: The 0x80 bit is the random flag   |
@@ -55,11 +53,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 +76,4 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 };

Controllers/AOCMousematController/AOCMousematControllerDetect.cpp

@@ -1,16 +1,6 @@
-/*---------------------------------------------------------*\
-| AOCMousematControllerDetect.cpp                           |
-|                                                           |
-|   Detector for AOC mousemat                               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AOCMousematController.h"
+#include "RGBController.h"
 #include "RGBController_AOCMousemat.h"
 
 /*-----------------------------------------------------*\
@@ -33,11 +23,12 @@ 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);
     }
 }
 
-REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);
+REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700",    DetectAOCMousematControllers,   AOC_VID,    AOC_AMM700_PID, 1,  0xFF19,  0xFF19);

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.cpp                             |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.cpp            |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
 
 #include "RGBController_AOCMousemat.h"
 
@@ -24,14 +21,14 @@
 
 RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
 {
-    controller                      = controller_ptr;
+    controller  = controller_ptr;
 
-    name                            = controller->GetDeviceName();
-    vendor                          = "AOC";
-    type                            = DEVICE_TYPE_MOUSEMAT;
-    description                     = "AOC Mousemat Device";
-    location                        = controller->GetDeviceLocation();
-    serial                          = controller->GetSerialString();
+    name        = "AOC Mousemat Device";
+    vendor      = "AOC";
+    type        = DEVICE_TYPE_MOUSEMAT;
+    description = "AOC Mousemat Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
 
     mode Direct;
     Direct.name                     = "Direct";

Controllers/AOCMousematController/RGBController_AOCMousemat.h

@@ -1,13 +1,10 @@
-/*---------------------------------------------------------*\
-| RGBController_AOCMousemat.h                               |
-|                                                           |
-|   RGBController for AOC mousemat                          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Apr 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AOCMousemat.h              |
+|                                           |
+|  Generic RGB Interface for AOC mousemat   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/15/2023   |
+\*-----------------------------------------*/
 
 #pragma once
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -1,22 +1,20 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.cpp                         |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.cpp        |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 #include <cstring>
+#include <stdio.h>
+
 #include "RGBController.h"
 #include "ResourceManager.h"
 #include "SettingsManager.h"
-#include "StringUtils.h"
 #include "ASRockPolychromeUSBController.h"
-#include "dmiinfo.h"
+#include "dependencies/dmiinfo.h"
 
 #define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
 #define POLYCHROME_USB_READ_HEADER      0x14
@@ -57,7 +55,7 @@ PolychromeUSBController::~PolychromeUSBController()
 
 unsigned int PolychromeUSBController::GetChannelCount()
 {
-    return((unsigned int)device_info.size());
+    return(device_info.size());
 }
 
 std::string PolychromeUSBController::GetDeviceLocation()
@@ -80,7 +78,10 @@ std::string PolychromeUSBController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 void PolychromeUSBController::SetDeviceInfo()
@@ -380,7 +381,7 @@ void PolychromeUSBController::WriteRGSwap
     bool chnl8
     )
 {
-    unsigned char rgconfig[1] = {static_cast<unsigned char>((((unsigned char)chnl8 << 7) | ((unsigned char)pcb << 6) | ((unsigned char)io << 5) | ((unsigned char)pch << 4) | ((unsigned char)ahdr1 << 3) | ((unsigned char)ahdr0 << 2) | ((unsigned char)hdr1 << 1) | (unsigned char)hdr0))};
+    unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
     WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -1,21 +1,19 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBController.h                           |
-|                                                           |
-|   Driver for ASRock Polychrome USB motherboards           |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeUSBController.h          |
+|                                           |
+|  Driver for ASRock Polychrome USB         |
+|  lighting controller                      |
+|                                           |
+|  Ed Kambulow (dredvard) 12/20/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Polychrome USB                                                                 |
 \*----------------------------------------------------------------------------------------------*/
@@ -156,11 +154,12 @@ protected:
         );
 
 private:
+    unsigned int  led_count;
     std::string   device_name;
     unsigned char configtable[12];
     bool          rgswapconfig[8] = { 0 };
 
-    void SetDeviceInfo();
+    void SetDeviceInfo();    
     void ReadConfigTables();
     void Commit();
 };

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp

@@ -1,19 +1,13 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeUSBControllerDetect.cpp                   |
-|                                                           |
-|   Detector for ASRock Polychrome USB motherboards         |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <hidapi.h>
 #include "Detector.h"
 #include "ASRockPolychromeUSBController.h"
+#include "RGBController.h"
 #include "RGBController_ASRockPolychromeUSB.h"
+#include "i2c_smbus.h"
+#include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <hidapi/hidapi.h>
 
 /*---------------------------------------------------------*\
 | ASRock vendor ID                                          |
@@ -38,5 +32,5 @@ void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*
     }
 }
 
-REGISTER_HID_DETECTOR("ASRock Polychrome USB",                  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip",  DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
+REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
+REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.cpp                     |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.cpp    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 
-#include <string.h>
 #include "RGBController_ASRockPolychromeUSB.h"
+#include <string.h>
 
 #define ASROCK_USB_MAX_ZONES        8
 #define ASROCK_ADDRESSABLE_MAX_LEDS 100
@@ -295,7 +293,7 @@ void RGBController_PolychromeUSB::DeviceUpdateLEDs()
             set_mode = active_mode;
         }
 
-        controller->WriteZone((unsigned char)zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
+        controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
     }
 }
 

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -1,14 +1,12 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeUSB.h                       |
-|                                                           |
-|   RGBController for ASRock Polychrome USB motherboards    |
-|                                                           |
-|   Ed Kambulow (dredvard)                      20 Dec 2020 |
-|   Shady Nawara (ShadyNawara)                  16 Jan 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeUSB.h      |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock Polychrome USB Driver             |
+|                                           |
+|  Ed Kambulow (Dredvard) 12/26/2020        |
+|  Shady Nawara (ShadyNawara) 01/16/2023    |
+\*-----------------------------------------*/
 
 #pragma once
 
@@ -31,6 +29,7 @@ public:
     void        DeviceUpdateMode();
 
 private:
+    bool                            initializedMode;
     PolychromeUSBController*        controller;
     std::vector<PolychromeZoneInfo> zones_info;
 

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.cpp                           |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.cpp      |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
 #include "ASRockASRRGBSMBusController.h"
 #include <cstring>
-#include "dmiinfo.h"
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
@@ -66,7 +64,7 @@ void ASRockASRRGBSMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, ui
 {
     uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
     uint8_t select_led_pkt[1]  = { led };
-
+    
     /*-----------------------------------------------------*\
     | Select LED                                            |
     \*-----------------------------------------------------*/

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockASRRGBSMBusController.h                             |
-|                                                           |
-|   Driver for SMBus ASRock ASR RGB motherboards            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockASRRGBSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>
 
 #pragma once
 
-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t	polychrome_dev_id;
 
 #define ASROCK_ASR_CONTROLLER_NAME  "ASRock ASR RGB SMBus Controller"
@@ -64,7 +63,7 @@ public:
     uint8_t                 GetMode();
     void                    SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
     void                    SetMode(uint8_t zone, uint8_t mode, uint8_t speed);
-
+    
     uint16_t                fw_version;
 
 private:

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -1,35 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.h                               |
-|                                                           |
-|   RGBController for SMBus ASRock ASR RGB motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockASRRGBSMBusController.h"
-
-class RGBController_ASRockASRRGBSMBus : public RGBController
-{
-public:
-    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
-    ~RGBController_ASRockASRRGBSMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockASRRGBSMBusController* controller;
-};

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "ASRockPolychromeV1SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV1SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V1 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV1SMBusController.h      |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
 
-#pragma once
-
-#include <string>
 #include "i2c_smbus.h"
 #include "RGBController.h"
+#include <string>
+
+#pragma once
 
 typedef uint8_t	polychrome_dev_id;
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV1SMBusController.h"
-
-class RGBController_ASRockPolychromeV1SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV1SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV1SMBusController* controller;
-    uint8_t                 getModeIndex(uint8_t mode_value);
-    std::vector<uint8_t>    zoneIndexMap;
-};

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.cpp                     |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeV2SMBusController.cpp    |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "ASRockPolychromeV2SMBusController.h"
-#include "dmiinfo.h"
+#include <cstring>
+#include "dependencies/dmiinfo.h"
 #include "LogManager.h"
 
 #define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| ASRockPolychromeV2SMBusController.h                       |
-|                                                           |
-|   Driver for SMBus ASRock Polychrome V2 motherboards      |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                13 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  ASRockPolychromeSMBusController.h        |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+#include <string>
 
 #pragma once
 
-#include <string>
-#include "i2c_smbus.h"
-
 typedef uint8_t polychrome_dev_id;
 
 #define ASROCK_V2_CONTROLLER_NAME  "ASRock Polychrome v2 SMBus Controller"
@@ -133,7 +132,7 @@ public:
 
     uint8_t                 zone_led_count[6];
     uint16_t                fw_version;
-
+    
 private:
     std::string             device_name;
     uint8_t                 active_zone;

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -1,36 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.h                   |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeV2SMBusController.h"
-
-class RGBController_ASRockPolychromeV2SMBus : public RGBController
-{
-public:
-    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
-    ~RGBController_ASRockPolychromeV2SMBus();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    ASRockPolychromeV2SMBusController* controller;
-};

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -1,26 +1,17 @@
-/*---------------------------------------------------------*\
-| ASRockSMBusControllerDetect.cpp                           |
-|                                                           |
-|   Detector for SMBus ASRock ASR RGB and Polychrome        |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                14 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#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"
 #include "i2c_smbus.h"
 #include "pci_ids.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
 
 /*******************************************************************************************\
 *                                                                                           *

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -1,13 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRRGBSMBus.cpp                             |
-|                                                           |
-|   RGBController for SMBus ASRock ASR LED motherboards     |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_ASRockASRRGBSMBus.h"
 
@@ -169,7 +167,7 @@ void RGBController_ASRockASRRGBSMBus::ResizeZone(int /*zone*/, int /*new_size*/)
 
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
         UpdateSingleLED(led);
     }

Controllers/ASRockSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.h    |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockASRRGBSMBusController.h"
+
+class RGBController_ASRockASRRGBSMBus : public RGBController
+{
+public:
+    RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMBusController* controller_ptr);
+    ~RGBController_ASRockASRRGBSMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockASRRGBSMBusController* controller;
+};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV1SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V1            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeSMBus.cpp  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "LogManager.h"
 #include "RGBController_ASRockPolychromeV1SMBus.h"

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -0,0 +1,35 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV1SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV1SMBusController.h"
+
+class RGBController_ASRockPolychromeV1SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV1SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV1SMBusController* controller;
+    uint8_t                 getModeIndex(uint8_t mode_value);
+    std::vector<uint8_t>    zoneIndexMap;
+};

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -1,14 +1,11 @@
-/*---------------------------------------------------------*\
-| RGBController_ASRockPolychromeV2SMBus.cpp                 |
-|                                                           |
-|   RGBController for SMBus ASRock Polychrome V2            |
-|   motherboards                                            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                15 Dec 2019 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromeV2SMBus.cpp|
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
 
 #include "RGBController_ASRockPolychromeV2SMBus.h"
 
@@ -290,7 +287,7 @@ void RGBController_ASRockPolychromeV2SMBus::ResizeZone(int /*zone*/, int /*new_s
 
 void RGBController_ASRockPolychromeV2SMBus::DeviceUpdateLEDs()
 {
-    for(unsigned int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
         UpdateSingleLED(led);
     }

Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_ASRockPolychromev2SMBus.h  |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "ASRockPolychromeV2SMBusController.h"
+
+class RGBController_ASRockPolychromeV2SMBus : public RGBController
+{
+public:
+    RGBController_ASRockPolychromeV2SMBus(ASRockPolychromeV2SMBusController* controller_ptr);
+    ~RGBController_ASRockPolychromeV2SMBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    ASRockPolychromeV2SMBusController* controller;
+};

Controllers/AlienwareController/AlienwareController.cpp

@@ -1,14 +1,13 @@
-/*---------------------------------------------------------*\
-| AlienwareController.cpp                                   |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 21 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.cpp                  |
+|                                           |
+|  Driver for Alienware lighting controller |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/21/2021    |
+\*-----------------------------------------*/
 
+#include "RGBController.h"
+#include "AlienwareController.h"
 #include <cstring>
 #include <cstdint>
 #include <map>
@@ -16,10 +15,7 @@
 #include <chrono>
 #include <algorithm>
 #include <sstream>
-#include "RGBController.h"
-#include "AlienwareController.h"
 #include "LogManager.h"
-#include "StringUtils.h"
 
 typedef uint32_t alienware_platform_id;
 
@@ -31,8 +27,7 @@ static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
 {
     { 0x0C01,   4 },    // Dell G5 SE 5505
     { 0x0A01,  16 },    // Dell G7 15 7500
-    { 0x0E03,   4 },    // Dell G15   5511
-    { 0x0E0A,   4 }     // Dell G15   5530
+    { 0x0E03,   4 }     // Dell G15   5511
 
 };
 
@@ -48,8 +43,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
                   "Light Bar 4",    "Light Bar 5",  "Light Bar 6",
                   "Light Bar 7",    "Light Bar 8",  "Light Bar 9",
                   "Light Bar 10",   "Light Bar 11", "Light Bar 12"              } },
-    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } },
-    { 0x0E0A,   { "Left",           "Middle",       "Right",        "Numpad"    } }
+    { 0x0E03,   { "Left",           "Middle",       "Right",        "Numpad"    } }
 };
 
 static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
@@ -90,7 +84,9 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
     /*-----------------------------------------------------*\
     | Get serial number                                     |
     \*-----------------------------------------------------*/
-    serial_number       = StringUtils::wstring_to_string(info.serial_number);
+    std::wstring tmp_serial_number;
+    tmp_serial_number   = info.serial_number;
+    serial_number       = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
 
     /*-----------------------------------------------------*\
     | Get zone information by checking firmware             |
@@ -99,11 +95,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 +105,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                            |
     \*-----------------------------------------------------*/
@@ -171,7 +167,7 @@ AlienwareController::~AlienwareController()
 
 unsigned int AlienwareController::GetZoneCount()
 {
-    return((unsigned int)zones.size());
+    return(zones.size());
 }
 
 std::vector<const char*> AlienwareController::GetZoneNames()
@@ -276,7 +272,7 @@ bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -380,7 +376,7 @@ bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones  = (uint16_t)zones.size();
+    uint16_t num_zones  = zones.size();
 
     usb_buf[0x00]       = 0x00;
     usb_buf[0x01]       = 0x03;
@@ -519,7 +515,7 @@ bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zo
     /*-----------------------------------------------------*\
     | Set up message packet with leading 00, per hidapi     |
     \*-----------------------------------------------------*/
-    uint16_t num_zones      = (uint16_t)zones.size();
+    uint16_t num_zones      = zones.size();
 
     usb_buf[0x00]           = 0x00;
     usb_buf[0x01]           = 0x03;
@@ -655,7 +651,7 @@ void AlienwareController::UpdateDim()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        dim_zone_map[zones[i].dim].emplace_back((uint8_t)i);
+        dim_zone_map[zones[i].dim].emplace_back(i);
     }
 
     for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
@@ -682,7 +678,7 @@ bool AlienwareController::UpdateDirect()
 
     for(size_t i = 0; i < zones.size(); i++)
     {
-        color_zone_map[zones[i].color[0]].emplace_back((uint8_t)i);
+        color_zone_map[zones[i].color[0]].emplace_back(i);
     }
 
     for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)

Controllers/AlienwareController/AlienwareController.h

@@ -1,20 +1,18 @@
-/*---------------------------------------------------------*\
-| AlienwareController.h                                     |
-|                                                           |
-|   Driver for Dell Alienware RGB USB controller            |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareController.h                    |
+|                                           |
+|  Driver for Dell Alienware RGB USB        |
+|  controller                               |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <hidapi/hidapi.h>
+#include <string>
 
 #pragma once
 
-#include <string>
-#include <hidapi.h>
-#include "RGBController.h"
-
 /*----------------------------------------------------------------------------------------------*\
 | Definitions for Alienware Controller                                                           |
 \*----------------------------------------------------------------------------------------------*/

Controllers/AlienwareController/AlienwareControllerDetect.cpp

@@ -1,14 +1,6 @@
-/*---------------------------------------------------------*\
-| AlienwareControllerDetect.cpp                             |
-|                                                           |
-|   Detector for Dell Alienware RGB USB controller          |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
 #include "Detector.h"
 #include "AlienwareController.h"
+#include "RGBController.h"
 #include "RGBController_Alienware.h"
 
 /*---------------------------------------------------------*\
@@ -19,8 +11,7 @@
 /*---------------------------------------------------------*\
 | Alienware product ID                                      |
 \*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID1                      0x0550
-#define ALIENWARE_G_SERIES_PID2                      0x0551
+#define ALIENWARE_G_SERIES_PID                         0x0550
 
 void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
 {
@@ -35,5 +26,4 @@ void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
     }
 }
 
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID1);
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID2);
+REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -1,17 +1,16 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.cpp                               |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware USB Driver                     |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
+
+#include "RGBController_Alienware.h"
 
 #include <thread>
 #include <chrono>
-#include "RGBController_Alienware.h"
 
 /**------------------------------------------------------------------*\
     @name Alienware
@@ -214,7 +213,7 @@ void RGBController_Alienware::DeviceUpdateMode()
         /*-----------------------------------------------------*\
         | Setup state per zone                                  |
         \*-----------------------------------------------------*/
-        for(uint8_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
         {
             zone current_zone = zones[zone_idx];
 

Controllers/AlienwareController/RGBController_Alienware.h

@@ -1,20 +1,19 @@
-/*---------------------------------------------------------*\
-| RGBController_Alienware.h                                 |
-|                                                           |
-|   RGBController for Dell Alienware RGB USB controller     |
-|                                                           |
-|   Gabriel Marcano (gemarcano)                 19 Apr 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_Alienware.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Alienware RGB USB Driver                 |
+|                                           |
+|  Gabriel Marcano (gemarcano) 4/19/2021    |
+\*-----------------------------------------*/
 
 #pragma once
 
-#include <chrono>
 #include "RGBController.h"
 #include "AlienwareController.h"
 
+#include <chrono>
+
 class RGBController_Alienware : public RGBController
 {
 public:

Controllers/AlienwareKeyboardController/AlienwareAW410KController.cpp

@@ -1,24 +1,21 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.cpp                         |
+|                                                        |
+|  Driver for Alienware AW410K                           |
+|  keyboard light controller                             |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
 
-#include <cstring>
 #include "AlienwareAW410KController.h"
-#include "StringUtils.h"
+#include <cstring>
 
-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,27 +30,24 @@ std::string AlienwareAW410KController::GetDeviceLocation()
     return("HID: " + location);
 }
 
-std::string AlienwareAW410KController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AlienwareAW410KController::GetSerialString()
 {
     wchar_t serial_string[128];
     int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
     if(ret != 0)
     {
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 void AlienwareAW410KController::SendCommit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -75,7 +69,7 @@ void AlienwareAW410KController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -83,6 +77,7 @@ void AlienwareAW410KController::SendCommit()
     std::this_thread::sleep_for(std::chrono::milliseconds(20));
 }
 
+
 void AlienwareAW410KController::SendfeatureReport
     (
     unsigned char   first_byte,
@@ -91,7 +86,7 @@ void AlienwareAW410KController::SendfeatureReport
     unsigned char   forth_byte
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -110,7 +105,7 @@ void AlienwareAW410KController::SendfeatureReport
     /*-----------------------------------------------------*\
     | Send Feature report packet                            |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 10 milliseconds                                 |
@@ -120,7 +115,7 @@ void AlienwareAW410KController::SendfeatureReport
 
 void AlienwareAW410KController::SendEdit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -138,7 +133,7 @@ void AlienwareAW410KController::SendEdit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -148,7 +143,7 @@ void AlienwareAW410KController::SendEdit()
 
 void AlienwareAW410KController::SendInitialize()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -173,7 +168,7 @@ void AlienwareAW410KController::SendInitialize()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -227,7 +222,7 @@ void AlienwareAW410KController::SendDirectOn
     std::vector<SelectedButtons>     &frame_data
     )
 {
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
 
     /*-----------------------------------------------*\
     | To Guarantee the data are always %4 =0 append   |
@@ -307,7 +302,7 @@ void AlienwareAW410KController::SendDirectOn
 void AlienwareAW410KController::SetMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -329,7 +324,7 @@ void AlienwareAW410KController::UpdateSingleLED
 {
     SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
 
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -359,7 +354,7 @@ void AlienwareAW410KController::UpdateSingleLED
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -371,7 +366,7 @@ void AlienwareAW410KController::SendMode
     (
     unsigned char   /*zone*/,
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -379,7 +374,7 @@ void AlienwareAW410KController::SendMode
     unsigned char   blue
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -405,13 +400,13 @@ void AlienwareAW410KController::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void AlienwareAW410KController::SetMorphMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   red1,
     unsigned char   green1,
     unsigned char   blue1,
@@ -420,7 +415,7 @@ void AlienwareAW410KController::SetMorphMode
     unsigned char   blue2
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -449,5 +444,5 @@ void AlienwareAW410KController::SetMorphMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }

Controllers/AlienwareKeyboardController/AlienwareAW410KController.h

@@ -1,20 +1,20 @@
-/*---------------------------------------------------------*\
-| AlienwareAW410KController.h                               |
-|                                                           |
-|   Driver for Alienware AW410K keyboard                    |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*------------------------------------------------------*\
+|  AlienwareAW410KController.h                           |
+|                                                        |
+|  Definitions and types for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
 
-#pragma once
+#include "RGBController.h"
 
 #include <string>
-#include <hidapi.h>
-#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
 
 enum
 {
@@ -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();
@@ -110,7 +109,7 @@ public:
     void        SetMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,
@@ -121,7 +120,7 @@ public:
     void        SetMorphMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   red1,
                     unsigned char   green1,
                     unsigned char   blue1,
@@ -141,13 +140,12 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 
     void        SendMode
                     (
                     unsigned char   zone,
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.h

@@ -1,37 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW410K.h                           |
-|                                                           |
-|   RGBController for Alienware AW410K keyboard             |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW410KController.h"
-
-class RGBController_AlienwareAW410K : public RGBController
-{
-public:
-    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
-    ~RGBController_AlienwareAW410K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW410KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};

Controllers/AlienwareKeyboardController/AlienwareAW510KController.cpp

@@ -1,23 +1,19 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.cpp                             |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.cpp            |
+|                                           |
+|  Driver for Alienware AW510K              |
+|  keyboard light controller                |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#include <cstring>
 #include "AlienwareAW510KController.h"
-#include "StringUtils.h"
+#include <cstring>
 
-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,27 +28,20 @@ std::string AlienwareAW510KController::GetDeviceLocation()
     return("HID: " + location);
 }
 
-std::string AlienwareAW510KController::GetDeviceName()
-{
-    return(name);
-}
-
 std::string AlienwareAW510KController::GetSerialString()
 {
     wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+    hid_get_serial_number_string(dev, serial_string, 128);
 
-    if(ret != 0)
-    {
-        return("");
-    }
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
 
-    return(StringUtils::wstring_to_string(serial_string));
+    return(return_string);
 }
 
 void AlienwareAW510KController::SendCommit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -74,7 +63,7 @@ void AlienwareAW510KController::SendCommit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -82,6 +71,7 @@ void AlienwareAW510KController::SendCommit()
     std::this_thread::sleep_for(std::chrono::milliseconds(20));
 }
 
+
 void AlienwareAW510KController::SendfeatureReport
     (
     unsigned char   first_byte,
@@ -90,7 +80,7 @@ void AlienwareAW510KController::SendfeatureReport
     unsigned char   forth_byte
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -109,7 +99,7 @@ void AlienwareAW510KController::SendfeatureReport
     /*-----------------------------------------------------*\
     | Send Feature report packet                            |
     \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, 65);
+    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 10 milliseconds                                 |
@@ -119,7 +109,7 @@ void AlienwareAW510KController::SendfeatureReport
 
 void AlienwareAW510KController::SendEdit()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -137,7 +127,7 @@ void AlienwareAW510KController::SendEdit()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -147,7 +137,7 @@ void AlienwareAW510KController::SendEdit()
 
 void AlienwareAW510KController::SendInitialize()
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -172,7 +162,7 @@ void AlienwareAW510KController::SendInitialize()
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 2 milliseconds                                  |
@@ -226,7 +216,7 @@ void AlienwareAW510KController::SendDirectOn
     std::vector<SelectedKeys>     &frame_data
     )
 {
-    SendfeatureReport(0x0E, (unsigned char)frame_data.size(), 0x00, 0x01);
+    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
 
     /*-----------------------------------------------*\
     | To Guarantee the data are always %4 =0 append   |
@@ -306,7 +296,7 @@ void AlienwareAW510KController::SendDirectOn
 void AlienwareAW510KController::SetMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -328,7 +318,7 @@ void AlienwareAW510KController::UpdateSingleLED
 {
     SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
 
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -358,7 +348,7 @@ void AlienwareAW510KController::UpdateSingleLED
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 
     /*-----------------------------------------------------*\
     | Delay 20 milliseconds                                 |
@@ -370,7 +360,7 @@ void AlienwareAW510KController::SendMode
     (
     unsigned char   /*zone*/,
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   direction,
     unsigned char   colorMode,
     unsigned char   red,
@@ -378,7 +368,7 @@ void AlienwareAW510KController::SendMode
     unsigned char   blue
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -404,13 +394,13 @@ void AlienwareAW510KController::SendMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }
 
 void AlienwareAW510KController::SetMorphMode
     (
     unsigned char   mode,
-    unsigned char   speed,
+    unsigned short  speed,
     unsigned char   red1,
     unsigned char   green1,
     unsigned char   blue1,
@@ -419,7 +409,7 @@ void AlienwareAW510KController::SetMorphMode
     unsigned char   blue2
     )
 {
-    unsigned char usb_buf[65];
+    char usb_buf[65];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -448,5 +438,5 @@ void AlienwareAW510KController::SetMorphMode
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
+    hid_write(dev, (unsigned char *)usb_buf, 65);
 }

Controllers/AlienwareKeyboardController/AlienwareAW510KController.h

@@ -1,19 +1,18 @@
-/*---------------------------------------------------------*\
-| AlienwareAW510KController.h                               |
-|                                                           |
-|   Driver for Alienware AW510K keyboard                    |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  AlienwareAW510KController.h              |
+|                                           |
+|  Definitions and types for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#pragma once
+#include "RGBController.h"
 
 #include <string>
-#include <hidapi.h>
-#include "RGBController.h"
+#include <hidapi/hidapi.h>
+
+#pragma once
 
 enum
 {
@@ -77,11 +76,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();
@@ -112,7 +110,7 @@ public:
     void        SetMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,
@@ -123,7 +121,7 @@ public:
     void        SetMorphMode
                     (
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   red1,
                     unsigned char   green1,
                     unsigned char   blue1,
@@ -143,13 +141,12 @@ public:
 private:
     hid_device*             dev;
     std::string             location;
-    std::string             name;
 
     void        SendMode
                     (
                     unsigned char   zone,
                     unsigned char   mode,
-                    unsigned char   speed,
+                    unsigned short  speed,
                     unsigned char   direction,
                     unsigned char   colorMode,
                     unsigned char   red,

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.h

@@ -1,36 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.h                           |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareAW510KController.h"
-
-class RGBController_AlienwareAW510K : public RGBController
-{
-public:
-    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
-    ~RGBController_AlienwareAW510K();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW510KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};

Controllers/AlienwareKeyboardController/AlienwareKeyboardControllerDetect.cpp

@@ -1,29 +1,21 @@
-/*---------------------------------------------------------*\
-| AlienwareKeyboardControllerDetect.cpp                     |
-|                                                           |
-|   Detector for Alienware Keyboard                         |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   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"
+#include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
 | Alienware vendor ID                                   |
 \*-----------------------------------------------------*/
-#define ALIENWARE_VID                           0x04F2
+#define ALIENWARE_VID           0x04F2
 
 /*-----------------------------------------------------*\
 | Keyboard product IDs                                  |
 \*-----------------------------------------------------*/
-#define ALIENWARE_AW510K_PID                    0x1830
-#define ALIENWARE_AW410K_PID                    0x1968
+#define ALIENWARE_AW510K_PID    0x1830
+#define ALIENWARE_AW410K_PID    0x1968
 
 /******************************************************************************************\
 *                                                                                          *
@@ -38,9 +30,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 +42,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() */

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.cpp

@@ -1,18 +1,17 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW410K.cpp                         |
-|                                                           |
-|   RGBController for Alienware AW410K keyboard             |
-|                                                           |
-|   based on AW510K controller by Mohamad Sallal (msallal)  |
-|   Dominik Mikolajczyk (dmiko)                 23 Oct 2023 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.cpp                     |
+|                                                        |
+|  Generic RGB Interface for alienware                   |
+|  AW410K Keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
 
-#include <iterator>
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AlienwareAW410K.h"
+#include <iterator>
 
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
@@ -176,7 +175,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";
@@ -411,7 +410,7 @@ void RGBController_AlienwareAW410K::DeviceUpdateMode()
             | Load LEDs again in case of profile load etc.                  |
             \*-------------------------------------------------------------*/
             DeviceUpdateLEDs();
-            break;
+            break;  
         case ALIENWARE_AW410K_MODE_MORPH:
             /*-------------------------------------------------------------*\
             | In case of morph it requires two colors (color1 and color2)   |

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW410K.h

@@ -0,0 +1,36 @@
+/*------------------------------------------------------*\
+|  RGBController_AlienwareAW410K.h                       |
+|                                                        |
+|  Generic RGB Interface for Alienware                   |
+|  AW410K keyboard                                       |
+|                                                        |
+|  based on AW510K controller by Mohamad Sallal - msallal|
+|                                                        |
+|  Dominik Mikolajczyk - dmiko 23/10/2023                |
+\*------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW410KController.h"
+
+class RGBController_AlienwareAW410K : public RGBController
+{
+public:
+    RGBController_AlienwareAW410K(AlienwareAW410KController* controller_ptr);
+    ~RGBController_AlienwareAW410K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW410KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp

@@ -1,17 +1,15 @@
-/*---------------------------------------------------------*\
-| RGBController_AlienwareAW510K.cpp                         |
-|                                                           |
-|   RGBController for Alienware AW510K keyboard             |
-|                                                           |
-|   Mohamad Sallal (msallal)                    22 May 2021 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.cpp        |
+|                                           |
+|  Generic RGB Interface for alienware      |
+|  AW510K Keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
 
-#include <iterator>
 #include "RGBControllerKeyNames.h"
 #include "RGBController_AlienwareAW510K.h"
+#include <iterator>
 
 //0xFFFFFFFF indicates an unused entry in matrix
 #define NA  0xFFFFFFFF
@@ -175,7 +173,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";

Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_AlienwareAW510K.h          |
+|                                           |
+|  Generic RGB Interface for Alienware      |
+|  AW510K keyboard                          |
+|                                           |
+|  Mohamad Sallal - msallal      05/22/2021 |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AlienwareAW510KController.h"
+
+class RGBController_AlienwareAW510K : public RGBController
+{
+public:
+    RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr);
+    ~RGBController_AlienwareAW510K();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AlienwareAW510KController*  controller;
+    std::vector<RGBColor>       current_colors;
+};

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController.cpp

@@ -1,183 +0,0 @@
-/*---------------------------------------------------------*\
-| AlienwareAW3423DWFController.cpp                          |
-|                                                           |
-|   Driver for the Alienware AW3423DWF monitor              |
-|                                                           |
-|   Ferréol DUBOIS COLI (Fefe_du_973)           23 Jan 2025 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <bitset>
-#include <chrono>
-#include <cstring>
-#include <thread>
-
-#include "AlienwareAW3423DWFController.h"
-#include "StringUtils.h"
-
-AlienwareAW3423DWFController::AlienwareAW3423DWFController(hid_device *dev_handle, const char *path) : dev(dev_handle), location(path){}
-
-void AlienwareAW3423DWFController::SendControlPacket(const unsigned char *data, size_t length)
-{
-    unsigned char buffer[256] = {0x00};
-    memcpy(buffer + 1, data, length);
-
-    hid_write(dev, buffer, length + 1);
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GetReportResponse()
-{
-    uint8_t buffer[193];
-
-    memset(buffer, 0, 193);
-
-    hid_get_input_report(dev, buffer, 193);
-
-    return std::vector<unsigned char>(buffer + 1, buffer + 18);
-}
-
-void AlienwareAW3423DWFController::PerformLogin()
-{
-    unsigned char init_packet[64] =
-    {
-        0x40, 0xE1, 0x01
-    };
-    SendControlPacket(init_packet, 4);
-
-    std::vector<unsigned char> response = GetReportResponse();
-
-    std::vector<unsigned char> key = GenerateKey(response);
-
-    unsigned char login_packet[192] = {0x00};
-    login_packet[0] = 0x40;
-    login_packet[1] = 0xE1;
-    login_packet[2] = 0x02;
-    memcpy(login_packet + 64, key.data(), key.size());
-
-    SendControlPacket(login_packet, 192);
-}
-
-void AlienwareAW3423DWFController::SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b)
-{
-    unsigned char led_id_2 = (led_id == 0x01) ? 0xf6 : (led_id == 0x02) ? 0xf5
-                                                   : (led_id == 0x08)   ? 0xff
-                                                                        : 0xfc;
-    PerformLogin();
-
-    unsigned char color_packet[192] = {0x00};
-
-    color_packet[0]  = 0x40;
-    color_packet[1]  = 0xC6;
-    color_packet[6]  = 0x0A;
-    color_packet[8]  = 0x6E;
-    color_packet[10] = 0x82;
-    color_packet[64] = 0x51;
-    color_packet[65] = 0x87;
-    color_packet[66] = 0xD0;
-    color_packet[67] = 0x04;
-
-    color_packet[68] = led_id;
-    color_packet[69] = r;
-    color_packet[70] = g;
-    color_packet[71] = b;
-    color_packet[72] = 0x64;
-    color_packet[73] = led_id_2;
-
-    SendControlPacket(color_packet, 192);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(200));
-}
-
-std::vector<unsigned char> AlienwareAW3423DWFController::GenerateKey(
-    const std::vector<unsigned char> &response)
-{
-    std::vector<unsigned char> syn_key(8, 0);
-
-    const std::vector<unsigned char> oem_key = {
-        0xf5, 0x3f, 0xc1, 0x39, 0x44, 0x3a, 0x31, 0x79, 0x0d, 0xb1, 0x82, 0x76
-    };
-
-    size_t sk_idx = 0, ok_idx = 0;
-    while(ok_idx < oem_key.size() && sk_idx < 8)
-    {
-        unsigned char ok_sub_len = (oem_key[ok_idx] & 1) + ((oem_key[ok_idx] & 0x10) >> 4);
-
-        for(unsigned int i = 0; i < ok_sub_len && sk_idx < 8; i++)
-        {
-            syn_key[sk_idx] = oem_key[ok_idx + 1] ^ oem_key[ok_idx];
-            ok_idx++;
-            sk_idx++;
-        }
-        ok_idx++;
-    }
-
-    std::vector<unsigned char> out_buffer;
-
-    uint16_t v15 = static_cast<uint16_t>(response[15]) |
-                   (static_cast<uint16_t>(response[0]) << 8);
-    bool parity_odd = (std::bitset<16>(v15).count() % 2 != 0);
-
-    if(parity_odd)
-    {
-        size_t end = std::min<size_t>(8, response.size());
-        out_buffer = std::vector<unsigned char>(response.begin(), response.begin() + end);
-
-        if(response.size() > 14)
-        {
-            unsigned char idx = response[14] & 0x07;
-            if((idx + 8) < (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 "";
-}

Controllers/AlienwareMonitorController/AlienwareAW3423DWFController.h

@@ -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-only                   |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <hidapi.h>
-#include <vector>
-#include <string>
-
-class AlienwareAW3423DWFController
-{
-public:
-    AlienwareAW3423DWFController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW3423DWFController();
-
-    std::string GetLocation();
-    std::string GetSerialString();
-    void SendColor(unsigned char led_id, unsigned char r, unsigned char g, unsigned char b);
-
-private:
-    hid_device* dev;
-    std::string location;
-
-    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();
-};

Controllers/AlienwareMonitorController/AlienwareMonitorController.cpp

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