More poseidon z rework

Poseidon z rework in progress
2020-02-02 19:10:49 -06:00 · 2020-01-28 20:27:31 -06:00
2470 changed files with 12538 additions and 579219 deletions
@@ -1,17 +0,0 @@
-# EditorConfig helps developers define and maintain consistent coding styles between different editors and IDEs
-# editorconfig.org
-
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-
-# We recommend you to keep these unchanged
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false
-indent_size = 4
@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-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
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
@@ -1,113 +1 @@
-# This file is used to ignore files that should not be pushed to the repo.
-# ----------------------------------------------------------------------------
-
-# OpenRGB Specific
-OpenRGB
-openrgb
-OpenRGB-x86_64.AppImage
-
-# Directories
-.build/
-.cache/
-.moc/
-.obj/
-.pch/
-.rcc/
-.uic/
-.clangd/
-*_debug/
-*_release/
-debug/
-release/
-build/
-Build/
-.qmake.cache
-.qmake.stash
-.vscode
-.vs
-
-# Generic Files
-.DS_Store
-Thumbs.db
-
-# Binaries
-*.exe
-!dependencies/**/*.exe
-*.bat
-!dependencies/**/*.bat
-
-# C++ objects and libs
-*.slo
-*.lo
-*.o
-*.a
-*.la
-*.lai
-*.so
-*.so.*
-*.dll
-!dependencies/**/*.dll
-*.dylib
-
-# Qt-es
-object_script.*.Release
-object_script.*.Debug
-*_plugin_import.cpp
-*.pro.user
-*.pro.user.*
-*.qbs.user
-*.qbs.user.*
-*.moc
-moc_*.cpp
-moc_*.h
-qrc_*.cpp
-ui_*.h
-*.qmlc
-*.jsc
-Makefile*
-*build-*
-*.qm
-*.prl
-
-# Qt unit tests
-target_wrapper.*
-
-# QtCreator
-*.autosave
-
-# QtCreator Qml
-*.qmlproject.user
-*.qmlproject.user.*
-
-# QtCreator CMake
-CMakeLists.txt.user*
-
-# QtCreator 4.8< compilation database
-compile_commands.json
-
-# QtCreator local machine specific files for imported projects
-*creator.user*
-
-*_qmlcache.qrc
-
-# Visual Studio generated files
-*.ib_pdb_index
-*.idb
-*.ilk
-*.ncb
-*.opensdf
-*.pdb
-*.sdf
-*.sln
-*.suo
-*.vcproj
-*.vcxproj
-*vcproj.*.*.user
-*vcxproj.*
-
-# MinGW generated files
-*.Debug
-*.Release
-
-# Clang tooling files
-compile_commands.json
+*.pro.user*
@@ -1,523 +0,0 @@
-# swy: some useful references; the MSVC part of the CI script is based on the one from bind9, by Michał Kępień:
-# https://gitlab.com/gitlab-org/ci-cd/shared-runners/images/gcp/windows-containers/blob/master/cookbooks/preinstalled-software/README.md
-# https://gitlab.isc.org/isc-projects/bind9/commit/facc6a051fcac70fbbc61cb92a37be8c3e4db5ec#587d266bb27a4dc3022bbed44dfa19849df3044c_718_731
-# https://www.kittell.net/code/powershell-unix-sed-equivalent-change-text-file/
-# https://powershell.org/forums/topic/how-to-use-ansi-vt100-formatting-in-powershell-ooh-pretty-colors/
-
-#-----------------------------------------------------------------------#
-# OpenRGB GitLab CI Configuration                                       #
-#-----------------------------------------------------------------------#
-
-.shared_windows_runners:
-  tags:
-  - shared-windows
-  - windows
-  - windows-1809
-
-stages:
-  - build
-  - test
-
-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
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) 32-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-"Linux 32 AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
-  stage: build
-  script:
-  - export $(dpkg-architecture)
-  - ./scripts/build-appimage.sh
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB-i386.AppImage
-    - 60-openrgb.rules
-    - README.md
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Linux (AppImage) 64-bit Build Target                                  #
-#-----------------------------------------------------------------------#
-"Linux 64 AppImage":
-  <<: *ccache_init
-  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-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 (.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:
-  - 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 (.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:
-  - 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 (.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:
-  - 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 (.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:
-  - 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 (.rpm, f35) 64-bit Build Target                                 #
-#-----------------------------------------------------------------------#
-"Linux 64 f35 rpm":
-  image: fedora:35
-  stage: build
-  script:
-  - dnf install rpmdevtools dnf-plugins-core -y 
-  - rpmdev-setuptree 
-  - 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
-
-#-----------------------------------------------------------------------#
-# Linux (.rpm, f36) 64-bit Build Target                                 #
-#-----------------------------------------------------------------------#
-"Linux 64 f36 rpm":
-  image: fedora:36
-  stage: build
-  script:
-  - dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
-  - rpmdev-setuptree
-  - 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
-
-#-----------------------------------------------------------------------#
-# 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
-  - openrgb -l
-  - 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
-  - openrgb -l
-  - 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
-  - openrgb -l
-  - 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
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Bullseye)"
-  needs:
-  - "Linux 64 .deb (Debian Bullseye)"
-
-#-----------------------------------------------------------------------#
-# Ubuntu 64 20.04LTS test                                               #
-#-----------------------------------------------------------------------#
-"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
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Buster)"
-  needs:
-  - "Linux 64 .deb (Debian Buster)"
-
-#-----------------------------------------------------------------------#
-# Ubuntu 64 21.10 test                                                  #
-#-----------------------------------------------------------------------#
-"Ubuntu 64 21.10":
-  image: ubuntu:impish
-  stage: test
-  script:
-  - apt update
-  - DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
-  - openrgb --version
-  - openrgb -l
-  - apt remove -y openrgb
-  dependencies:
-  - "Linux 64 .deb (Debian Bullseye)"
-  needs:
-  - "Linux 64 .deb (Debian Bullseye)"
-
-#-----------------------------------------------------------------------#
-# Fedora 64 v35 test                                                    #
-#-----------------------------------------------------------------------#
-"Fedora 64 v35":
-  image: fedora:35
-  stage: test
-  script:
-  - yum -y localinstall ./openrgb*64.rpm
-  - openrgb --version
-  - openrgb -l
-  - yum -y remove openrgb
-  dependencies:
-  - "Linux 64 f35 rpm"
-  needs:
-  - "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
-  - openrgb -l
-  - yum -y remove openrgb
-  dependencies:
-  - "Linux 64 f36 rpm"
-  needs:
-  - "Linux 64 f36 rpm"
-
-#-----------------------------------------------------------------------#
-# Windows (32-bit) Build Target                                         #
-#-----------------------------------------------------------------------#
-"Windows 32":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - $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://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
-  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
-  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
-  - _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:
-    - 'OpenRGB Windows 32-bit'
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# Windows (64-bit) Build Target                                         #
-#-----------------------------------------------------------------------#
-"Windows 64":
-  extends:
-  - .shared_windows_runners
-  stage: build
-  script:
-  - $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://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
-  - curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
-  - curl.exe -LJ -o qt-jom.zip  'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
-  - _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:
-    - 'OpenRGB Windows 64-bit'
-    expire_in: 30 days
-
-#-----------------------------------------------------------------------#
-# MacOS Build Target                                                    #
-#-----------------------------------------------------------------------#
-"MacOS ARM64":
-  tags:
-  - macos
-  stage: build
-  script:
-  - eval $(/opt/homebrew/bin/brew shellenv)
-  - qmake OpenRGB.pro
-  - make -j16
-  - macdeployqt OpenRGB.app -codesign=OpenRGB
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB.app
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: '$BUILD_MACOS =~ /.+/'
-    when: on_success
-
-"MacOS Intel":
-  tags:
-  - macos
-  stage: build
-  script:
-  - eval $(/usr/local/bin/brew shellenv)
-  - arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
-  - arch -x86_64 make -j16
-  - arch -x86_64 macdeployqt OpenRGB.app -codesign=OpenRGB
-
-  artifacts:
-    name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
-    paths:
-    - OpenRGB.app
-    expire_in: 30 days
-
-  rules:
-  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
-    when: on_success
-  - if: '$BUILD_MACOS =~ /.+/'
-    when: on_success
@@ -1,106 +0,0 @@
-# OpenRGB CODEOWNERS
-
-# Default Code Owner
-* @Calcprogrammer1
-
-CODEOWNERS @Calcprogrammer1
-
-#-----------------------------------------------------------------------------#
-# Controllers - Directories                                                   #
-#-----------------------------------------------------------------------------#
-[Controllers]
-/Controllers/AMDWraithPrismController/
-/Controllers/ASRockPolychromeSMBusController/
-/Controllers/ASRockPolychromeUSBController/
-/Controllers/AlienwareController/
-/Controllers/AlienwareKeyboardController/
-/Controllers/AnnePro2Controller/
-/Controllers/AsusAuraCoreController/
-/Controllers/AsusAuraGPUController/
-/Controllers/AsusAuraUSBController/
-/Controllers/AsusTUFLaptopController/
-/Controllers/BlinkyTapeController/
-/Controllers/CoolerMasterController/                        @Dr_No
-/Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDominatorPlatinumController/
-/Controllers/CorsairHydroController/
-/Controllers/CorsairHydroPlatinumController/
-/Controllers/CorsairLightingNodeController/
-/Controllers/CorsairPeripheralController/
-/Controllers/CorsairVengeanceController/
-/Controllers/CorsairVengeanceProController/
-/Controllers/CorsairWirelessController/
-/Controllers/CreativeController/
-/Controllers/CrucialController/
-/Controllers/DasKeyboardController/
-/Controllers/DebugController/
-/Controllers/DuckyKeyboardController/
-/Controllers/DygmaRaiseController/
-/Controllers/E131Controller/
-/Controllers/EKController/                                  @Dr_No
-/Controllers/ENESMBusController/
-/Controllers/EVGAAmpereGPUController/                       @TheRogueZeta
-/Controllers/EVGAGP102GPUController/                        
-/Controllers/EVGAPascalGPUController/                       
-/Controllers/EVGATuringGPUController/                       @TheRogueZeta
-/Controllers/EVGAUSBController/                             @Dr_No
-/Controllers/EVisionKeyboardController/
-/Controllers/EspurnaController/
-/Controllers/FanBusController/
-/Controllers/FaustusController/
-/Controllers/GainwardGPUController/
-/Controllers/GalaxGPUController/
-/Controllers/GigabyteAorusCPUCoolerController/
-/Controllers/GigabyteRGBFusion2DRAMController/
-/Controllers/GigabyteRGBFusion2GPUController/
-/Controllers/GigabyteRGBFusion2SMBusController/             @Dr_No
-/Controllers/GigabyteRGBFusion2USBController/               @Dr_No
-/Controllers/GigabyteRGBFusionController/
-/Controllers/GigabyteRGBFusionGPUController/
-/Controllers/HPOmen30LController/
-/Controllers/HoltekController/
-/Controllers/HyperXDRAMController/
-/Controllers/HyperXKeyboardController/
-/Controllers/HyperXMouseController/
-/Controllers/HyperXMousematController/
-/Controllers/LEDStripController/
-/Controllers/LianLiController/
-/Controllers/LinuxLEDController/
-/Controllers/LogitechController/                            @Dr_No
-/Controllers/MSI3ZoneController/
-/Controllers/MSIGPUController/
-/Controllers/MSIMysticLightController/
-/Controllers/MSIRGBController/
-/Controllers/NZXTHue2Controller/
-/Controllers/NZXTHuePlusController/
-/Controllers/NZXTKrakenController/
-/Controllers/OpenRazerController/
-/Controllers/PNYGPUController/
-/Controllers/PatriotViperController/
-/Controllers/PhilipsHueController/
-/Controllers/PhilipsWizController/
-/Controllers/QMKOpenRGBController/
-/Controllers/RazerController/
-/Controllers/RedragonController/
-/Controllers/RoccatController/
-/Controllers/SapphireGPUController/
-/Controllers/SinowealthController/
-/Controllers/SonyDS4Controller/
-/Controllers/SteelSeriesController/
-/Controllers/TecknetController/
-/Controllers/ThermaltakePoseidonZRGBController/
-/Controllers/ThermaltakeRiingController/
-/Controllers/ThingMController/
-/Controllers/WootingKeyboardController/                     @Dr_No
-/Controllers/YeelightController/
-/Controllers/ZalmanZSyncController/
-
-#-----------------------------------------------------------------------------#
-# Controllers - File exceptions                                               #
-#                                                                             #
-#   As sections get combined and the last rule applies any specific file      #
-#   that is an exception to the above should be explicitly named here         #
-#-----------------------------------------------------------------------------#
-[Controllers]
-/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp            @TheRogueZeta
-/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h              @TheRogueZeta
@@ -1,33 +0,0 @@
-<!-- 
-Found a bug?  Something isn't working as expected?
-To help us keep track of the requests please start the title with [Bug Report]
-But before that, first you should check it out with the latest pipeline.
-->
-
-### Description of Bug
-<!--
-Please describe the bug.
-Explain any steps taken to reproduce the bug
-and what you expect the correct behavior to be.
-->
-
-### Attached Log
-<!--
-Please attach a verbose log, you can do it by running the exe from cmd with '--loglevel 6' flag.
-You can locate them using the Settings tab and click the 'Open Settings Folder' button.
-Important!! Please upload the logs made with the latest pipeline build of OpenRGB.
-->
-
-### Operating System
-<!--
-Please write down which OS and which version did you encounter the issue with.
-->
-~"OS - Linux" 
-~"OS - MacOS" 
-~"OS - Windows" 
-### Hardware Configuration
-<!--
-Please list the RGB hardware that you are using with OpenRGB.
-If your bug does not relate to any one particular device or device type,
-or if the bug is in a part of the code not directly interacting with hardware, this is optional.
-->
@@ -1,11 +0,0 @@
-<!-- 
-Have something you would like to see added to OpenRGB? Let us know here 
-To help us keep track of the requests please start the title with [Feature Request]
-->
-
-### Feature Request
-<!--
-Please explain the new feature you would like to see added in detail.
-Explain how you think it should work and provide any mock-ups,
-code snippets, etc. that you think will help explain the feature.
-->
@@ -1,86 +0,0 @@
-<!-- 
-When naming the support request please title the request as 
-`[New Device] <Name of new device>` 
-Please open one issue per device you would like to add
-->
-
-### Name of device:
-<!--
-Please put the name of the product, including manufacturer, beneath this line
-->
-
-
-### Link to manufacturer's product page:
-<!--
-Please add a link to the manufacturer's product page beneath this line
-->
-
-
-### Please select what type of device/interface the device uses:
-<!-- Please select from one of the following
- This determines how the device connects to the PC -->
-
-~"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::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
-~"DeviceType::WMI"  <!-- The device is controlled thru Windows Management Instrumentation -->
-
-<!-- Please delete any lines that are not relevant -->
-
-### ID information:
-<!--
-For PCI (GPU) devices we will need the Vendor ID, Device ID, Sub-Vendor ID and Sub-Device IDs
-To get the Device ID formation for a GPU on Windows run the following command in Powershell:
-
-wmic path Win32_VideoController get name,PNPDeviceID
-
-Linux this can be found using the terminal:
-
-lspci -d 1002: -nnvm | head -6 | tail -n 4 && lspci -d 10DE: -nnvm | head -6 | tail -n 4
-->
-
-<!--
-For USB devices we will need the USB VID and PID
-Windows Powershell:
-
-gwmi Win32_USBControllerDevice |%{[wmi]($_.Dependent)} | Sort Manufacturer,Description,DeviceID | Ft -GroupBy Manufacturer Description,Service,DeviceID
-
-Linux Terminal:
-lsusb
-->
-
-
-### Please attach screenshots of the device's official control application here:
-<!--
-Screenshots of the official control software should show lists of supported modes, color selection, and zone/LED selection capabilities of the device's official software.
-->
-
-
-### Please attach device captures here:
-<!-- If you have code examples from other projects please link them here or alternatively
-for information on how to capture device packets please refer to the wiki article
-https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
-->
-
-
-
-
-
-
-
-
-
-<!-- For admin purposes: Please leave this section as is -->
-/label ~"Issue Type - New Device"
-/label ~"NewDevice::Step0 - Unconfirmed"
-
-# Checklist for Step2
- [ ] Name of device
- [ ] A link to the vendors product page has been included
- [ ] The transport bus has been identified and the appropriate label added to the issue.
- [ ] The device ID's have been included for [USB](https://gitlab.com/Dr_No/OpenRGB/-/wikis/USB-Vendor-Identification-and-Product-Identification) or PCI
- [ ] Screenshots of the OEM Application are included
- [ ] There is either, appropriate code examples linked or suitable device captures attached
-<!-- For admin purposes: Please leave this section as is -->
@@ -1,24 +0,0 @@
-
-<!--
-Please put "Initial commit for" name of the product, including manufacturer above this line
-  and a description of the additions / removals / changes done below the line.
-->
-
-
-
-
-<!-- For admin purposes: Please leave this section as is -->
-
-# Checklist for Accepting a Merge Request for a New Device
- [ ] The `New Device` issue raised for this device is linked to this MR with a keyword `Closes / Resolves / Implements`
- [ ] There is a device protocol page in the [Developer Wiki](https://gitlab.com/OpenRGBDevelopers/OpenRGB-Wiki) or there is enough information / captures in the `New Device` issue to provide ongoing support.
- [ ] The code to be merged follows the style guide and change requirements as [documented in the contributing guide](https://gitlab.com/CalcProgrammer1/OpenRGB/-/blob/master/CONTRIBUTING.md).
-<!--
-The metadata for this controller is required to produce both the udev permissions and
- the supported device page for this device. A stub can be found in the RGBController_Dummy.cpp
-->
- [ ] Meta data for the device is included in `RGBController_*` file
- [ ] This device is detected and is working on Windows 10 and / or 11
- [ ] This device is detected and is working on Linux (Please specify distribution and releases tested)
- [ ] Logging for Info, Warnings and Errors has been added for troubleshooting purposes
-<!-- For admin purposes: Please leave this section as is -->
@@ -0,0 +1,3 @@
+[submodule "dependencies/libe131"]
+	path = dependencies/libe131
+	url = https://github.com/CalcProgrammer1/libe131
@@ -1,174 +0,0 @@
-#include "AutoStart-FreeBSD.h"
-#include "LogManager.h"
-#include "filesystem.h"
-
-#include <fstream>
-#include <iostream>
-#include <unistd.h>
-#include <sstream>
-
-/*-----------------------------------------------------*\
-| FreeBSD AutoStart Implementation                      |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
-
-AutoStart::AutoStart(std::string name)
-{
-    InitAutoStart(name);
-}
-
-bool AutoStart::DisableAutoStart()
-{
-    std::error_code autostart_file_remove_errcode;
-    bool            success                         = false;
-
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
-        if(!filesystem::exists(autostart_file))
-        {
-            success = true;
-        }
-        /*---------------------------------------------*\
-        | 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.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
-{
-    bool        success                             = false;
-
-    /*-------------------------------------------------*\
-    | 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     |
-        \*---------------------------------------------*/
-        if(!autostart_file_stream)
-        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
-            success = false;
-        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
-        else
-        {
-            //autostart_file_stream << desktop_file;
-            autostart_file_stream.close();
-            success = !autostart_file_stream.fail();
-
-            if (!success)
-            {
-                LOG_ERROR("An error occurred writing the auto start file.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::IsAutoStartEnabled()
-{
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        return(filesystem::exists(autostart_file));
-    }
-    else
-    {
-        return(false);
-    }
-}
-
-std::string AutoStart::GetExePath()
-{
-    /*-------------------------------------------------*\
-    | 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));
-}
-
-void AutoStart::InitAutoStart(std::string name)
-{
-    std::string autostart_dir;
-
-    autostart_name = name;
-
-    /*-------------------------------------------------*\
-    | 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                                              |
-    \*-------------------------------------------------*/
-    if(xdg_config_home != NULL)
-    {
-        autostart_dir = xdg_config_home;
-        autostart_dir = autostart_dir + "/autostart/";
-    }
-    else if(home != NULL)
-    {
-        autostart_dir = home;
-        autostart_dir = autostart_dir + "/.config/autostart/";
-    }
-
-    /*-------------------------------------------------*\
-    | 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);
-        }
-
-        if(success)
-        {
-            autostart_file = autostart_dir + autostart_name + ".desktop";
-        }
-    }
-}
-
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <string>
-#include "AutoStart.h"
-
-class AutoStart: public AutoStartInterface
-{
-public:
-    AutoStart(std::string name);
-
-    bool            DisableAutoStart();
-    bool            EnableAutoStart(AutoStartInfo autostart_info);
-    bool            IsAutoStartEnabled();
-    std::string     GetExePath();
-
-private:
-    void            InitAutoStart(std::string name);
-    std::string     GenerateLaunchAgentFile(AutoStartInfo autostart_info);
-};
@@ -1,212 +0,0 @@
-#include "AutoStart-Linux.h"
-#include "LogManager.h"
-#include "filesystem.h"
-
-#include <fstream>
-#include <iostream>
-#include <unistd.h>
-#include <linux/limits.h>
-
-/*-----------------------------------------------------*\
-| Linux AutoStart Implementation                        |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
-
-AutoStart::AutoStart(std::string name)
-{
-    InitAutoStart(name);
-}
-
-bool AutoStart::DisableAutoStart()
-{
-    std::error_code autostart_file_remove_errcode;
-    bool            success                         = false;
-
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
-        if(!filesystem::exists(autostart_file))
-        {
-            success = true;
-        }
-        /*---------------------------------------------*\
-        | 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.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
-{
-    bool        success                             = false;
-
-    /*-------------------------------------------------*\
-    | 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     |
-        \*---------------------------------------------*/
-        if(!autostart_file_stream)
-        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
-            success = false;
-        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
-        else
-        {
-            autostart_file_stream << desktop_file;
-            autostart_file_stream.close();
-            success = !autostart_file_stream.fail();
-
-            if (!success)
-            {
-                LOG_ERROR("An error occurred writing the auto start file.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::IsAutoStartEnabled()
-{
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        return(filesystem::exists(autostart_file));
-    }
-    else
-    {
-        return(false);
-    }
-}
-
-std::string AutoStart::GetExePath()
-{
-    /*-------------------------------------------------*\
-    | 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                                       |
-\*-----------------------------------------------------*/
-
-std::string AutoStart::GenerateDesktopFile(AutoStartInfo autostart_info)
-{
-    /*-------------------------------------------------*\
-    | Generate a .desktop file from the AutoStart       |
-    | parameters                                        |
-    \*-------------------------------------------------*/
-    std::stringstream fileContents;
-
-    fileContents << "[Desktop Entry]"                               << std::endl;
-    fileContents << "Categories="        << autostart_info.category << std::endl;
-    fileContents << "Comment="           << autostart_info.desc     << std::endl;
-    fileContents << "Icon="              << autostart_info.icon     << std::endl;
-    fileContents << "Name="              << GetAutoStartName()      << std::endl;
-    fileContents << "StartupNotify=true"                            << std::endl;
-    fileContents << "Terminal=false"                                << std::endl;
-    fileContents << "Type=Application"                              << std::endl;
-
-    /*-------------------------------------------------*\
-    | Add the executable path and arguments             |
-    \*-------------------------------------------------*/
-    fileContents << "Exec="              << autostart_info.path;
-
-    if (autostart_info.args != "")
-    {
-        fileContents << " " << autostart_info.args;
-    }
-
-    fileContents << std::endl;
-    
-    return(fileContents.str());
-}
-
-void AutoStart::InitAutoStart(std::string name)
-{
-    std::string autostart_dir;
-
-    autostart_name = name;
-
-    /*-------------------------------------------------*\
-    | 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                                              |
-    \*-------------------------------------------------*/
-    if(xdg_config_home != NULL)
-    {
-        autostart_dir = xdg_config_home;
-        autostart_dir = autostart_dir + "/autostart/";
-    }
-    else if(home != NULL)
-    {
-        autostart_dir = home;
-        autostart_dir = autostart_dir + "/.config/autostart/";
-    }
-
-    /*-------------------------------------------------*\
-    | 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);
-        }
-
-        if(success)
-        {
-            autostart_file = autostart_dir + autostart_name + ".desktop";
-        }
-    }
-}
-
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <string>
-#include "AutoStart.h"
-
-class AutoStart: public AutoStartInterface
-{
-public:
-    AutoStart(std::string name);
-
-    bool        DisableAutoStart();
-    bool        EnableAutoStart(AutoStartInfo autostart_info);
-    bool        IsAutoStartEnabled();
-    std::string GetExePath();
-
-private:
-    void        InitAutoStart(std::string name);
-    std::string GenerateDesktopFile(AutoStartInfo autostart_info);
-};
@@ -1,208 +0,0 @@
-#include "AutoStart-MacOS.h"
-#include "LogManager.h"
-#include "filesystem.h"
-
-#include <fstream>
-#include <sstream>
-#include <iostream>
-#include <unistd.h>
-
-#include <mach-o/dyld.h>
-
-/*-----------------------------------------------------*\
-| MacOS AutoStart Implementation                        |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
-
-AutoStart::AutoStart(std::string name)
-{
-    InitAutoStart(name);
-}
-
-bool AutoStart::DisableAutoStart()
-{
-    std::error_code autostart_file_remove_errcode;
-    bool            success                         = false;
-
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
-        if(!filesystem::exists(autostart_file))
-        {
-            success = true;
-        }
-        /*---------------------------------------------*\
-        | 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.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
-{
-    bool        success                             = false;
-
-    /*-------------------------------------------------*\
-    | 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     |
-        \*---------------------------------------------*/
-        if(!autostart_file_stream)
-        {
-            LOG_ERROR("Could not open %s for writing.", autostart_file.c_str());
-            success = false;
-        }
-        /*---------------------------------------------*\
-        | Otherwise, write the file                     |
-        \*---------------------------------------------*/
-        else
-        {
-            autostart_file_stream << desktop_file;
-            autostart_file_stream.close();
-            success = !autostart_file_stream.fail();
-
-            if (!success)
-            {
-                LOG_ERROR("An error occurred writing the auto start file.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::IsAutoStartEnabled()
-{
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        return(filesystem::exists(autostart_file));
-    }
-    else
-    {
-        return(false);
-    }
-}
-
-std::string AutoStart::GetExePath()
-{
-    /*-------------------------------------------------*\
-    | Create the OpenRGB executable path                |
-    \*-------------------------------------------------*/
-    char     exepath[ PATH_MAX ];
-    uint32_t exesize = PATH_MAX;
-
-    int ret_val = _NSGetExecutablePath(exepath, &exesize);
-
-    return(std::string(exepath, (ret_val == 0) ? strlen(exepath) : 0));
-
-    return("");
-}
-
-/*-----------------------------------------------------*\
-| MacOS AutoStart Implementation                        |
-| Private Methods                                       |
-\*-----------------------------------------------------*/
-
-std::string AutoStart::GenerateLaunchAgentFile(AutoStartInfo autostart_info)
-{
-    /*-------------------------------------------------*\
-    | Generate a .plist file from the AutoStart         |
-    | parameters                                        |
-    \*-------------------------------------------------*/
-    std::stringstream fileContents;
-
-    fileContents << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"                                                                    << std::endl;
-    fileContents << "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">"    << std::endl;
-    fileContents << "<plist version=\"1.0\">"                                                                                       << std::endl;
-    fileContents << "<dict>"                                                                                                        << std::endl;
-    fileContents << "    <key>Label</key>"                                                                                          << std::endl;
-    fileContents << "    <string>org.openrgb</string>"                                                                              << std::endl;
-    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);
-        std::string arg;
-
-        while(arg_parser >> arg)
-        {
-            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());
-}
-
-void AutoStart::InitAutoStart(std::string name)
-{
-    std::string autostart_dir;
-
-    autostart_name = name;
-
-    /*-------------------------------------------------*\
-    | Determine where the autostart .desktop files are  |
-    | kept                                              |
-    \*-------------------------------------------------*/
-    autostart_dir = getenv("HOME");
-    autostart_dir = autostart_dir + "/Library/LaunchAgents/";
-
-    /*-------------------------------------------------*\
-    | 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);
-        }
-
-        if(success)
-        {
-            autostart_file = autostart_dir + autostart_name + ".plist";
-        }
-    }
-}
-
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <string>
-#include "AutoStart.h"
-
-class AutoStart: public AutoStartInterface
-{
-public:
-    AutoStart(std::string name);
-
-    bool            DisableAutoStart();
-    bool            EnableAutoStart(AutoStartInfo autostart_info);
-    bool            IsAutoStartEnabled();
-    std::string     GetExePath();
-
-private:
-    void            InitAutoStart(std::string name);
-    std::string     GenerateLaunchAgentFile(AutoStartInfo autostart_info);
-};
@@ -1,204 +0,0 @@
-#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)
-{
-    InitAutoStart(name);
-}
-
-bool AutoStart::DisableAutoStart()
-{
-    std::error_code autostart_file_remove_errcode;
-    bool success                                    = false;
-
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        /*---------------------------------------------*\
-        | If file doesn't exist, disable is successful  |
-        \*---------------------------------------------*/
-        if(!filesystem::exists(autostart_file))
-        {
-            success = true;
-        }
-        /*---------------------------------------------*\
-        | Otherwise, delete the file                    |
-        \*---------------------------------------------*/
-        else
-        {
-            success = filesystem::remove(autostart_file, autostart_file_remove_errcode);
-            
-            if(!success)
-            {
-                LOG_ERROR("An error occurred removing the auto start file.");
-            }
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return(success);
-}
-
-bool AutoStart::EnableAutoStart(AutoStartInfo autostart_info)
-{
-    bool success                                    = false;
-
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        bool            weInitialised               = false;
-        HRESULT         result;
-        IShellLinkW*    shellLink                   = NULL;
-
-        std::wstring    exepathw                    = utf8_decode(autostart_info.path);
-        std::wstring    argumentsw                  = utf8_decode(autostart_info.args);
-        std::wstring    startupfilepathw            = utf8_decode(autostart_file);
-        std::wstring    descriptionw                = utf8_decode(autostart_info.desc);
-        std::wstring    iconw                       = utf8_decode(autostart_info.path);
-
-        result                                      = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
-
-        /*---------------------------------------------*\
-        | If not initialized, initialize                |
-        \*---------------------------------------------*/
-        if(result == CO_E_NOTINITIALIZED)
-        {
-            weInitialised                           = true;
-            CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
-            result                                  = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_ALL, IID_IShellLinkW, (void**)&shellLink);
-        }
-
-        /*---------------------------------------------*\
-        | 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);
-                success                             = SUCCEEDED(result);
-                persistFile->Release();
-            }
-
-            shellLink->Release();
-        }
-
-        /*---------------------------------------------*\
-        | Uninitialize when done                        |
-        \*---------------------------------------------*/
-        if(weInitialised)
-        {
-            CoUninitialize();
-        }
-    }
-    else
-    {
-        LOG_ERROR("Could not establish correct autostart file path.");
-    }
-
-    return success;
-}
-
-bool AutoStart::IsAutoStartEnabled()
-{
-    /*-------------------------------------------------*\
-    | Check if the filename is valid                    |
-    \*-------------------------------------------------*/
-    if(autostart_file != "")
-    {
-        return(filesystem::exists(autostart_file));
-    }
-    else
-    {
-        return(false);
-    }
-}
-
-std::string AutoStart::GetExePath()
-{
-    /*-------------------------------------------------*\
-    | 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                                       |
-\*-----------------------------------------------------*/
-
-void AutoStart::InitAutoStart(std::string name)
-{
-    char startMenuPath[MAX_PATH];
-
-    autostart_name = name;
-
-    /*-------------------------------------------------*\
-    | Get startup applications path                     |
-    \*-------------------------------------------------*/
-    HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROGRAMS, NULL, 0, startMenuPath);
-
-    if(SUCCEEDED(result))
-    {
-        autostart_file = std::string(startMenuPath);
-
-        autostart_file += "\\Startup\\" + autostart_name + ".lnk";
-    }
-    else
-    {
-        autostart_file.clear();
-    }
-}
-
-/*-----------------------------------------------------*\
-| Convert an UTF8 string to a wide Unicode String       |
-| (from wmi.cpp)                                        |
-\*-----------------------------------------------------*/
-std::wstring AutoStart::utf8_decode(const std::string& str)
-{
-    if(str.empty())
-    {
-        return std::wstring();
-    }
-
-    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);
-}
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <string>
-#include "AutoStart.h"
-
-class AutoStart: public AutoStartInterface
-{
-public:
-    AutoStart(std::string name);
-
-    bool            DisableAutoStart();
-    bool            EnableAutoStart(AutoStartInfo autostart_info);
-    bool            IsAutoStartEnabled();
-    std::string     GetExePath();
-
-private:
-    void            InitAutoStart(std::string name);
-    std::wstring    utf8_decode(const std::string& str);
-};
@@ -1,16 +0,0 @@
-#include "AutoStart.h"
-
-/*-----------------------------------------------------*\
-| Common AutoStart Implementation                       |
-| Public Methods                                        |
-\*-----------------------------------------------------*/
-
-std::string AutoStartInterface::GetAutoStartFile()
-{
-    return(autostart_file);
-}
-
-std::string AutoStartInterface::GetAutoStartName()
-{
-    return(autostart_name);
-}
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <string>
-
-struct AutoStartInfo
-{
-    std::string path;
-    std::string args;
-    std::string desc;
-    std::string icon;
-    std::string category;
-};
-
-class AutoStartInterface
-{
-public:
-    virtual bool        DisableAutoStart()                              = 0;
-    virtual bool        EnableAutoStart(AutoStartInfo autostart_info)   = 0;
-    virtual bool        IsAutoStartEnabled()                            = 0;
-    virtual std::string GetExePath()                                    = 0;
-
-    std::string         GetAutoStartFile();
-    std::string         GetAutoStartName();
-
-protected:
-    std::string         autostart_file;
-    std::string         autostart_name;
-};
-
-#ifdef _WIN32
-#include "AutoStart-Windows.h"
-#endif
-
-#ifdef __linux__
-#include "AutoStart-Linux.h"
-#endif
-
-#ifdef __APPLE__
-#include "AutoStart-MacOS.h"
-#endif
-
-#ifdef __FreeBSD__
-#include "AutoStart-FreeBSD.h"
-#endif
@@ -1,58 +0,0 @@
-# Contributing to OpenRGB
-
-The OpenRGB project welcomes contributions from the community.  The project would not support the number of devices it does today without the amazing contributions from community developers.  If you want to add a new device, fix a bug, or add a feature, feel free to open a merge request on the OpenRGB GitLab (https://gitlab.com/CalcProgrammer1/OpenRGB).
-
-## Creating a Merge Request
-
-To create a merge request, log into GitLab and fork the OpenRGB project.  Push your changes to your fork and then use the Create Merge Request option.  Before opening a merge request, please review the following best practices to help your merge request get merged without excessive delay.
-
-* Please keep the scope of each merge request limited to one functional area.  If you wish to add a new device controller, for instance, don't also do code cleanup in another controller as part of the same merge request.
-* Explain what your merge request is changing, why you feel the change is necessary, and add any additional information you feel is needed to best understand your change in the merge request description.
-* Mark your merge request as a draft (start title with "Draft:") until it has been tested and verified working.
-* Follow the Style Guidelines below when making your code changes.
-* Avoid using `git merge` when updating your fork.  The OpenRGB project uses a linear git history, meaning all changes are rebased onto the tip of master.  By using `git rebase` to update your fork, you will make it easier to accept merge requests.
-
-## Style Guidelines
-
-OpenRGB is written in C++, uses the Qt framework for UI, and uses the QMake build system.  While OpenRGB does use C++, I am primarily a C programmer and prefer doing things "C Style" vs. C++ style.  C++'s object oriented programming features fit the needs of a program such as OpenRGB where there are many implementations of a single interface so I chose to write it in C++ over C.  Still, however, I prefer using C-style code where possible.  When making changes to existing code files, try to follow the existing style.  Merge requests that go out of their way to restyle code will not be accepted and will be sent back for rework.
-
-### Functional Style
-
-* Limit use of C++ std library data types
-    * For fixed-length containers, use C arrays
-    * For list constants, use const C arrays
-    * For fixed-length strings, use C char buffers ("C strings"), though using std::string is acceptable if the value will be placed in a std::string
-    * For basic types, prefer using the non-typedef'd basic types (char, short, int, etc) over typedef'd (uint8_t, uint16_t, uint32_t, etc)
-        * Unless defined in an OpenRGB API or the file is implementing an existing API using these types (such as i2c_smbus)
-    * For hard-coded values, use `#define`s over const variables unless you need a pointer to the value
-    * For variable-length containers, use std::vector
-    * For variable-length strings, use std::string
-    * `struct` should not include any functions, only variables
-    * `class` should only be used for objects containing functions
-    * Other std types may be used sparingly if necessary
-* Only use Qt libraries, types, and functionality in user interface files
-    * Anything under the qt/ folder basically
-    * Do not use QDebug, use our LogManager instead.  If you use QDebug during development, please remove it before submitting your merge request
-* Use C-style indexed for loops when iterating through an array or vector
-* Use C-style casts unless necessary
-* Avoid the `auto` type.  It makes code more difficult to read
-* Do not use `printf` or `cout` for debug messages, use LogManager instead
-* Don't define namespaces unless necessary
-
-### Non-functional Style
-
-* Set your editor's tab settings to insert spaces, using 4 spaces per tab stop
-* Always put opening and closing braces `{`, `}` on their own lines
-* Indent code inside the braces, do not indent the braces themselves
-* Capitalize hexadecimal literals (`0xFF` not `0xff`) except in the udev rules file (which must be lowercase to work)
-* No space between keyword and open parenthesis (`if(TRUE)` not `if (TRUE)`).  There are some instances of this that haven't been cleaned up in the code.
-* Generally, `snake_case` is used for variable names and `CamelCase` is used for function and class names
-* Add a header comment to new files with the filename, description, original author, and date (this is missing on most Detect files)
-* Line up `=` when doing a lot of assignments together
-* Use this comment box style when adding comments:
-
-```
-/*--------------------------------*\
-| This is a comment                |
-\*_-------------------------------*/
-```
@@ -1,153 +0,0 @@
-#ifndef COLORS_H
-#define COLORS_H
-
-#define COLOR_BLACK 0x000000
-#define COLOR_NAVY 0x000080
-#define COLOR_DARKBLUE 0x00008b
-#define COLOR_MEDIUMBLUE 0x0000cd
-#define COLOR_BLUE 0x0000ff
-#define COLOR_DARKGREEN 0x006400
-#define COLOR_GREEN 0x008000
-#define COLOR_TEAL 0x008080
-#define COLOR_DARKCYAN 0x008b8b
-#define COLOR_DEEPSKYBLUE 0x00bfff
-#define COLOR_DARKTURQUOISE 0x00ced1
-#define COLOR_MEDIUMSPRINGGREEN 0x00fa9a
-#define COLOR_LIME 0x00ff00
-#define COLOR_SPRINGGREEN 0x00ff7f
-#define COLOR_AQUA 0x00ffff
-#define COLOR_CYAN 0x00ffff
-#define COLOR_MIDNIGHTBLUE 0x191970
-#define COLOR_DODGERBLUE 0x1e90ff
-#define COLOR_LIGHTSEAGREEN 0x20b2aa
-#define COLOR_FORESTGREEN 0x228b22
-#define COLOR_SEAGREEN 0x2e8b57
-#define COLOR_DARKSLATEGRAY 0x2f4f4f
-#define COLOR_DARKSLATEGREY 0x2f4f4f
-#define COLOR_LIMEGREEN 0x32cd32
-#define COLOR_MEDIUMSEAGREEN 0x3cb371
-#define COLOR_TURQUOISE 0x40e0d0
-#define COLOR_ROYALBLUE 0x4169e1
-#define COLOR_STEELBLUE 0x4682b4
-#define COLOR_DARKSLATEBLUE 0x483d8b
-#define COLOR_MEDIUMTURQUOISE 0x48d1cc
-#define COLOR_INDIGO 0x4b0082
-#define COLOR_DARKOLIVEGREEN 0x556b2f
-#define COLOR_CADETBLUE 0x5f9ea0
-#define COLOR_CORNFLOWERBLUE 0x6495ed
-#define COLOR_MEDIUMAQUAMARINE 0x66cdaa
-#define COLOR_DIMGRAY 0x696969
-#define COLOR_DIMGREY 0x696969
-#define COLOR_SLATEBLUE 0x6a5acd
-#define COLOR_OLIVEDRAB 0x6b8e23
-#define COLOR_SLATEGRAY 0x708090
-#define COLOR_SLATEGREY 0x708090
-#define COLOR_LIGHTSLATEGRAY 0x778899
-#define COLOR_LIGHTSLATEGREY 0x778899
-#define COLOR_MEDIUMSLATEBLUE 0x7b68ee
-#define COLOR_LAWNGREEN 0x7cfc00
-#define COLOR_CHARTREUSE 0x7fff00
-#define COLOR_AQUAMARINE 0x7fffd4
-#define COLOR_MAROON 0x800000
-#define COLOR_PURPLE 0x800080
-#define COLOR_ELECTRIC_ULTRAMARINE 0x4000FF
-#define COLOR_OLIVE 0x808000
-#define COLOR_GRAY 0x808080
-#define COLOR_GREY 0x808080
-#define COLOR_SKYBLUE 0x87ceeb
-#define COLOR_LIGHTSKYBLUE 0x87cefa
-#define COLOR_BLUEVIOLET 0x8a2be2
-#define COLOR_DARKRED 0x8b0000
-#define COLOR_DARKMAGENTA 0x8b008b
-#define COLOR_SADDLEBROWN 0x8b4513
-#define COLOR_DARKSEAGREEN 0x8fbc8f
-#define COLOR_LIGHTGREEN 0x90ee90
-#define COLOR_MEDIUMPURPLE 0x9370db
-#define COLOR_DARKVIOLET 0x9400d3
-#define COLOR_PALEGREEN 0x98fb98
-#define COLOR_DARKORCHID 0x9932cc
-#define COLOR_YELLOWGREEN 0x9acd32
-#define COLOR_SIENNA 0xa0522d
-#define COLOR_BROWN 0xa52a2a
-#define COLOR_DARKGRAY 0xa9a9a9
-#define COLOR_DARKGREY 0xa9a9a9
-#define COLOR_LIGHTBLUE 0xadd8e6
-#define COLOR_GREENYELLOW 0xadff2f
-#define COLOR_PALETURQUOISE 0xafeeee
-#define COLOR_LIGHTSTEELBLUE 0xb0c4de
-#define COLOR_POWDERBLUE 0xb0e0e6
-#define COLOR_FIREBRICK 0xb22222
-#define COLOR_DARKGOLDENROD 0xb8860b
-#define COLOR_MEDIUMORCHID 0xba55d3
-#define COLOR_ROSYBROWN 0xbc8f8f
-#define COLOR_DARKKHAKI 0xbdb76b
-#define COLOR_SILVER 0xc0c0c0
-#define COLOR_MEDIUMVIOLETRED 0xc71585
-#define COLOR_INDIANRED 0xcd5c5c
-#define COLOR_PERU 0xcd853f
-#define COLOR_CHOCOLATE 0xd2691e
-#define COLOR_TAN 0xd2b48c
-#define COLOR_LIGHTGRAY 0xd3d3d3
-#define COLOR_LIGHTGREY 0xd3d3d3
-#define COLOR_THISTLE 0xd8bfd8
-#define COLOR_ORCHID 0xda70d6
-#define COLOR_GOLDENROD 0xdaa520
-#define COLOR_PALEVIOLETRED 0xdb7093
-#define COLOR_CRIMSON 0xdc143c
-#define COLOR_GAINSBORO 0xdcdcdc
-#define COLOR_PLUM 0xdda0dd
-#define COLOR_BURLYWOOD 0xdeb887
-#define COLOR_LIGHTCYAN 0xe0ffff
-#define COLOR_LAVENDER 0xe6e6fa
-#define COLOR_DARKSALMON 0xe9967a
-#define COLOR_VIOLET 0xee82ee
-#define COLOR_PALEGOLDENROD 0xeee8aa
-#define COLOR_LIGHTCORAL 0xf08080
-#define COLOR_KHAKI 0xf0e68c
-#define COLOR_ALICEBLUE 0xf0f8ff
-#define COLOR_HONEYDEW 0xf0fff0
-#define COLOR_AZURE 0xf0ffff
-#define COLOR_SANDYBROWN 0xf4a460
-#define COLOR_WHEAT 0xf5deb3
-#define COLOR_BEIGE 0xf5f5dc
-#define COLOR_WHITESMOKE 0xf5f5f5
-#define COLOR_MINTCREAM 0xf5fffa
-#define COLOR_GHOSTWHITE 0xf8f8ff
-#define COLOR_SALMON 0xfa8072
-#define COLOR_ANTIQUEWHITE 0xfaebd7
-#define COLOR_LINEN 0xfaf0e6
-#define COLOR_LIGHTGOLDENRODYELLOW 0xfafad2
-#define COLOR_OLDLACE 0xfdf5e6
-#define COLOR_RED 0xff0000
-#define COLOR_FUCHSIA 0xff00ff
-#define COLOR_MAGENTA 0xff00ff
-#define COLOR_DEEPPINK 0xff1493
-#define COLOR_ORANGERED 0xff4500
-#define COLOR_TOMATO 0xff6347
-#define COLOR_HOTPINK 0xff69b4
-#define COLOR_CORAL 0xff7f50
-#define COLOR_DARKORANGE 0xff8c00
-#define COLOR_LIGHTSALMON 0xffa07a
-#define COLOR_ORANGE 0xffa500
-#define COLOR_LIGHTPINK 0xffb6c1
-#define COLOR_PINK 0xffc0cb
-#define COLOR_GOLD 0xffd700
-#define COLOR_PEACHPUFF 0xffdab9
-#define COLOR_NAVAJOWHITE 0xffdead
-#define COLOR_MOCCASIN 0xffe4b5
-#define COLOR_BISQUE 0xffe4c4
-#define COLOR_MISTYROSE 0xffe4e1
-#define COLOR_BLANCHEDALMOND 0xffebcd
-#define COLOR_PAPAYAWHIP 0xffefd5
-#define COLOR_LAVENDERBLUSH 0xfff0f5
-#define COLOR_SEASHELL 0xfff5ee
-#define COLOR_CORNSILK 0xfff8dc
-#define COLOR_LEMONCHIFFON 0xfffacd
-#define COLOR_FLORALWHITE 0xfffaf0
-#define COLOR_SNOW 0xfffafa
-#define COLOR_YELLOW 0xffff00
-#define COLOR_LIGHTYELLOW 0xffffe0
-#define COLOR_IVORY 0xfffff0
-#define COLOR_WHITE 0xffffff
-
-#endif // COLORS_H
@@ -12,39 +12,30 @@
 #include <stdio.h>
 #include <stdlib.h>

-AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const char* path)
+AMDWraithPrismController::AMDWraithPrismController(libusb_device_handle* dev_handle)
 {
-    dev         = dev_handle;
-    location    = path;
+    dev = dev_handle;

    strcpy(device_name, "AMD Wraith Prism");

-    current_fan_mode            = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_fan_speed           = 0xFF;
-    current_fan_random_color    = false;
-    current_fan_brightness      = 0xFF;
+    current_fan_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_fan_speed = 0xFF;
+    current_fan_random_color = false;

-    current_logo_mode           = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
-    current_logo_speed          = 0xFF;
-    current_logo_random_color   = false;
-    current_logo_brightness     = 0xFF;
+    current_logo_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_logo_speed = 0xFF;
+    current_logo_random_color = false;

-    current_ring_mode           = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    current_ring_speed          = 0xFF;
-    current_ring_direction      = false;
-    current_ring_brightness     = 0xFF;
+    current_ring_mode = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    current_ring_speed = 0xFF;
+    current_ring_direction = false;

    SendEnableCommand();
 }

 AMDWraithPrismController::~AMDWraithPrismController()
 {
-    hid_close(dev);
-}

-std::string AMDWraithPrismController::GetLocationString()
-{
-    return("HID: " + location);
 }

 char* AMDWraithPrismController::GetDeviceName()
@@ -52,29 +43,12 @@ char* AMDWraithPrismController::GetDeviceName()
    return device_name;
 }

-std::string AMDWraithPrismController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
 std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
 {
    std::string ret_string = "";

    unsigned char usb_buf[] =
    {
-        0x00,
        0x40, 0x21, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -93,10 +67,12 @@ std::string AMDWraithPrismController::GetEffectChannelString(unsigned char chann
        0x00, 0x00, 0x00, 0x00,
    };

-    usb_buf[0x03] = channel;
+    int             actual;

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    usb_buf[0x02] = channel;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);

    ret_string.append((char *)&usb_buf[0x08]);

@@ -109,7 +85,6 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()

    unsigned char usb_buf[] =
    {
-        0x00,
        0x12, 0x20, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -128,10 +103,11 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
        0x00, 0x00, 0x00, 0x00,
    };

+    int             actual;
    unsigned char   fw_buf[16] = {0x00};

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);

    for(int char_idx = 0; char_idx < 16; char_idx+=2)
    {
@@ -150,11 +126,10 @@ std::string AMDWraithPrismController::GetFirmwareVersionString()
    return(ret_string);
 }

-void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
+void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, bool random_color)
 {
    current_fan_mode            = mode;
    current_fan_speed           = speed_values_fan_logo[mode][speed];
-    current_fan_brightness      = brightness;
    current_fan_random_color    = random_color;
 }

@@ -167,18 +142,17 @@ void AMDWraithPrismController::SetFanColor(unsigned char red, unsigned char gree
        false,
        current_fan_random_color,
        current_fan_mode,
-        current_fan_brightness,
+        max_brightness_fan_logo[current_fan_mode],
        red,
        green,
        blue
    );
 }

-void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color)
+void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, bool random_color)
 {
    current_logo_mode           = mode;
    current_logo_speed          = speed_values_fan_logo[mode][speed];
-    current_logo_brightness     = brightness;
    current_logo_random_color   = random_color;
 }

@@ -191,19 +165,18 @@ void AMDWraithPrismController::SetLogoColor(unsigned char red, unsigned char gre
        false,
        current_logo_random_color,
        current_logo_mode,
-        current_logo_brightness,
+        max_brightness_fan_logo[current_logo_mode],
        red,
        green,
        blue
    );
 }

-void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color)
+void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color)
 {
    current_ring_mode           = mode;
    current_ring_speed          = speed_values_ring[mode][speed];
    current_ring_direction      = direction;
-    current_ring_brightness     = brightness;
    current_ring_random_color   = random_color;
 }

@@ -218,7 +191,7 @@ void AMDWraithPrismController::SetRingColor(unsigned char red, unsigned char gre
        current_ring_direction,
        current_ring_random_color,
        mode_value_ring[current_ring_mode],
-        current_ring_brightness,
+        max_brightness_ring[current_ring_mode],
        red,
        green,
        blue
@@ -236,7 +209,6 @@ void AMDWraithPrismController::SendEnableCommand()
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x41, 0x80, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -255,15 +227,16 @@ void AMDWraithPrismController::SendEnableCommand()
        0x00, 0x00, 0x00, 0x00,
    };

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    int             actual;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }

 void AMDWraithPrismController::SendApplyCommand()
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x51, 0x28, 0x00, 0x00,
        0xE0, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
@@ -282,8 +255,10 @@ void AMDWraithPrismController::SendApplyCommand()
        0x00, 0x00, 0x00, 0x00,
    };

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    int             actual;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }

 void AMDWraithPrismController::SendEffectChannelUpdate
@@ -301,7 +276,6 @@ void AMDWraithPrismController::SendEffectChannelUpdate
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x51, 0x2C, 0x01, 0x00,
        0x05, 0xFF, 0x00, 0x01,
        0xFF, 0xFF, 0x00, 0xFF,
@@ -320,26 +294,27 @@ void AMDWraithPrismController::SendEffectChannelUpdate
        0xFF, 0xFF, 0xFF, 0xFF
    };

-    usb_buf[0x05]   = effect_channel;
-    usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
-    usb_buf[0x08]   = mode;
+    int             actual;

-    usb_buf[0x0A]   = brightness;
+    usb_buf[0x04]   = effect_channel;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
+    usb_buf[0x07]   = mode;

-    usb_buf[0x0B]   = red;
-    usb_buf[0x0C]   = green;
-    usb_buf[0x0D]   = blue;
+    usb_buf[0x09]   = brightness;

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    usb_buf[0x0A]   = red;
+    usb_buf[0x0B]   = green;
+    usb_buf[0x0C]   = blue;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }

 void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsigned char logo_channel, unsigned char fan_channel)
 {
    unsigned char usb_buf[] =
    {
-        0x00,
        0x51, 0xA0, 0x01, 0x00,
        0x00, 0x03, 0x00, 0x00,
        0x05, 0x06, 0x07, 0x07,
@@ -358,14 +333,16 @@ void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsi
        0x00, 0x00, 0x00, 0x00,
    };

-    usb_buf[0x09] = logo_channel;
-    usb_buf[0x0A] = fan_channel;
+    int             actual;

-    for(int led = 0x0B; led <= 0x19; led++)
+    usb_buf[0x08] = logo_channel;
+    usb_buf[0x09] = fan_channel;
+
+    for(int led = 0x0A; led <= 0x18; led++)
    {
        usb_buf[led] = ring_channel;
    }

-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
 }
@@ -8,12 +8,17 @@
 \*-----------------------------------------*/

 #include <string>
-#include <hidapi/hidapi.h>
+#include <libusb-1.0/libusb.h>

 #pragma once

-#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX     0xFF
-#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX       0x7F
+static const unsigned char max_brightness_fan_logo[] =
+{
+    0x00,
+    0xFF,
+    0x7F,
+    0xFF
+};

 static const unsigned char speed_values_fan_logo[][5] =
 {
@@ -23,6 +28,22 @@ static const unsigned char speed_values_fan_logo[][5] =
    { 0x3C, 0x37, 0x31, 0x2C, 0x26 },                  /* Breathing                    */
 };

+static const unsigned char max_brightness_ring[] =
+{
+    0xFF,
+    0xFF,
+    0x7F,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF
+};
+
 static const unsigned char mode_value_ring[] =
 {
    0xFF,
@@ -88,45 +109,39 @@ enum
 class AMDWraithPrismController
 {
 public:
-    AMDWraithPrismController(hid_device* dev_handle, const char* path);
+    AMDWraithPrismController(libusb_device_handle* dev_handle);
    ~AMDWraithPrismController();

    char* GetDeviceName();

    std::string GetEffectChannelString(unsigned char channel);
    std::string GetFirmwareVersionString();
-    std::string GetLocationString();
-    std::string GetSerialString();

    void SetRingEffectChannel(unsigned char channel);

-    void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetFanMode(unsigned char mode, unsigned char speed, bool random_color);
    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);

-    void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
+    void SetLogoMode(unsigned char mode, unsigned char speed, bool random_color);
    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);

-    void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
+    void SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color);
    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);

 private:
    char                    device_name[32];
-    hid_device*             dev;
-    std::string             location;
+    libusb_device_handle*   dev;

    unsigned char           current_fan_mode;
    unsigned char           current_fan_speed;
-    unsigned char           current_fan_brightness;
    bool                    current_fan_random_color;

    unsigned char           current_logo_mode;
    unsigned char           current_logo_speed;
-    unsigned char           current_logo_brightness;
    bool                    current_logo_random_color;

    unsigned char           current_ring_mode;
    unsigned char           current_ring_speed;
-    unsigned char           current_ring_brightness;
    bool                    current_ring_direction;
    bool                    current_ring_random_color;

@@ -1,8 +1,8 @@
-#include "Detector.h"
 #include "AMDWraithPrismController.h"
 #include "RGBController.h"
 #include "RGBController_AMDWraithPrism.h"
-#include <hidapi/hidapi.h>
+#include <vector>
+#include <libusb-1.0/libusb.h>

 #define AMD_WRAITH_PRISM_VID 0x2516
 #define AMD_WRAITH_PRISM_PID 0x0051
@@ -15,16 +15,23 @@
 *                                                                                          *
 \******************************************************************************************/

-void DetectAMDWraithPrismControllers(hid_device_info* info, const std::string&)
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
 {
-    hid_device* dev = hid_open_path(info->path);
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for AMD Wraith Prism
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+
    if( dev )
    {
-        AMDWraithPrismController*     controller     = new AMDWraithPrismController(dev, info->path);
+        libusb_detach_kernel_driver(dev, 1);
+        libusb_claim_interface(dev, 1);
+
+        AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
+
        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
+
+        rgb_controllers.push_back(rgb_controller);
    }
 }
-
-REGISTER_HID_DETECTOR_IP("AMD Wraith Prism", DetectAMDWraithPrismControllers, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID, 1, 0xFF00);
@@ -1,282 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AMDWraithPrism.cpp         |
-|                                           |
-|  Generic RGB Interface for AMD Wraith     |
-|  Prism                                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController_AMDWraithPrism.h"
-
-/**------------------------------------------------------------------*\
-    @name AMD Wraith Prism
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :warning:
-    @detectors DetectAMDWraithPrismControllers
-    @comment The Wraith Prism comes with 2 cables but is only detectable
-        and controlable when using the USB cable. `Morse Code` and `Mirage`
-        modes have not been implemented. Saving to flash is supported by
-        the device but not yet implemented.
-\*-------------------------------------------------------------------*/
-
-RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* 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();
-    /*-----------------------------------------------------*\
-    | Don't use HID serial string, it is inconsistent on my |
-    | Wraith Prism                                          |
-    \*-----------------------------------------------------*/
-    serial      = "";//controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = 0;
-    Direct.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Direct.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.speed_min         = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Breathing.speed_max         = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Breathing.brightness_min    = 0;
-    Breathing.brightness_max    = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.brightness        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
-    Breathing.speed             = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name             = "Color Cycle";
-    ColorCycle.value            = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    ColorCycle.speed_min        = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    ColorCycle.speed_max        = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    ColorCycle.brightness_min   = 0;
-    ColorCycle.brightness_max   = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
-    ColorCycle.brightness       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_CYCLE_MAX;
-    ColorCycle.color_mode       = MODE_COLORS_NONE;
-    ColorCycle.speed            = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(ColorCycle);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow";
-    Rainbow.value               = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.speed_min           = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Rainbow.speed_max           = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Rainbow.brightness_min      = 0;
-    Rainbow.brightness_max      = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Rainbow.brightness          = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
-    Rainbow.color_mode          = MODE_COLORS_NONE;
-    Rainbow.speed               = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(Rainbow);
-
-    mode Bounce;
-    Bounce.name                 = "Bounce";
-    Bounce.value                = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
-    Bounce.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Bounce.speed_min            = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Bounce.speed_max            = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Bounce.brightness_min       = 0;
-    Bounce.brightness_max       = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Bounce.brightness           = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;    //The Ring zone can not get brighter but Logo / Fan can
-    Bounce.color_mode           = MODE_COLORS_NONE;
-    Bounce.speed                = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(Bounce);
-
-    mode Chase;
-    Chase.name                  = "Chase";
-    Chase.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
-    Chase.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Chase.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Chase.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Chase.brightness_min        = 0;
-    Chase.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Chase.color_mode            = MODE_COLORS_PER_LED;
-    Chase.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(Chase);
-
-    mode Swirl;
-    Swirl.name                  = "Swirl";
-    Swirl.value                 = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
-    Swirl.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Swirl.speed_min             = AMD_WRAITH_PRISM_SPEED_SLOWEST;
-    Swirl.speed_max             = AMD_WRAITH_PRISM_SPEED_FASTEST;
-    Swirl.brightness_min        = 0;
-    Swirl.brightness_max        = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.brightness            = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
-    Swirl.color_mode            = MODE_COLORS_PER_LED;
-    Swirl.speed                 = AMD_WRAITH_PRISM_SPEED_NORMAL;
-    modes.push_back(Swirl);
-
-    SetupZones();
-}
-
-RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
-{
-    delete controller;
-}
-
-void RGBController_AMDWraithPrism::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    zone logo_zone;
-    logo_zone.name          = "Logo";
-    logo_zone.type          = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min      = 1;
-    logo_zone.leds_max      = 1;
-    logo_zone.leds_count    = 1;
-    logo_zone.matrix_map    = NULL;
-    zones.push_back(logo_zone);
-
-    zone fan_zone;
-    fan_zone.name           = "Fan";
-    fan_zone.type           = ZONE_TYPE_SINGLE;
-    fan_zone.leds_min       = 1;
-    fan_zone.leds_max       = 1;
-    fan_zone.leds_count     = 1;
-    fan_zone.matrix_map     = NULL;
-    zones.push_back(fan_zone);
-
-    zone ring_zone;
-    ring_zone.name          = "Ring";
-    ring_zone.type          = ZONE_TYPE_SINGLE;
-    ring_zone.leds_min      = 1;
-    ring_zone.leds_max      = 1;
-    ring_zone.leds_count    = 1;
-    ring_zone.matrix_map    = NULL;
-    zones.push_back(ring_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LEDs                                               |
-    \*---------------------------------------------------------*/
-    led logo_led;
-    logo_led.name = "Logo LED";
-    leds.push_back(logo_led);
-
-    led fan_led;
-    fan_led.name = "Fan LED";
-    leds.push_back(fan_led);
-
-    led ring_led;
-    ring_led.name = "Ring LED";
-    leds.push_back(ring_led);
-
-    SetupColors();
-}
-
-void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
-{
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    controller->SetLogoColor(red, grn, blu);
-
-    red = RGBGetRValue(colors[1]);
-    grn = RGBGetGValue(colors[1]);
-    blu = RGBGetBValue(colors[1]);
-    controller->SetFanColor(red, grn, blu);
-
-    red = RGBGetRValue(colors[2]);
-    grn = RGBGetGValue(colors[2]);
-    blu = RGBGetBValue(colors[2]);
-    controller->SetRingColor(red, grn, blu);
-}
-
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
-{
-    RGBColor      color = colors[zone];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
-
-    if(zone == 0)
-    {
-        controller->SetLogoColor(red, grn, blu);
-    }
-    else if(zone == 1)
-    {
-        controller->SetFanColor(red, grn, blu);
-    }
-    else if(zone == 2)
-    {
-        controller->SetRingColor(red, grn, blu);
-    }
-}
-
-void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
-{
-    UpdateZoneLEDs(led);
-}
-
-void RGBController_AMDWraithPrism::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AMDWraithPrism::DeviceUpdateMode()
-{
-    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-
-    controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
-
-    switch(modes[active_mode].value)
-    {
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
-            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
-            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
-            break;
-
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
-            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
-            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
-            break;
-        
-        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
-            controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
-            controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
-            break;
-
-        default:
-            if(random)
-            {
-                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
-                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
-            }
-            else
-            {
-                controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
-                controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
-            }
-            break;
-    }
-
-    DeviceUpdateLEDs();
-}
@@ -1,353 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeSMBusController.cpp      |
-|                                           |
-|  Driver for for ASRock ASR LED and        |
-|  Polychrome RGB lighting controller       |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/14/2019  |
-\*-----------------------------------------*/
-
-#include "ASRockPolychromeSMBusController.h"
-#include <cstring>
-#include "dependencies/dmiinfo.h"
-#include "LogManager.h"
-
-#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN    "[%s] Zone %i LED count: %02d"
-
-using namespace std::chrono_literals;
-
-PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    DMIInfo dmi;
-
-    device_name =   "ASRock " + dmi.getMainboard();
-    fw_version =    ReadFirmwareVersion();
-    unsigned char   major_version = fw_version >> 8;
-
-    /*-----------------------------------------------------*\
-    | Determine whether the device uses ASR LED or          |
-    | Polychrome protocol by checking firmware version.     |
-    | Versions: 1.xx are ASR RGB LED                        |
-    |           2.xx are Polychrome v1                      |
-    |           3.xx are Polychrome v2                      |
-    \*-----------------------------------------------------*/
-    switch(major_version)
-    {
-        case ASROCK_TYPE_ASRLED:
-            LOG_TRACE("[%s] Device type is ASR RGB LED", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_ASRLED;
-            memset(zone_led_count, 0, sizeof(zone_led_count));
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            LOG_TRACE("[%s] Device type is Polychrome v1", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_POLYCHROME_V1;
-            ReadLEDConfiguration();
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            LOG_TRACE("[%s] Device type is Polychrome v2", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_POLYCHROME_V2;
-            ReadLEDConfiguration();
-            break;
-
-        default:
-            LOG_TRACE("[%s] Got Unknown version!", ASROCK_CONTROLLER_NAME);
-            asrock_type = ASROCK_TYPE_UNKNOWN;
-            break;
-    }
-}
-
-PolychromeController::~PolychromeController()
-{
-
-}
-
-unsigned int PolychromeController::GetASRockType()
-{
-    return(asrock_type);
-}
-
-std::string PolychromeController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string PolychromeController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string PolychromeController::GetFirmwareVersion()
-{
-    unsigned char  major_version = fw_version >> 8;
-    unsigned char  minor_version = fw_version & 0xFF;
-
-    return(std::to_string(major_version) + "." + std::to_string(minor_version));
-}
-
-unsigned short PolychromeController::ReadFirmwareVersion()
-{
-    // The firmware register holds two bytes, so the first read should return 2
-    // If not, report invalid firmware revision FFFF
-    LOG_DEBUG("[%s] Reading back device firmware version", ASROCK_CONTROLLER_NAME);
-    // Version response array needs to be 32 bytes to prevent non ASRock board from stack smashing
-    unsigned char asrock_version[I2C_SMBUS_BLOCK_MAX] = { 0x00, 0x00 };
-    if (bus->i2c_smbus_read_block_data(dev, ASROCK_REG_FIRMWARE_VER, asrock_version) == 0x02)
-    {
-        unsigned char major = asrock_version[0];
-        unsigned char minor = asrock_version[1];
-
-        LOG_DEBUG("[%s] Device firmware version: v%02d.%02d", ASROCK_CONTROLLER_NAME, major, minor);
-        return((major << 8) | minor);
-    }
-    else
-    {
-        LOG_WARNING("[%s] Firmware readback failed; Returning 0xFFFF", ASROCK_CONTROLLER_NAME);
-        return(0xFFFF);
-    }
-}
-
-void PolychromeController::ReadLEDConfiguration()
-{
-    /*---------------------------------------------------------------------------------*\
-    | The LED configuration register holds 6 bytes, so the first read should return 6   |
-    | If not, set all zone sizes to zero                                                |
-    \*---------------------------------------------------------------------------------*/
-    LOG_DEBUG("[%s] Reading LED config from controller", ASROCK_CONTROLLER_NAME);
-    unsigned char asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-    if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_REG_LED_CONFIG, asrock_zone_count) == 0x06)
-    {
-        zone_led_count[POLYCHROME_ZONE_1]           = asrock_zone_count[0];
-        zone_led_count[POLYCHROME_ZONE_2]           = asrock_zone_count[1];
-        zone_led_count[POLYCHROME_ZONE_3]           = asrock_zone_count[2];
-        zone_led_count[POLYCHROME_ZONE_4]           = asrock_zone_count[3];
-        zone_led_count[POLYCHROME_ZONE_5]           = asrock_zone_count[4];
-        zone_led_count[POLYCHROME_ZONE_ADDRESSABLE] = asrock_zone_count[5];
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_1, zone_led_count[POLYCHROME_ZONE_1]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_2, zone_led_count[POLYCHROME_ZONE_2]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_3, zone_led_count[POLYCHROME_ZONE_3]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_4, zone_led_count[POLYCHROME_ZONE_4]);
-        LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, ASROCK_CONTROLLER_NAME, POLYCHROME_ZONE_5, zone_led_count[POLYCHROME_ZONE_5]);
-        LOG_DEBUG("[%s] Addressable Zone LED count: %02d", ASROCK_CONTROLLER_NAME, zone_led_count[POLYCHROME_ZONE_ADDRESSABLE]);
-    }
-    else
-    {
-        LOG_WARNING("[%s] LED config read failed", ASROCK_CONTROLLER_NAME);
-        memset(zone_led_count, 0, sizeof(zone_led_count));
-    }
-}
-
-unsigned int PolychromeController::GetMode()
-{
-    return(active_mode);
-}
-
-void PolychromeController::SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char color_speed_pkt[4] = { red, green, blue, active_speed };
-    unsigned char select_led_pkt[1]  = { led };
-    
-    switch(asrock_type)
-    {
-        case ASROCK_TYPE_ASRLED:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_BREATHING:
-                case ASRLED_MODE_STROBE:
-                case ASRLED_MODE_SPECTRUM_CYCLE:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 3 bytes in R/G/B order               |
-                \*-----------------------------------------------------*/
-                default:
-                case ASRLED_MODE_STATIC:
-                case ASRLED_MODE_MUSIC:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 1 byte - speed                       |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_RANDOM:
-                case ASRLED_MODE_WAVE:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case ASRLED_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            if(active_mode != ASRLED_MODE_OFF)
-            {
-                bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                std::this_thread::sleep_for(1ms);
-            }
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes take 4 bytes in R/G/B/S order             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_BREATHING:
-                case POLYCHROME_V1_MODE_STROBE:
-                case POLYCHROME_V1_MODE_SPECTRUM_CYCLE:
-                case POLYCHROME_V1_MODE_SPRING:
-                case POLYCHROME_V1_MODE_METEOR:
-                case POLYCHROME_V1_MODE_STACK:
-                case POLYCHROME_V1_MODE_CRAM:
-                case POLYCHROME_V1_MODE_SCAN:
-                case POLYCHROME_V1_MODE_NEON:
-                case POLYCHROME_V1_MODE_WATER:
-
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 3 bytes in R/G/B order               |
-                \*-----------------------------------------------------*/
-                default:
-                case POLYCHROME_V1_MODE_STATIC:
-                case POLYCHROME_V1_MODE_MUSIC:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take 1 byte - speed                       |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_RANDOM:
-                case POLYCHROME_V1_MODE_WAVE:
-                case POLYCHROME_V1_MODE_RAINBOW:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
-                    break;
-
-                /*-----------------------------------------------------*\
-                | These modes take no bytes                             |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V1_MODE_OFF:
-                    break;
-            }
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            /*-----------------------------------------------------*\
-            | Select LED                                            |
-            \*-----------------------------------------------------*/
-            switch(active_mode)
-            {
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_RAINBOW:
-                case POLYCHROME_V2_MODE_SPECTRUM_CYCLE:
-                    break;
-
-                default:
-                    bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, select_led_pkt);
-                    std::this_thread::sleep_for(1ms);
-
-                    /*-----------------------------------------------------*\
-                    | Polychrome firmware always writes color to fixed reg  |
-                    \*-----------------------------------------------------*/
-                    bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_COLOR, 3, color_speed_pkt);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
-    }
-}
-
-void PolychromeController::SetMode(unsigned char zone,unsigned char mode, unsigned char speed)
-{
-    unsigned char led_count_pkt[1]  = { 0x00 };
-    active_zone                     = zone;
-    active_mode                     = mode;
-    active_speed                    = speed;
-
-    switch(asrock_type)
-    {
-        case ASROCK_TYPE_ASRLED:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            /*-----------------------------------------------------*\
-            | Make sure set all register is set to 0                |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_SET_ALL, 1, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Set the zone we are working on                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_LED_SELECT, 1, &active_zone);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Write the mode                                        |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            bus->i2c_smbus_write_block_data(dev, ASROCK_REG_MODE, 1, &active_mode);
-            std::this_thread::sleep_for(1ms);
-
-            /*-----------------------------------------------------*\
-            | Select a single LED                                   |
-            \*-----------------------------------------------------*/
-            bus->i2c_smbus_write_block_data(dev, POLYCHROME_V2_REG_LED_COUNT, 0, led_count_pkt);
-            std::this_thread::sleep_for(1ms);
-
-            switch(active_mode)
-            {
-                /*-----------------------------------------------------*\
-                | These modes don't take a speed                        |
-                \*-----------------------------------------------------*/
-                case POLYCHROME_V2_MODE_OFF:
-                case POLYCHROME_V2_MODE_STATIC:
-                    break;
-
-                /*-----------------------------------------------------*\
-                | All other modes, write speed to active mode register  |
-                \*-----------------------------------------------------*/
-                default:
-                    bus->i2c_smbus_write_block_data(dev, active_mode, 1, &speed);
-                    std::this_thread::sleep_for(1ms);
-                    break;
-            }
-            break;
-    }    
-}
@@ -1,271 +0,0 @@
-/*-----------------------------------------*\
-|  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
-
-typedef unsigned char	polychrome_dev_id;
-
-#define ASROCK_CONTROLLER_NAME  "ASRock Polychrome SMBus Controller"
-#define ASROCK_DETECTOR_NAME    "ASRock Polychrome SMBus Detect"
-#define VENDOR_NAME             "ASRock"
-#define SMBUS_ADDRESS           0x6A
-
-enum
-{
-    ASROCK_TYPE_UNKNOWN                     = 0x00,     /* Unknown Type or Not ASRock Device    */
-    ASROCK_TYPE_ASRLED                      = 0x01,     /* ASRock Firmware 1.x - ASR LED        */
-    ASROCK_TYPE_POLYCHROME_V1               = 0x02,     /* ASRock Firmware 2.x - Polychrome V1  */
-    ASROCK_TYPE_POLYCHROME_V2               = 0x03,     /* ASRock Firmware 3.x - Polychrome V2  */
-};
-
-enum
-{
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Common Registers                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    ASROCK_REG_FIRMWARE_VER                 = 0x00,     /* Firmware version Major.Minor         */
-    ASROCK_REG_MODE                         = 0x30,     /* Mode selection register              */
-    ASROCK_REG_LED_SELECT                   = 0x31,     /* LED selection register               */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1/V2 Common Registers                                                   |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_REG_LED_CONFIG               = 0x33,     /* LED configuration register           */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V1 (Firmware 2.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_REG_SET_ALL               = 0x32,     /* Set All register 0x1 = set all       */
-    POLYCHROME_V1_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
-    /*------------------------------------------------------------------------------------------*\
-    | ASRock Polychrome V2 (Firmware 3.x) Registers                                              |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V2_REG_LED_COUNT             = 0x32,     /* Additional LED count register        */
-    POLYCHROME_V2_REG_COLOR                 = 0x34,     /* Color register: Red, Green, Blue     */
-    POLYCHROME_V2_REG_ARGB_GRB              = 0x35,     /* ARGB bistream reversing register     */
-};
-
-enum
-{
-    POLYCHROME_ZONE_1                       = 0x00,     /* RGB LED 1 Header                     */
-    POLYCHROME_ZONE_2                       = 0x01,     /* RGB LED 2 Header                     */
-    POLYCHROME_ZONE_3                       = 0x02,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_4                       = 0x03,     /* Audio/PCH Zone LEDs                  */
-    POLYCHROME_ZONE_5                       = 0x04,     /* IO Cover Zone LEDs                   */
-    POLYCHROME_ZONE_ADDRESSABLE             = 0x05,     /* Addressable LED header               */
-    POLYCHROME_ZONE_COUNT                   = 0x06,     /* Total number of zones                */
-    POLYCHROME_ZONE_ADDRESSABLE_MAX         = 0x64,     /* Maxinum number of ARGB LEDs          */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for ASR LED                                                                        |
-\*----------------------------------------------------------------------------------------------*/
-#define ASRLED_NUM_MODES                    8           /* Number of ASR LED modes              */
-
-enum
-{
-    ASRLED_MODE_OFF                         = 0x10,     /* OFF mode                             */
-    ASRLED_MODE_STATIC                      = 0x11,     /* Static color mode                    */
-    ASRLED_MODE_BREATHING                   = 0x12,     /* Breathing effect mode                */
-    ASRLED_MODE_STROBE                      = 0x13,     /* Strobe effect mode                   */
-    ASRLED_MODE_SPECTRUM_CYCLE              = 0x14,     /* Spectrum Cycle effect mode           */
-    ASRLED_MODE_RANDOM                      = 0x15,     /* Random effect mode                   */
-    ASRLED_MODE_MUSIC                       = 0x17,     /* Music effect mode                    */
-    ASRLED_MODE_WAVE                        = 0x18,     /* Wave effect mode                     */
-};
-
-enum
-{
-    ASRLED_SPEED_MIN                        = 0x05,     /* Slowest speed                        */
-    ASRLED_SPEED_DEFAULT                    = 0x03,     /* Default speed                        */
-    ASRLED_SPEED_MAX                        = 0x00,     /* Fastest speed                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V1                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V1_NUM_MODES             16          /* Number of Polychrome V1 modes        */
-
-enum
-{
-    POLYCHROME_V1_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V1_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V1_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V1_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V1_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V1_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V1_MODE_MUSIC                = 0x17,     /* Music effect mode                    */
-    POLYCHROME_V1_MODE_WAVE                 = 0x18,     /* Wave effect mode                     */
-    /*------------------------------------------------------------------------------------------*\
-    | Modes only available on ARGB headers                                                       |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_MODE_SPRING               = 0x19,     /* Spring effect mode                   */
-    POLYCHROME_V1_MODE_METEOR               = 0x1A,     /* Meteor effect mode                   */
-    POLYCHROME_V1_MODE_STACK                = 0x1B,     /* Stack effect mode                    */
-    POLYCHROME_V1_MODE_CRAM                 = 0x1C,     /* Cram effect mode                     */
-    POLYCHROME_V1_MODE_SCAN                 = 0x1D,     /* Scan effect mode                     */
-    POLYCHROME_V1_MODE_NEON                 = 0x1E,     /* Neon effect mode                     */
-    POLYCHROME_V1_MODE_WATER                = 0x1F,     /* Water effect mode                    */
-    POLYCHROME_V1_MODE_RAINBOW              = 0x20,     /* Rainbow chase effect mode            */
-};
-
-enum
-{
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_BREATHING                                                               |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_BREATHING       = 0x0A,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_BREATHING   = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_BREATHING       = 0x02,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_STROBE                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_STROBE          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STROBE      = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_STROBE          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_SPECTRUM_CYCLE                                                          |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_CYCLE           = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CYCLE       = 0x14,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_CYCLE           = 0x0A,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RANDOM                                                                  |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RANDOM          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RANDOM      = 0x28,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RANDOM          = 0x05,     /* Fastest speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_WAVE                                                                    |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_WAVE            = 0x06,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WAVE        = 0x02,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_WAVE            = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SPRING      = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_METEOR      = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_STACK       = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_CRAM        = 0x04,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_SCAN        = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_NEON        = 0x20,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_WATER       = 0x0A,     /* Default speed                        */
-    /*------------------------------------------------------------------------------------------*\
-    | POLYCHROME_V1_MODE_RAINBOW                                                                 |
-    \*------------------------------------------------------------------------------------------*/
-    POLYCHROME_V1_SPEED_MIN_RAINBOW         = 0x12,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_DEFAULT_RAINBOW     = 0x0A,     /* Default speed                        */
-    POLYCHROME_V1_SPEED_MAX_RAINBOW         = 0x01,     /* Fastest speed                        */
-    POLYCHROME_V1_SPEED_MIN_ARGB            = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V1_SPEED_MAX_ARGB            = 0x02,     /* Fastest speed                        */
-};
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome V2                                                                  |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_V2_NUM_MODES             14          /* Number of Polychrome V2 modes        */
-
-enum
-{
-    POLYCHROME_V2_MODE_OFF                  = 0x10,     /* OFF mode                             */
-    POLYCHROME_V2_MODE_STATIC               = 0x11,     /* Static color mode                    */
-    POLYCHROME_V2_MODE_BREATHING            = 0x12,     /* Breating effect mode                 */
-    POLYCHROME_V2_MODE_STROBE               = 0x13,     /* Strobe effect mode                   */
-    POLYCHROME_V2_MODE_SPECTRUM_CYCLE       = 0x14,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_V2_MODE_RANDOM               = 0x15,     /* Random effect mode                   */
-    POLYCHROME_V2_MODE_WAVE                 = 0x17,     /* Wave effect mode                     */
-    POLYCHROME_V2_MODE_SPRING               = 0x18,     /* Spring effect mode                   */
-    POLYCHROME_V2_MODE_STACK                = 0x19,     /* Stack effect mode                    */
-    POLYCHROME_V2_MODE_CRAM                 = 0x1A,     /* Cram effect mode                     */
-    POLYCHROME_V2_MODE_SCAN                 = 0x1B,     /* Scan effect mode                     */
-    POLYCHROME_V2_MODE_NEON                 = 0x1C,     /* Neon effect mode                     */
-    POLYCHROME_V2_MODE_WATER                = 0x1D,     /* Water effect mode                    */
-    POLYCHROME_V2_MODE_RAINBOW              = 0x1E,     /* Rainbow effect mode                  */
-};
-
-enum
-{
-    POLYCHROME_V2_BREATHING_SPEED_MIN               = 0x0A,     /* Slowest speed                        */
-    POLYCHROME_V2_BREATHING_SPEED_DEFAULT           = 0x06,     /* Default speed                        */
-    POLYCHROME_V2_BREATHING_SPEED_MAX               = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_STROBE_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_STROBE_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
-    POLYCHROME_V2_STROBE_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN          = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT      = 0x50,     /* Default speed                        */
-    POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX          = 0x0A,     /* Fastest speed                        */
-
-    POLYCHROME_V2_RANDOM_SPEED_MIN                  = 0xA0,     /* Slowest speed                        */
-    POLYCHROME_V2_RANDOM_SPEED_DEFAULT              = 0x4D,     /* Default speed                        */
-    POLYCHROME_V2_RANDOM_SPEED_MAX                  = 0x05,     /* Fastest speed                        */
-
-    POLYCHROME_V2_WAVE_SPEED_MIN                    = 0x06,     /* Slowest speed                        */
-    POLYCHROME_V2_WAVE_SPEED_DEFAULT                = 0x03,     /* Default speed                        */
-    POLYCHROME_V2_WAVE_SPEED_MAX                    = 0x01,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SPRING_SPEED_MIN                  = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_SPRING_SPEED_DEFAULT              = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_SPRING_SPEED_MAX                  = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_STACK_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_STACK_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_STACK_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_CRAM_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_CRAM_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_CRAM_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_SCAN_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_SCAN_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_SCAN_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_NEON_SPEED_MIN                    = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_NEON_SPEED_DEFAULT                = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_NEON_SPEED_MAX                    = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_WATER_SPEED_MIN                   = 0x20,     /* Slowest speed                        */
-    POLYCHROME_V2_WATER_SPEED_DEFAULT               = 0x11,     /* Default speed                        */
-    POLYCHROME_V2_WATER_SPEED_MAX                   = 0x02,     /* Fastest speed                        */
-
-    POLYCHROME_V2_RAINBOW_SPEED_MIN                 = 0x12,     /* Slowest speed                        */
-    POLYCHROME_V2_RAINBOW_SPEED_DEFAULT             = 0x08,     /* Default speed                        */
-    POLYCHROME_V2_RAINBOW_SPEED_MAX                 = 0x02,     /* Fastest speed                        */
-};
-
-class PolychromeController
-{
-public:
-    PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev);
-    ~PolychromeController();
-
-    std::string     GetDeviceLocation();
-    std::string     GetDeviceName();
-    std::string     GetFirmwareVersion();
-    unsigned int    GetMode();
-    unsigned int    GetASRockType();
-    void            SetColorsAndSpeed(unsigned char led, unsigned char red, unsigned char green, unsigned char blue);
-    void            SetMode(unsigned char zone, unsigned char mode, unsigned char speed);
-
-    unsigned char           zone_led_count[6];
-    
-private:
-    unsigned int            asrock_type;
-    unsigned short          fw_version;
-    std::string             device_name;
-    unsigned char           active_zone;
-    unsigned char           active_mode;
-    unsigned char           active_speed;
-    i2c_smbus_interface*    bus;
-    polychrome_dev_id       dev;
-
-    unsigned short  ReadFirmwareVersion();
-    void            ReadLEDConfiguration();
-};
@@ -1,89 +0,0 @@
-#include "Detector.h"
-#include "ASRockPolychromeSMBusController.h"
-#include "LogManager.h"
-#include "RGBController.h"
-#include "RGBController_ASRockPolychromeSMBus.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForPolychromeSMBusController                                                       *
-*                                                                                          *
-*       Tests the given address to see if an ASRock Polychrome RGB controller exists there.*
-*       First does a quick write to test for a response                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-    }
-
-    return(pass);
-
-}   /* TestForPolychromeController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectPolychromeControllers                                                            *
-*                                                                                          *
-*       Detect ASRock Polychrome RGB SMBus controllers on the enumerated I2C busses at     *
-*       address 0x6A.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
-*           dev - I2C address of Polychrome device                                         *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
-{
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
-        {
-            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
-            {
-                LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
-                // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
-                {
-                    LOG_DEBUG("[%s] Detected a device at address %02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
-                    PolychromeController* controller = new PolychromeController(busses[bus], SMBUS_ADDRESS);
-
-                    if(controller->GetASRockType() != ASROCK_TYPE_UNKNOWN)
-                    {
-                        LOG_DEBUG("[%s] Found a known Polychrome device", ASROCK_DETECTOR_NAME);
-                        RGBController_Polychrome* rgb_controller = new RGBController_Polychrome(controller);
-                        ResourceManager::get()->RegisterRGBController(rgb_controller);
-                    }
-                    else
-                    {
-                        LOG_DEBUG("[%s] Not a Polychrome device or unknown type", ASROCK_DETECTOR_NAME);
-                        delete controller;
-                    }
-                }
-                else
-                {
-                    LOG_DEBUG("[%s] Bus %02d no response at %02X", ASROCK_DETECTOR_NAME, bus, SMBUS_ADDRESS);
-                }
-            }
-            else
-            {
-                LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME);
-            } 
-        }
-    }
-
-}   /* DetectSMBusPolychromeControllers() */
-
-REGISTER_I2C_DETECTOR("ASRock Polychrome SMBus", DetectPolychromeSMBusControllers);
@@ -1,656 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeSMBus.cpp  |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock ASR LED and Polychrome RGB Driver |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/15/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController_ASRockPolychromeSMBus.h"
-
-#define ASROCK_MAX_ZONES    4
-#define ASROCK_MAX_LEDS     22
-
-static const char* polychrome_v1_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "PCH",
-    "IO Cover",
-    "Audio",
-    "Addressable Header"
-};
-
-static const char* polychrome_v2_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Audio",
-    "PCH",
-    "IO Cover",
-    "Addressable Header"
-};
-
-/**------------------------------------------------------------------*\
-    @name ASRock Polychrome SMBus
-    @type SMBus
-    @save :warning:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectPolychromeSMBusControllers
-    @comment ASRock Polychrome controllers will save with each update.
-        Per ARGB LED support is not possible with these devices.
-\*-------------------------------------------------------------------*/
-
-RGBController_Polychrome::RGBController_Polychrome(PolychromeController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "ASRock";
-    version     = controller->GetFirmwareVersion();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    location    = controller->GetDeviceLocation();
-
-    switch(controller->GetASRockType())
-    {
-        case ASROCK_TYPE_ASRLED:
-            {
-                description = "ASRock ASR RGB LED Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = ASRLED_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = ASRLED_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = ASRLED_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = ASRLED_SPEED_MIN;
-                Breathing.speed_max         = ASRLED_SPEED_MAX;
-                Breathing.speed             = ASRLED_SPEED_DEFAULT;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = ASRLED_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = ASRLED_SPEED_MIN;
-                Strobe.speed_max            = ASRLED_SPEED_MAX;
-                Strobe.speed                = ASRLED_SPEED_DEFAULT;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = ASRLED_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = ASRLED_SPEED_MIN;
-                SpectrumCycle.speed_max     = ASRLED_SPEED_MAX;
-                SpectrumCycle.speed         = ASRLED_SPEED_DEFAULT;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = ASRLED_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = ASRLED_SPEED_MIN;
-                Random.speed_max            = ASRLED_SPEED_MAX;
-                Random.speed                = ASRLED_SPEED_DEFAULT;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name                  = "Music";
-                Music.value                 = ASRLED_MODE_MUSIC;
-                Music.flags                 = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = ASRLED_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = ASRLED_SPEED_MIN;
-                Wave.speed_max              = ASRLED_SPEED_MAX;
-                Wave.speed                  = ASRLED_SPEED_DEFAULT;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V1:
-            {
-                description = "ASRock Polychrome v1 Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = POLYCHROME_V1_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = POLYCHROME_V1_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = POLYCHROME_V1_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = POLYCHROME_V1_SPEED_MIN_BREATHING;
-                Breathing.speed_max         = POLYCHROME_V1_SPEED_MAX_BREATHING;
-                Breathing.speed             = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = POLYCHROME_V1_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = POLYCHROME_V1_SPEED_MIN_STROBE;
-                Strobe.speed_max            = POLYCHROME_V1_SPEED_MAX_STROBE;
-                Strobe.speed                = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = POLYCHROME_V1_SPEED_MIN_CYCLE;
-                SpectrumCycle.speed_max     = POLYCHROME_V1_SPEED_MAX_CYCLE;
-                SpectrumCycle.speed         = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = POLYCHROME_V1_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = POLYCHROME_V1_SPEED_MIN_RANDOM;
-                Random.speed_max            = POLYCHROME_V1_SPEED_MAX_RANDOM;
-                Random.speed                = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Music;
-                Music.name                 = "Music";
-                Music.value                = POLYCHROME_V1_MODE_MUSIC;
-                Music.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Music.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Music);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = POLYCHROME_V1_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = POLYCHROME_V1_SPEED_MIN_WAVE;
-                Wave.speed_max              = POLYCHROME_V1_SPEED_MAX_WAVE;
-                Wave.speed                  = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                /*---------------------------------------------------------------------*\
-                | Comment out until per zone modes are working. These are only for ARGB |
-                \*---------------------------------------------------------------------*/
-                /*
-                mode Spring;
-                Spring.name                 = "Spring";
-                Spring.value                = POLYCHROME_V1_MODE_SPRING;
-                Spring.flags                = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min            = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Spring.speed_max            = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Spring.speed                = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
-                Spring.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Spring);
-
-                mode Stack;
-                Stack.name                  = "Stack";
-                Stack.value                 = POLYCHROME_V1_MODE_STACK;
-                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Stack.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Stack.speed                 = POLYCHROME_V1_SPEED_DEFAULT_STACK;
-                Stack.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Stack);
-
-                mode Cram;
-                Cram.name                   = "Cram";
-                Cram.value                  = POLYCHROME_V1_MODE_CRAM;
-                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Cram.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Cram.speed                  = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
-                Cram.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Cram);
-
-                mode Scan;
-                Scan.name                   = "Scan";
-                Scan.value                  = POLYCHROME_V1_MODE_SCAN;
-                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Scan.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Scan.speed                  = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
-                Scan.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Scan);
-
-                mode Neon;
-                Neon.name                   = "Neon";
-                Neon.value                  = POLYCHROME_V1_MODE_NEON;
-                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-                Neon.speed_min              = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Neon.speed_max              = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Neon.speed                  = POLYCHROME_V1_SPEED_DEFAULT_NEON;
-                Neon.color_mode             = MODE_COLORS_PER_LED;
-                modes.push_back(Neon);
-
-                mode Water;
-                Water.name                  = "Water";
-                Water.value                 = POLYCHROME_V1_MODE_WATER;
-                Water.flags                 = MODE_FLAG_HAS_SPEED;
-                Water.speed_min             = POLYCHROME_V1_SPEED_MIN_ARGB;
-                Water.speed_max             = POLYCHROME_V1_SPEED_MAX_ARGB;
-                Water.speed                 = POLYCHROME_V1_SPEED_DEFAULT_WATER;
-                Water.color_mode            = MODE_COLORS_PER_LED;
-                modes.push_back(Water);
-
-                mode Rainbow;
-                Rainbow.name                = "Rainbow";
-                Rainbow.value               = POLYCHROME_V1_MODE_RAINBOW;
-                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min           = POLYCHROME_V1_SPEED_MIN_RAINBOW;
-                Rainbow.speed_max           = POLYCHROME_V1_SPEED_MAX_RAINBOW;
-                Rainbow.speed               = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
-                Rainbow.color_mode          = MODE_COLORS_NONE;
-                modes.push_back(Rainbow);
-                */
-            }
-            break;
-
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                description = "ASRock Polychrome v2 Device";
-
-                mode Off;
-                Off.name                    = "Off";
-                Off.value                   = POLYCHROME_V2_MODE_OFF;
-                Off.flags                   = 0;
-                Off.color_mode              = MODE_COLORS_NONE;
-                modes.push_back(Off);
-
-                mode Static;
-                Static.name                 = "Static";
-                Static.value                = POLYCHROME_V2_MODE_STATIC;
-                Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-                Static.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Static);
-
-                mode Breathing;
-                Breathing.name              = "Breathing";
-                Breathing.value             = POLYCHROME_V2_MODE_BREATHING;
-                Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Breathing.speed_min         = POLYCHROME_V2_BREATHING_SPEED_MIN;
-                Breathing.speed_max         = POLYCHROME_V2_BREATHING_SPEED_MAX;
-                Breathing.speed             = POLYCHROME_V2_BREATHING_SPEED_DEFAULT;
-                Breathing.color_mode        = MODE_COLORS_PER_LED;
-                modes.push_back(Breathing);
-
-                mode Strobe;
-                Strobe.name                 = "Strobe";
-                Strobe.value                = POLYCHROME_V2_MODE_STROBE;
-                Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-                Strobe.speed_min            = POLYCHROME_V2_STROBE_SPEED_MIN;
-                Strobe.speed_max            = POLYCHROME_V2_STROBE_SPEED_MAX;
-                Strobe.speed                = POLYCHROME_V2_STROBE_SPEED_DEFAULT;
-                Strobe.color_mode           = MODE_COLORS_PER_LED;
-                modes.push_back(Strobe);
-
-                mode SpectrumCycle;
-                SpectrumCycle.name          = "Spectrum Cycle";
-                SpectrumCycle.value         = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
-                SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-                SpectrumCycle.speed_min     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MIN;
-                SpectrumCycle.speed_max     = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_MAX;
-                SpectrumCycle.speed         = POLYCHROME_V2_SPECTRUM_CYCLE_SPEED_DEFAULT;
-                SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-                modes.push_back(SpectrumCycle);
-
-                mode Random;
-                Random.name                 = "Random";
-                Random.value                = POLYCHROME_V2_MODE_RANDOM;
-                Random.flags                = MODE_FLAG_HAS_SPEED;
-                Random.speed_min            = POLYCHROME_V2_RANDOM_SPEED_MIN;
-                Random.speed_max            = POLYCHROME_V2_RANDOM_SPEED_MAX;
-                Random.speed                = POLYCHROME_V2_RANDOM_SPEED_DEFAULT;
-                Random.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Random);
-
-                mode Wave;
-                Wave.name                   = "Wave";
-                Wave.value                  = POLYCHROME_V2_MODE_WAVE;
-                Wave.flags                  = MODE_FLAG_HAS_SPEED;
-                Wave.speed_min              = POLYCHROME_V2_WAVE_SPEED_MIN;
-                Wave.speed_max              = POLYCHROME_V2_WAVE_SPEED_MAX;
-                Wave.speed                  = POLYCHROME_V2_WAVE_SPEED_DEFAULT;
-                Wave.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Wave);
-
-                mode Spring;
-                Spring.name                 = "Spring";
-                Spring.value                = POLYCHROME_V2_MODE_SPRING;
-                Spring.flags                = MODE_FLAG_HAS_SPEED;
-                Spring.speed_min            = POLYCHROME_V2_SPRING_SPEED_MIN;
-                Spring.speed_max            = POLYCHROME_V2_SPRING_SPEED_MAX;
-                Spring.speed                = POLYCHROME_V2_SPRING_SPEED_DEFAULT;
-                Spring.color_mode           = MODE_COLORS_NONE;
-                modes.push_back(Spring);
-
-                mode Stack;
-                Stack.name                  = "Stack";
-                Stack.value                 = POLYCHROME_V2_MODE_STACK;
-                Stack.flags                 = MODE_FLAG_HAS_SPEED;
-                Stack.speed_min             = POLYCHROME_V2_STACK_SPEED_MIN;
-                Stack.speed_max             = POLYCHROME_V2_STACK_SPEED_MAX;
-                Stack.speed                 = POLYCHROME_V2_STACK_SPEED_DEFAULT;
-                Stack.color_mode            = MODE_COLORS_NONE;
-                modes.push_back(Stack);
-
-                mode Cram;
-                Cram.name                   = "Cram";
-                Cram.value                  = POLYCHROME_V2_MODE_CRAM;
-                Cram.flags                  = MODE_FLAG_HAS_SPEED;
-                Cram.speed_min              = POLYCHROME_V2_CRAM_SPEED_MIN;
-                Cram.speed_max              = POLYCHROME_V2_CRAM_SPEED_MAX;
-                Cram.speed                  = POLYCHROME_V2_CRAM_SPEED_DEFAULT;
-                Cram.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Cram);
-
-                mode Scan;
-                Scan.name                   = "Scan";
-                Scan.value                  = POLYCHROME_V2_MODE_SCAN;
-                Scan.flags                  = MODE_FLAG_HAS_SPEED;
-                Scan.speed_min              = POLYCHROME_V2_SCAN_SPEED_MIN;
-                Scan.speed_max              = POLYCHROME_V2_SCAN_SPEED_MAX;
-                Scan.speed                  = POLYCHROME_V2_SCAN_SPEED_DEFAULT;
-                Scan.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Scan);
-
-                mode Neon;
-                Neon.name                   = "Neon";
-                Neon.value                  = POLYCHROME_V2_MODE_NEON;
-                Neon.flags                  = MODE_FLAG_HAS_SPEED;
-                Neon.speed_min              = POLYCHROME_V2_NEON_SPEED_MIN;
-                Neon.speed_max              = POLYCHROME_V2_NEON_SPEED_MAX;
-                Neon.speed                  = POLYCHROME_V2_NEON_SPEED_DEFAULT;
-                Neon.color_mode             = MODE_COLORS_NONE;
-                modes.push_back(Neon);
-
-                mode Water;
-                Water.name                  = "Water";
-                Water.value                 = POLYCHROME_V2_MODE_WATER;
-                Water.flags                 = MODE_FLAG_HAS_SPEED;
-                Water.speed_min             = POLYCHROME_V2_WATER_SPEED_MIN;
-                Water.speed_max             = POLYCHROME_V2_WATER_SPEED_MAX;
-                Water.speed                 = POLYCHROME_V2_WATER_SPEED_DEFAULT;
-                Water.color_mode            = MODE_COLORS_NONE;
-                modes.push_back(Water);
-
-                mode Rainbow;
-                Rainbow.name                = "Rainbow";
-                Rainbow.value               = POLYCHROME_V2_MODE_RAINBOW;
-                Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-                Rainbow.speed_min           = POLYCHROME_V2_RAINBOW_SPEED_MIN;
-                Rainbow.speed_max           = POLYCHROME_V2_RAINBOW_SPEED_MAX;
-                Rainbow.speed               = POLYCHROME_V2_RAINBOW_SPEED_DEFAULT;
-                Rainbow.color_mode          = MODE_COLORS_NONE;
-                modes.push_back(Rainbow);
-            }
-            break;
-    }
-
-    SetupZones();
-}
-
-RGBController_Polychrome::~RGBController_Polychrome()
-{
-    delete controller;
-}
-
-void RGBController_Polychrome::SetupZones()
-{
-    switch(controller->GetASRockType())
-    {
-        /*---------------------------------------------------------*\
-        | ASR LED motherboards only have a single zone/LED          |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_ASRLED:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                zone* new_zone = new zone();
-
-                /*---------------------------------------------------------*\
-                | Set single zone name to "Motherboard"                     |
-                \*---------------------------------------------------------*/
-                new_zone->name          = "Motherboard";
-                new_zone->type          = ZONE_TYPE_SINGLE;
-                new_zone->leds_min      = 1;
-                new_zone->leds_max      = 1;
-                new_zone->leds_count    = 1;
-                new_zone->matrix_map    = NULL;
-
-                /*---------------------------------------------------------*\
-                | Push new zone to zones vector                             |
-                \*---------------------------------------------------------*/
-                zones.push_back(*new_zone);
-
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                led* new_led = new led();
-
-                /*---------------------------------------------------------*\
-                | Set single LED name to "Motherboard"                      |
-                \*---------------------------------------------------------*/
-                new_led->name           = "Motherboard";
-
-                /*---------------------------------------------------------*\
-                | Push new LED to LEDs vector                               |
-                \*---------------------------------------------------------*/
-                leds.push_back(*new_led);
-            }
-            break;
-
-        /*---------------------------------------------------------*\
-        | Polychrome motherboards should set up zones based on LED  |
-        | configuration register read from device                   |
-        \*---------------------------------------------------------*/
-        case ASROCK_TYPE_POLYCHROME_V1:
-        case ASROCK_TYPE_POLYCHROME_V2:
-            {
-                /*---------------------------------------------------------*\
-                | Set up zones                                              |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(controller->zone_led_count[zone_idx] > 0)
-                    {
-                        zone* new_zone = new zone();
-
-                        /*---------------------------------------------------------*\
-                        | Set zone name to channel name                             |
-                        \*---------------------------------------------------------*/
-                        if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                        {
-                            new_zone->name          = polychrome_v1_zone_names[zone_idx];
-                        }
-                        else
-                        {
-                            new_zone->name          = polychrome_v2_zone_names[zone_idx];
-                        }
-                        
-                        if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                        {
-                            new_zone->leds_min      = 1;
-                            new_zone->leds_max      = 1;
-                            new_zone->leds_count    = 1;
-                        }
-                        else
-                        {
-                            new_zone->leds_min      = controller->zone_led_count[zone_idx];
-                            new_zone->leds_max      = controller->zone_led_count[zone_idx];
-                            new_zone->leds_count    = controller->zone_led_count[zone_idx];
-                        }
-
-                        if(new_zone->leds_count > 1)
-                        {
-                            new_zone->type          = ZONE_TYPE_LINEAR;
-                        }
-                        else
-                        {
-                            new_zone->type          = ZONE_TYPE_SINGLE;
-                        }
-
-                        new_zone->matrix_map        = NULL;
-
-                        /*---------------------------------------------------------*\
-                        | Push new zone to zones vector                             |
-                        \*---------------------------------------------------------*/
-                        zones.push_back(*new_zone);
-                    }
-                }
-
-                unsigned int led_count = 0;
-                /*---------------------------------------------------------*\
-                | Set up LEDs                                               |
-                \*---------------------------------------------------------*/
-                for(unsigned int zone_idx = 0; zone_idx < POLYCHROME_ZONE_COUNT; zone_idx++)
-                {
-                    if(controller->zone_led_count[zone_idx] > 0)
-                    {
-                        for(unsigned int led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
-                        {
-                            /*---------------------------------------------------------*\
-                            | Each zone only has one LED                                |
-                            \*---------------------------------------------------------*/
-                            led* new_led = new led();
-
-                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                                {
-                                    new_led->name           = polychrome_v1_zone_names[zone_idx];
-                                }
-                                else
-                                {
-                                    new_led->name           = polychrome_v2_zone_names[zone_idx];
-                                }
-
-                            new_led->name.append(" " + std::to_string(led_idx + 1));
-                            new_led->value = 0;
-
-                            if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-                            {
-                                new_led->value              = zone_idx;
-                            }
-                            else if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                new_led->value              = 0x19;
-                            }
-
-                            /*---------------------------------------------------------*\
-                            | Push new LED to LEDs vector                               |
-                            \*---------------------------------------------------------*/
-                            leds.push_back(*new_led);
-
-                            led_count++;
-
-                            if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
-                            {
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            break;
-    }
-
-    SetupColors();
-}
-
-void RGBController_Polychrome::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Polychrome::DeviceUpdateLEDs()
-{
-    for (std::size_t led = 0; led < colors.size(); led++)
-    {
-        UpdateSingleLED(led);
-    }
-}
-
-void RGBController_Polychrome::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Polychrome::UpdateSingleLED(int led)
-{
-    unsigned char red = RGBGetRValue(colors[led]);
-    unsigned char grn = RGBGetGValue(colors[led]);
-    unsigned char blu = RGBGetBValue(colors[led]);
-
-    /*---------------------------------------------------------*\
-    | If the LED value is non-zero, this LED overrides the LED  |
-    | index                                                     |
-    \*---------------------------------------------------------*/
-    if(leds[led].value != 0)
-    {
-        led = leds[led].value;
-    }
-
-    controller->SetColorsAndSpeed(led, red, grn, blu);
-}
-
-void RGBController_Polychrome::SetCustomMode()
-{
-    active_mode = 1;
-}
-
-void RGBController_Polychrome::DeviceUpdateMode()
-{
-    if(controller->GetASRockType() == ASROCK_TYPE_POLYCHROME_V1)
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
-        }
-    }
-    else
-    {
-        controller->SetMode(0, modes[active_mode].value, modes[active_mode].speed);
-    }
-
-    DeviceUpdateLEDs();
-}
@@ -1,378 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeUSBController.cpp        |
-|                                           |
-|  Driver for ASRock Polychrome USB         |
-|  lighting controller                      |
-|                                           |
-|  Ed Kambulow (dredvard) 12/20/2020        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "ASRockPolychromeUSBController.h"
-#include <cstring>
-#include <stdio.h>
-#include "dependencies/dmiinfo.h"
-
-#define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
-#define POLYCHROME_USB_READ_HEADER      0x14
-#define POLYCHROME_USB_WRITE_HEADER     0x15
-#define POLYCHROME_USB_SET_ZONE         0x10
-#define POLYCHROME_USB_INIT             0xA4
-#define POLYCHROME_USB_COMMIT           0x12
-
-PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
-{
-    DMIInfo       dmi;
-
-    dev         = dev_handle;
-    device_name = "ASRock " + dmi.getMainboard();
-    location    = path;
-
-    SetDeviceInfo();
-}
-
-PolychromeUSBController::~PolychromeUSBController()
-{
-
-}
-
-unsigned int PolychromeUSBController::GetChannelCount()
-{
-    return(device_info.size());
-}
-
-std::string PolychromeUSBController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string PolychromeUSBController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string PolychromeUSBController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-void PolychromeUSBController::SetDeviceInfo()
-{
-    PolychromeDeviceInfo newdev_info;
-    ReadConfigTables();
-
-    for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
-    {
-        if(configtable[zonecnt] == 0x1E)
-        {
-			/*-----------------------------------------------------------------------*\
-			| If we don't have this device type (0x1E) we will skip it and continue.  |
-			\*-----------------------------------------------------------------------*/
-            continue;
-        }
-
-        newdev_info.num_leds = configtable[zonecnt];
-
-		/*--------------------------------------------------------------------------------------------------*\
-		| We will need to know what zone type this is, so that we can look up the name and make calls later. |
-		\*--------------------------------------------------------------------------------------------------*/
-        newdev_info.zone_type = zonecnt;
-
-        switch (zonecnt)
-        {
-            /*-----------------------------------------*\
-            | Type: Addressable, configurable           |
-            \*-----------------------------------------*/
-            case POLYCHROME_USB_ZONE_ARGB1:
-            case POLYCHROME_USB_ZONE_ARGB2:
-                newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
-                break;
-
-            /*-----------------------------------------*\
-            | Type: Addressable, not configurable       |
-            \*-----------------------------------------*/
-            case POLYCHROME_USB_ZONE_PCH:
-            case POLYCHROME_USB_ZONE_IOCOVER:
-            case POLYCHROME_USB_ZONE_PCB:
-            case POLYCHROME_USB_ZONE_AUDIO:
-                newdev_info.device_type = PolychromeDeviceType::FIXED;
-                break;
-            
-            /*-----------------------------------------*\
-            | Type: Fixed                               |
-            \*-----------------------------------------*/
-            case POLYCHROME_USB_ZONE_RGB1:
-            case POLYCHROME_USB_ZONE_RGB2:
-            default:
-                newdev_info.device_type = PolychromeDeviceType::FIXED;
-                break;
-        }
-
-        device_info.push_back(newdev_info);
-    }
-}
-
-void PolychromeUSBController::WriteZone
-    (
-    unsigned char   zone,
-    unsigned char   mode,
-    unsigned char   speed,
-    RGBColor        rgb, 
-    bool            allzone = false
-    )
-{
-
-	/*----------------------------------------------------*\
-    | Get the device info so we can look up the zone type. | 
-	\*----------------------------------------------------*/
-    PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
-
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00                  |
-    \*-----------------------------------------------------*/
-	usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
-    usb_buf[0x03] = device_info.zone_type; 
-	usb_buf[0x04] = mode;
-	usb_buf[0x05] = RGBGetRValue(rgb);
-	usb_buf[0x06] = RGBGetGValue(rgb);
-	usb_buf[0x07] = RGBGetBValue(rgb);
-	usb_buf[0x08] = speed;
-	usb_buf[0x09] = 0xFF;
-	usb_buf[0x10] = allzone;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-};
-
-void PolychromeUSBController::WriteRGSwap
-    (
-    bool ahdr1,
-    bool ahdr0,
-    bool hdr1,
-    bool hdr0
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00                 |
-    \*-----------------------------------------------------*/
-	usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
-
-    usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
-	usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-}
-
-void PolychromeUSBController::WriteHeader
-    (
-    unsigned char   cfg,
-    unsigned char*  configstring,
-    unsigned int    configsize
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
-	usb_buf[0x03] = cfg;
-    memcpy(&usb_buf[4], configstring, configsize);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-}
-
-PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
-{
-    /*-----------------------------------------------------*\
-    | Get the device info so we can look up the zone type   |
-	\*-----------------------------------------------------*/
-    PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
-
-    unsigned char       usb_buf[65];
-    PolychromeZoneInfo  zoneinfo;
-    unsigned char       r;
-    unsigned char       g;
-    unsigned char       b;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up config table request packet                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x01]   = POLYCHROME_USB_READ_ZONE_CONFIG;
-    usb_buf[0x03]   = device_info.zone_type; 
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Read response                                         |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    hid_read(dev, usb_buf, 64);
-    
-    r   = usb_buf[0x05];
-    g   = usb_buf[0x06];
-    b   = usb_buf[0x07];
-
-    zoneinfo.mode   = usb_buf[0x04];
-    zoneinfo.color  = ToRGBColor(r,g,b);  
-    zoneinfo.speed  = usb_buf[0x08];
-    zoneinfo.zone   = usb_buf[0x03];
-
-    return(zoneinfo);
-}
-
-void PolychromeUSBController::ReadConfigTables()
-{
-    unsigned char usb_buf[65];
-    unsigned char maxzoneleds[8];
-    unsigned char rgbswap;
-    unsigned char header1;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up max led config table request packet            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
-    usb_buf[0x03]   = POLYCHROME_USB_LEDCOUNT_CFG;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Read response                                         |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    hid_read(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO,   |
-    | PCB, AUDIO                                            |
-    \*-----------------------------------------------------*/
-    memcpy(&maxzoneleds,&usb_buf[0x04],8);
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up RGB Swap table request packet                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
-    usb_buf[0x03]   = POLYCHROME_USB_RGSWAP_CFG;
-
-    hid_write(dev, usb_buf, 65);
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    hid_read(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2,  |
-    | ARGB1, RGB2, RGB1 if available                        |
-    \*-----------------------------------------------------*/
-    rgbswap=usb_buf[4];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Header1 config table request packet            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x01]   = POLYCHROME_USB_READ_HEADER;
-    usb_buf[0x03]   = 0x01;
-
-    hid_write(dev, usb_buf, 64);
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    hid_read(dev, usb_buf, 64);
-    header1=usb_buf[4];
-
-    memcpy(configtable,&maxzoneleds,8);
-    configtable[8]=rgbswap;
-    configtable[9]=header1;
-    return;
-}
-
-void PolychromeUSBController::Commit()
-{
-    /*-----------------------------------------------------*\
-    | Saves all Writes in Device -  Will keep after powerup |
-    \*-----------------------------------------------------*/
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00                  |
-    \*-----------------------------------------------------*/
-	usb_buf[0x01] = POLYCHROME_USB_COMMIT;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 64);
-};
-
-const std::vector<PolychromeDeviceInfo>& PolychromeUSBController::GetPolychromeDevices() const
-{
-    return(device_info);
-};
@@ -1,152 +0,0 @@
-/*-----------------------------------------*\
-|  ASRockPolychromeUSBController.h          |
-|                                           |
-|  Driver for ASRock Polychrome USB         |
-|  lighting controller                      |
-|                                           |
-|  Ed Kambulow (dredvard) 12/20/2020        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-#include <string>
-
-#pragma once
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Polychrome USB                                                                 |
-\*----------------------------------------------------------------------------------------------*/
-#define POLYCHROME_USB_NUM_MODES            15          /* Number of Polychrome USB modes       */
-
-enum
-{
-    POLYCHROME_USB_MODE_OFF                 = 0x00,     /* OFF mode                             */
-    POLYCHROME_USB_MODE_STATIC              = 0x01,     /* Static color mode                    */
-    POLYCHROME_USB_MODE_BREATHING           = 0x02,     /* Breathing effect mode                */
-    POLYCHROME_USB_MODE_STROBE              = 0x03,     /* Strobe effect mode                   */
-    POLYCHROME_USB_MODE_SPECTRUM_CYCLE      = 0x04,     /* Spectrum Cycle effect mode           */
-    POLYCHROME_USB_MODE_RANDOM              = 0x05,     /* Random effect mode                   */
-    POLYCHROME_USB_MODE_MUSIC               = 0x06,     /* Random effect mode                   */
-    POLYCHROME_USB_MODE_WAVE                = 0x07,     /* Wave effect mode                     */
-    POLYCHROME_USB_MODE_SPRING              = 0x08,     /* Spring effect mode                   */
-    POLYCHROME_USB_MODE_STACK               = 0x09,     /* Stack effect mode                    */
-    POLYCHROME_USB_MODE_CRAM                = 0x0A,     /* Cram effect mode                     */
-    POLYCHROME_USB_MODE_SCAN                = 0x0B,     /* Scan effect mode                     */
-    POLYCHROME_USB_MODE_NEON                = 0x0C,     /* Neon effect mode                     */
-    POLYCHROME_USB_MODE_WATER               = 0x0D,     /* Water effect mode                    */
-    POLYCHROME_USB_MODE_RAINBOW             = 0x0E,     /* Rainbow effect mode                  */
-};
-
-enum
-{
-    POLYCHROME_USB_SPEED_MIN                = 0xFF,     /* Slowest speed                        */
-    POLYCHROME_USB_SPEED_DEFAULT            = 0xE0,     /* Default speed                        */
-    POLYCHROME_USB_SPEED_MAX                = 0x00,     /* Fastest speed                        */
-};
-
-enum
-{
-    POLYCHROME_USB_ZONE_MAX_NUM             = 0x08,     /* Total Max number of zones            */
-    POLYCHROME_USB_ZONE_ADDRESSABLE_MAX     = 0x64,     /* Maxinum number of ARGB LEDs          */
-};
-
-enum
-{
-    POLYCHROME_USB_LEDCOUNT_CFG             = 0x02,     // Config for LED Count
-    POLYCHROME_USB_RGSWAP_CFG               = 0x03,     // Config for RGSWAP
-    POLYCHROME_USB_ZONE_UNAVAILABLE         = 0x1E,     // Value from LEDCOUNT CFG if zone not present
-};
-
-static const char* polychrome_USB_zone_names[] =
-{
-    "RGB LED 1 Header",
-    "RGB LED 2 Header",
-    "Addressable Header 1",
-    "Addressable Header 2",
-    "PCH",
-    "IO Cover",
-    "PCB",
-    "Audio",
-};
-
-enum
-{
-    POLYCHROME_USB_ZONE_RGB1         = 0x00,  // RGB Header 1
-    POLYCHROME_USB_ZONE_RGB2         = 0X01,  // RGB Header 2
-    POLYCHROME_USB_ZONE_ARGB1        = 0X02,  // ARGB Header 1
-    POLYCHROME_USB_ZONE_ARGB2        = 0X03,  // ARGB Header 2
-    POLYCHROME_USB_ZONE_PCH          = 0X04,  // PCH
-    POLYCHROME_USB_ZONE_IOCOVER      = 0X05,  // IOCOVER
-    POLYCHROME_USB_ZONE_PCB          = 0X06,  // PCB - Could be mixed swapped with 0x07
-    POLYCHROME_USB_ZONE_AUDIO        = 0X07   // AUDIO
-};
-
-enum class PolychromeDeviceType
-{
-    FIXED,
-    ADDRESSABLE,
-};
-
-struct PolychromeZoneInfo
-{
-    unsigned char   mode;
-    unsigned char   zone;
-    unsigned char   speed;
-    RGBColor        color;
-};
-
-struct PolychromeDeviceInfo
-{
-    unsigned char           effect_channel;
-    unsigned char           num_leds;
-	unsigned char			zone_type;
-    PolychromeDeviceType    device_type;
-};
-
-class PolychromeUSBController
-{
-public:
-    unsigned char   zone_led_count[8];
-
-    PolychromeUSBController(hid_device* dev_handle, const char* path);
-    ~PolychromeUSBController();
-
-    unsigned int                                GetChannelCount();
-    std::string                                 GetDeviceLocation();
-    std::string                                 GetDeviceName();
-    const std::vector<PolychromeDeviceInfo>&    GetPolychromeDevices() const;
-    std::string                                 GetSerialString();
-    PolychromeZoneInfo                          GetZoneConfig (unsigned char zone);
-
-    void                                        WriteZone
-                                                    (
-                                                    unsigned char   zone,
-                                                    unsigned char   mode,
-                                                    unsigned char   speed,
-                                                    RGBColor        rgb,
-                                                    bool            allzone
-                                                    );
-
-    void                                        WriteHeader
-                                                    (
-                                                    unsigned char   cfg,
-                                                    unsigned char*  configstring,
-                                                    unsigned int    configsize
-                                                    );
-
-protected:
-    hid_device*                         dev;
-    std::vector<PolychromeDeviceInfo>   device_info;
-    std::string                         location;
-
-    void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
-
-private:
-    unsigned int  led_count;
-    std::string   device_name;
-    unsigned char configtable[12];
-
-    void SetDeviceInfo();    
-    void ReadConfigTables();
-    void Commit();
-};
@@ -1,36 +0,0 @@
-#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                                          |
-\*---------------------------------------------------------*/
-#define ASROCK_VID                                  0x26CE
-
-/*---------------------------------------------------------*\
-| ASRock product ID                                         |
-\*---------------------------------------------------------*/
-#define ASROCK_MOTHERBOARD_1_PID                    0x01A2
-#define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID   0x01A6
-
-void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        PolychromeUSBController*     controller     = new PolychromeUSBController(dev, info->path);
-        RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-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);
@@ -1,349 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeUSB.cpp    |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock Polychrome USB Driver             |
-|                                           |
-|  Ed Kambulow (Dredvard) 12/26/2020        |
-\*-----------------------------------------*/
-
-#include "RGBController_ASRockPolychromeUSB.h"
-#include <string.h>
-
-#define ASROCK_USB_MAX_ZONES        8
-#define ASROCK_ADDRESSABLE_MAX_LEDS 100
-
-/**------------------------------------------------------------------*\
-    @name ASrock Polychrome USB
-    @type USB
-    @save :warning:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectPolychromeUSBControllers
-    @comment ASRock Polychrome controllers will save with each update.
-        Per ARGB LED support is not possible with these devices.
-\*-------------------------------------------------------------------*/
-
-RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetDeviceName();
-    description                 = "ASRock Polychrome USB Device";
-    vendor                      = "ASRock";
-    type                        = DEVICE_TYPE_MOTHERBOARD;
-    location                    = controller->GetDeviceLocation();
-
-    mode Off;
-    Off.name                    = "Off";
-    Off.value                   = POLYCHROME_USB_MODE_OFF;
-    Off.flags                   = 0;
-    Off.color_mode              = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = POLYCHROME_USB_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = POLYCHROME_USB_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.speed_min         = POLYCHROME_USB_SPEED_MIN;
-    Breathing.speed_max         = POLYCHROME_USB_SPEED_MAX;
-    Breathing.speed             = POLYCHROME_USB_SPEED_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Strobe;
-    Strobe.name                 = "Strobe";
-    Strobe.value                = POLYCHROME_USB_MODE_STROBE;
-    Strobe.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
-    Strobe.speed_min            = POLYCHROME_USB_SPEED_MIN;
-    Strobe.speed_max            = POLYCHROME_USB_SPEED_MAX;
-    Strobe.speed                = POLYCHROME_USB_SPEED_DEFAULT;
-    Strobe.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Strobe);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name          = "Spectrum Cycle";
-    SpectrumCycle.value         = POLYCHROME_USB_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags         = MODE_FLAG_HAS_SPEED;
-    SpectrumCycle.speed_min     = POLYCHROME_USB_SPEED_MIN;
-    SpectrumCycle.speed_max     = POLYCHROME_USB_SPEED_MAX;
-    SpectrumCycle.speed         = POLYCHROME_USB_SPEED_DEFAULT;
-    SpectrumCycle.color_mode    = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Random;
-    Random.name                 = "Random";
-    Random.value                = POLYCHROME_USB_MODE_RANDOM;
-    Random.flags                = MODE_FLAG_HAS_SPEED;
-    Random.speed_min            = POLYCHROME_USB_SPEED_MIN;
-    Random.speed_max            = POLYCHROME_USB_SPEED_MAX;
-    Random.speed                = POLYCHROME_USB_SPEED_DEFAULT;
-    Random.color_mode           = MODE_COLORS_NONE;
-    modes.push_back(Random);
-
-    mode Music;
-    Random.name                 = "Music";
-    Random.value                = POLYCHROME_USB_MODE_RANDOM;
-    Random.flags                = MODE_FLAG_HAS_BRIGHTNESS;
-    Random.color_mode           = MODE_COLORS_NONE;
-    modes.push_back(Random);
-
-    mode Wave;
-    Wave.name                   = "Wave";
-    Wave.value                  = POLYCHROME_USB_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_SPEED;
-    Wave.speed_min              = POLYCHROME_USB_SPEED_MIN;
-    Wave.speed_max              = POLYCHROME_USB_SPEED_MAX;
-    Wave.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
-    Wave.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(Wave);
-
-    mode Spring;
-    Spring.name                 = "Spring";
-    Spring.value                = POLYCHROME_USB_MODE_SPRING;
-    Spring.flags                = MODE_FLAG_HAS_SPEED;
-    Spring.speed_min            = POLYCHROME_USB_SPEED_MIN;
-    Spring.speed_max            = POLYCHROME_USB_SPEED_MAX;
-    Spring.speed                = POLYCHROME_USB_SPEED_DEFAULT;
-    Spring.color_mode           = MODE_COLORS_NONE;
-    modes.push_back(Spring);
-
-    mode Stack;
-    Stack.name                  = "Stack";
-    Stack.value                 = POLYCHROME_USB_MODE_STACK;
-    Stack.flags                 = MODE_FLAG_HAS_SPEED;
-    Stack.speed_min             = POLYCHROME_USB_SPEED_MIN;
-    Stack.speed_max             = POLYCHROME_USB_SPEED_MAX;
-    Stack.speed                 = POLYCHROME_USB_SPEED_DEFAULT;
-    Stack.color_mode            = MODE_COLORS_NONE;
-    modes.push_back(Stack);
-
-    mode Cram;
-    Cram.name                   = "Cram";
-    Cram.value                  = POLYCHROME_USB_MODE_CRAM;
-    Cram.flags                  = MODE_FLAG_HAS_SPEED;
-    Cram.speed_min              = POLYCHROME_USB_SPEED_MIN;
-    Cram.speed_max              = POLYCHROME_USB_SPEED_MAX;
-    Cram.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
-    Cram.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(Cram);
-
-    mode Scan;
-    Scan.name                   = "Scan";
-    Scan.value                  = POLYCHROME_USB_MODE_SCAN;
-    Scan.flags                  = MODE_FLAG_HAS_SPEED;
-    Scan.speed_min              = POLYCHROME_USB_SPEED_MIN;
-    Scan.speed_max              = POLYCHROME_USB_SPEED_MAX;
-    Scan.speed                  = POLYCHROME_USB_SPEED_DEFAULT;
-    Scan.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(Scan);
-
-    mode Neon;
-    Neon.name                   = "Neon";
-    Neon.value                  = POLYCHROME_USB_MODE_NEON;
-    Neon.flags                  = 0;
-    Neon.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(Neon);
-
-    mode Water;
-    Water.name                  = "Water";
-    Water.value                 = POLYCHROME_USB_MODE_WATER;
-    Water.flags                 = MODE_FLAG_HAS_SPEED;
-    Water.speed_min             = POLYCHROME_USB_SPEED_MIN;
-    Water.speed_max             = POLYCHROME_USB_SPEED_MAX;
-    Water.speed                 = POLYCHROME_USB_SPEED_DEFAULT;
-    Water.color_mode            = MODE_COLORS_NONE;
-    modes.push_back(Water);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow";
-    Rainbow.value               = POLYCHROME_USB_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED;
-    Rainbow.speed_min           = POLYCHROME_USB_SPEED_MIN;
-    Rainbow.speed_max           = POLYCHROME_USB_SPEED_MAX;
-    Rainbow.speed               = POLYCHROME_USB_SPEED_DEFAULT;
-    Rainbow.color_mode          = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    SetupZones();
-
-    /*-------------------------------------------------*\
-    | Initialize active mode                            |
-    \*-------------------------------------------------*/
-    active_mode = GetDeviceMode(1);
-}
-
-void RGBController_PolychromeUSB::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-    zones.resize(controller->GetChannelCount());
-
-    /*-------------------------------------------------*\
-    | Set zones and leds                                |
-    \*-------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
-    {
-        PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
-
-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
-        if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
-        {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
-            zones[channel_idx].leds_count = device_info.num_leds; 
-        }
-        else if(device_info.device_type==PolychromeDeviceType::FIXED) 
-        {
-            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds; 
-        }       
-
-
-        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
-        {
-            led new_led;
-            new_led.name = zones[channel_idx].name;
-            new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value = channel_idx;
-
-            leds.push_back(new_led);
-        }
-
-        zones[channel_idx].matrix_map = NULL;
-    }
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize colors for each LED                            |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        unsigned char led = (unsigned char)leds[led_idx].value;
-
-        colors[led_idx] = controller->GetZoneConfig(led).color;     // TODO Get addressable instead of zone idx
-    }
-
-    /*---------------------------------------------------------*\
-    | Initialize zone info to track zone, speed, mode           |
-    | B550 Boards have modes, speed for each zone               |
-    \*---------------------------------------------------------*/
-     for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
-    {
-        PolychromeZoneInfo zoneinfo;
-        zoneinfo = controller->GetZoneConfig(channel_idx); 
-        zones_info.push_back(zoneinfo);
-    }
-
-}
-
-void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
-{
-     unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
-
-    /*---------------------------------------------------------*\
-    | This device does not currently support resizing zones     |
-    \*---------------------------------------------------------*/
-    zones[zone].leds_count = (unsigned char) new_size;
-
-    memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
-
-    for(unsigned int i = 0; i < zones.size(); i++)
-    {
-        zonecfg[i]=zones[i].leds_count;
-    }
-
-    // unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
-    // WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
-}
-
-void RGBController_PolychromeUSB::DeviceUpdateLEDs()
-{
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        unsigned char set_mode = zones_info[zone_idx].mode;
-
-        if (set_mode>modes.size())
-        {
-            set_mode = active_mode;
-        }
-
-        controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
-    }
-}
-
-void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
-{
-    unsigned char set_mode=zones_info[zone].mode;
-
-    if(set_mode > modes.size())
-    {
-        set_mode = active_mode;
-    }
-
-    controller->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
-}
-
-void RGBController_PolychromeUSB::UpdateSingleLED(int led)
-{
-    unsigned int  channel  = leds[led].value;
-    unsigned char set_mode = zones_info[channel].mode;
-
-    if(set_mode > modes.size())
-    {
-        set_mode = active_mode;
-    }
-
-    controller->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
-}
-
-unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
-{
-    int dev_mode;
-
-    dev_mode    = controller->GetZoneConfig(zone).mode;
-    active_mode = dev_mode;
-
-    return(active_mode);  
-}
-
-void RGBController_PolychromeUSB::SetCustomMode()
-{
-    active_mode = POLYCHROME_USB_MODE_STATIC;
-}
-
-void RGBController_PolychromeUSB::DeviceUpdateMode()
-{
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].leds_count > 0)
-        {
-            unsigned char set_mode      =(unsigned char) modes[active_mode].value;
-            zones_info[zone_idx].mode   =(unsigned char) modes[active_mode].value;
-            zones_info[zone_idx].speed  =(unsigned char) modes[active_mode].speed;
-            
-            if(set_mode > modes.size())
-            {
-                set_mode = active_mode;                    
-            }
-
-            controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
-        }
-    }
-}
@@ -1,37 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_ASRockPolychromeUSB.h      |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  ASRock Polychrome USB Driver             |
-|                                           |
-|  Ed Kambulow (Dredvard) 12/26/2020        |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "ASRockPolychromeUSBController.h"
-
-class RGBController_PolychromeUSB : public RGBController
-{
-public:
-    RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    bool                            initializedMode;
-    PolychromeUSBController*        controller;
-    std::vector<PolychromeZoneInfo> zones_info;
-
-    unsigned char GetDeviceMode(unsigned char zone);
-};
@@ -1,826 +0,0 @@
-/*-----------------------------------------*\
-|  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>
-#include <thread>
-#include <chrono>
-#include <algorithm>
-#include <sstream>
-
-typedef uint32_t alienware_platform_id;
-
-/*---------------------------------------------------------*\
-| Some devices appear to report the wrong number of zones.  |
-| Record that here.                                         |
-\*---------------------------------------------------------*/
-static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
-{
-    { 0x0C01,   4 }, // Dell G5 SE 5505
-    { 0x0A01,  16 }  // Dell G7 15 7500
-};
-
-/*---------------------------------------------------------*\
-| Add zones for devices here, mapping the platform ID to    |
-| the zone names                                            |
-\*---------------------------------------------------------*/
-static const std::map<alienware_platform_id, std::vector<const char*>> zone_names_table =
-{
-    { 0x0C01,   { "Left",           "Middle",       "Right",        "Numpad"    } },
-    { 0x0A01,   { "Left",           "Center Left",  "Center Right", "Right",
-                  "Light Bar 1",    "Light Bar 2",  "Light Bar 3",
-                  "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"              } }
-};
-
-static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
-{
-    using namespace std::chrono_literals;
-
-    hid_send_feature_report(dev, usb_buf, usb_buf_size);
-
-    /*-----------------------------------------------------*\
-    | The controller really doesn't like really spammed by  |
-    | too many commands at once... the delay may be command |
-    | dependent also.  Delay for longer if the command is   |
-    | changing animation state                              |
-    \*-----------------------------------------------------*/
-    unsigned char command       = usb_buf[2];
-    unsigned char subcommand    = usb_buf[3];
-
-    if( ( command == ALIENWARE_COMMAND_USER_ANIM                    )
-     && ( ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY )
-       || ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE ) ) )
-    {
-        std::this_thread::sleep_for(1s);
-    }
-    else
-    {
-        std::this_thread::sleep_for(60ms);
-    }
-}
-
-AlienwareController::AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name)
-{
-    HidapiAlienwareReport report;
-
-    dev                 = dev_handle;
-    device_name         = name;
-    location            = info.path;
-
-    /*-----------------------------------------------------*\
-    | Get 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             |
-    | configuration                                         |
-    \*-----------------------------------------------------*/
-    report              = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
-    alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];
-
-    /*-----------------------------------------------------*\
-    | Get firmware version                                  |
-    \*-----------------------------------------------------*/
-    report              = Report(ALIENWARE_COMMAND_REPORT_FIRMWARE);
-
-    std::stringstream fw_string;
-
-    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                            |
-    \*-----------------------------------------------------*/
-    zones.resize(number_of_zones);
-
-    if(zone_names_table.count(platform_id))
-    {
-        zone_names = zone_names_table.at(platform_id);
-    }
-    else
-    {
-        /*-------------------------------------------------*\
-        | If this is an unknown controller, set the name of |
-        | all regions to "Unknown"                          |
-        \*-------------------------------------------------*/
-        for(size_t i = 0; i < number_of_zones; i++)
-        {
-            zone_names.emplace_back("Unknown");
-        }
-    }
-
-    /*-----------------------------------------------------*\
-    | Set defaults for all zones                            |
-    | It doesn't seem possible to read the controller's     |
-    | current state, hence the default value being set here.|
-    \*-----------------------------------------------------*/
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        zones[zone_idx].color[0]    = 0x000000;
-        zones[zone_idx].color[1]    = 0x000000;
-        zones[zone_idx].mode        = ALIENWARE_MODE_COLOR;
-
-        /*-------------------------------------------------*\
-        | Default period value from ACC                     |
-        \*-------------------------------------------------*/
-        zones[zone_idx].period      = 2000;
-        zones[zone_idx].tempo       = ALIENWARE_TEMPO_MAX;
-        zones[zone_idx].dim         = 0;
-    }
-
-    /*-----------------------------------------------------*\
-    | Initialize dirty flags                                |
-    \*-----------------------------------------------------*/
-    dirty               = true;
-    dirty_dim           = true;
-}
-
-AlienwareController::~AlienwareController()
-{
-
-}
-
-unsigned int AlienwareController::GetZoneCount()
-{
-    return(zones.size());
-}
-
-std::vector<const char*> AlienwareController::GetZoneNames()
-{
-    return(zone_names);
-}
-
-std::string AlienwareController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AlienwareController::GetSerialString()
-{
-    return(serial_number);
-}
-
-std::string AlienwareController::GetFirmwareVersion()
-{
-    return(version);
-}
-
-AlienwareController::HidapiAlienwareReport AlienwareController::GetResponse()
-{
-    /*-----------------------------------------------------*\
-    | Zero init. This is not updated if there's a problem.  |
-    \*-----------------------------------------------------*/
-    HidapiAlienwareReport result;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(result.data, 0x00, sizeof(result.data));
-
-
-    hid_get_feature_report(dev, result.data, HIDAPI_ALIENWARE_REPORT_SIZE);
-
-    return(result);
-}
-
-AlienwareController::HidapiAlienwareReport AlienwareController::Report(uint8_t subcommand)
-{
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00] = 0x00;
-    usb_buf[0x01] = 0x03;
-    usb_buf[0x02] = ALIENWARE_COMMAND_REPORT;
-    usb_buf[0x03] = subcommand;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    return(GetResponse());
-}
-
-AlienwareReport AlienwareController::GetStatus(uint8_t subcommand)
-{
-    HidapiAlienwareReport   data    = Report(subcommand);
-    AlienwareReport         result  = AlienwareReport{};
-
-    /*-----------------------------------------------------*\
-    | Skip first byte, as that's the report number, which   |
-    | should be 0                                           |
-    \*-----------------------------------------------------*/
-    memcpy(result.data, &data.data[1], sizeof(result.data));
-
-    return(result);
-}
-
-bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
-{
-    /*-----------------------------------------------------*\
-    | Bail out if there are no zones to update              |
-    \*-----------------------------------------------------*/
-    if(!zones.size())
-    {
-        return(true);
-    }
-
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = zones.size();
-
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_DIM;
-    usb_buf[0x03]       = static_cast<uint8_t>(percent);
-    usb_buf[0x04]       = num_zones >> 8;
-    usb_buf[0x05]       = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
-    {
-        usb_buf[0x06+i] = zones[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
-}
-
-bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
-{
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00 per hidapi      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_USER_ANIM;
-    usb_buf[0x03]       = subcommand >> 8;
-    usb_buf[0x04]       = subcommand & 0xFF;
-    usb_buf[0x05]       = animation >> 8;
-    usb_buf[0x06]       = animation & 0xFF;
-    usb_buf[0x07]       = duration >> 8;
-    usb_buf[0x08]       = duration & 0xFF;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Every subcommand appears to report its result on a    |
-    | different byte                                        |
-    \*-----------------------------------------------------*/
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | The only time the 0x03 byte is zero is if the         |
-    | controller has crashed                                |
-    \*-----------------------------------------------------*/
-    if(response.data[1] == 0)
-    {
-        return(false);
-    }
-
-    switch(subcommand)
-    {
-        case ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE:
-            return(!response.data[7]);
-        case ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY:
-            return(!response.data[5]);
-        case ALIENWARE_COMMAND_USER_ANIM_PLAY:
-            return(!response.data[7]);
-        default:
-            return(true);
-    }
-}
-
-bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
-{
-    /*-----------------------------------------------------*\
-    | Bail if zones is empty, and return false to indicate  |
-    | nothing has changed                                   |
-    \*-----------------------------------------------------*/
-    if(!zones.size())
-    {
-        return(false);
-    }
-
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones  = zones.size();
-
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_SELECT_ZONES;
-    usb_buf[0x03]       = 1; // loop?
-    usb_buf[0x04]       = num_zones >> 8;
-    usb_buf[0x05]       = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
-    {
-        usb_buf[0x06+i] = zones[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
-}
-
-bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
-{
-    return(ModeAction(&mode, &duration, &tempo, &color, 1));
-}
-
-bool AlienwareController::ModeAction
-    (
-    const uint8_t*  mode,
-    const uint16_t* duration,
-    const uint16_t* tempo,
-    const RGBColor* color,
-    unsigned        amount
-    )
-{
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Amount must be 3 or less, as that's how many          |
-    | subcommands can fit into one report                   |
-    \*-----------------------------------------------------*/
-    if(amount > 3)
-    {
-        return(false);
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]               = 0x00;
-    usb_buf[0x01]               = 0x03;
-    usb_buf[0x02]               = ALIENWARE_COMMAND_ADD_ACTION;
-
-    for(unsigned int i = 0; i < amount; i++)
-    {
-        usb_buf[0x03 + (8 * i)] = mode[i];
-        usb_buf[0x04 + (8 * i)] = duration[i] >> 8;
-        usb_buf[0x05 + (8 * i)] = duration[i] & 0xFF;
-        usb_buf[0x06 + (8 * i)] = tempo[i] >> 8;
-        usb_buf[0x07 + (8 * i)] = tempo[i] & 0xFF;
-        usb_buf[0x08 + (8 * i)] = RGBGetRValue(color[i]);
-        usb_buf[0x09 + (8 * i)] = RGBGetGValue(color[i]);
-        usb_buf[0x0A + (8 * i)] = RGBGetBValue(color[i]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
-}
-
-bool AlienwareController::MultiModeAction
-    (
-    const uint8_t*  mode,
-    const uint16_t* duration,
-    const uint16_t* tempo,
-    const RGBColor* color,
-    unsigned        amount
-    )
-{
-    bool         result = true;
-    unsigned int left   = amount;
-
-    while(left && result)
-    {
-        unsigned int tmp_amount;
-
-        tmp_amount          = std::min(left, 3u);
-        result             &= ModeAction(mode, duration, tempo, color, tmp_amount);
-        mode               += tmp_amount;
-        duration           += tmp_amount;
-        tempo              += tmp_amount;
-        color              += tmp_amount;
-        left               -= tmp_amount;
-    }
-
-    return(result);
-}
-
-bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zones)
-{
-    /*-----------------------------------------------------*\
-    | Bail if zones is empty                                |
-    \*-----------------------------------------------------*/
-    if(zones.empty())
-    {
-        return(true);
-    }
-
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    uint16_t num_zones      = zones.size();
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x03;
-    usb_buf[0x02]           = ALIENWARE_COMMAND_SET_COLOR;
-    usb_buf[0x03]           = RGBGetRValue(color);
-    usb_buf[0x04]           = RGBGetGValue(color);
-    usb_buf[0x05]           = RGBGetBValue(color);
-    usb_buf[0x06]           = num_zones >> 8;
-    usb_buf[0x07]           = num_zones & 0xFF;
-
-    for(size_t i = 0; i < num_zones; i++)
-    {
-        usb_buf[0x08 + i]   = zones[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
-}
-
-bool AlienwareController::Reset()
-{
-    /*-----------------------------------------------------*\
-    | Bail if zones is empty                                |
-    \*-----------------------------------------------------*/
-    if(zones.empty())
-    {
-        return(true);
-    }
-
-    unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet with leading 00, per hidapi     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]       = 0x00;
-    usb_buf[0x01]       = 0x03;
-    usb_buf[0x02]       = ALIENWARE_COMMAND_RESET;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    SendHIDReport(dev, usb_buf, sizeof(usb_buf));
-
-    HidapiAlienwareReport response = GetResponse();
-
-    /*-----------------------------------------------------*\
-    | For this command, error is if the output equals the   |
-    | input                                                 |
-    \*-----------------------------------------------------*/
-    return(response.data[1] == 0x03);
-}
-
-void AlienwareController::SetMode(uint8_t zone, uint8_t mode)
-{
-    if(mode != zones[zone].mode)
-    {
-        zones[zone].mode        = mode;
-        dirty                   = true;
-    }
-}
-
-void AlienwareController::SetColor(uint8_t zone, RGBColor color)
-{
-    SetColor(zone, color, zones[zone].color[1]);
-}
-
-void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
-{
-    dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
-
-	if(dirty)
-	{
-		zones[zone].color[0] = color1;
-        zones[zone].color[1] = color2;
-	}
-}
-
-void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
-{
-    if(period != zones[zone].period)
-    {
-        zones[zone].period      = period;
-        dirty                   = true;
-    }
-}
-
-void AlienwareController::SetTempo(uint8_t zone, uint16_t tempo)
-{
-    if(tempo != zones[zone].tempo)
-    {
-        zones[zone].tempo       = tempo;
-        dirty                   = true;
-    }
-}
-
-void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
-{
-    if(dim != zones[zone].dim)
-    {
-        zones[zone].dim         = dim;
-        dirty_dim               = true;
-    }
-}
-
-void AlienwareController::UpdateDim()
-{
-    if(!dirty_dim)
-    {
-        return;
-    }
-
-    /*-----------------------------------------------------*\
-    | Collect all zones that share dim settings, and update |
-    | them together                                         |
-    \*-----------------------------------------------------*/
-    std::map<uint8_t, std::vector<uint8_t>> dim_zone_map;
-
-    for(size_t i = 0; i < zones.size(); i++)
-    {
-        dim_zone_map[zones[i].dim].emplace_back(i);
-    }
-
-    for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
-    {
-        /*-------------------------------------------------*\
-        | Bail on an error...                               |
-        \*-------------------------------------------------*/
-        if(!Dim(pair.second, pair.first))
-        {
-            return;
-        }
-    }
-
-    dirty_dim = false;
-}
-
-bool AlienwareController::UpdateDirect()
-{
-    /*-----------------------------------------------------*\
-    | Collect all zones that share dim settings, and update |
-    | them together                                         |
-    \*-----------------------------------------------------*/
-    std::map<RGBColor, std::vector<uint8_t>> color_zone_map;
-
-    for(size_t i = 0; i < zones.size(); i++)
-    {
-        color_zone_map[zones[i].color[0]].emplace_back(i);
-    }
-
-    for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
-    {
-        /*-------------------------------------------------*\
-        | Bail on an error...                               |
-        \*-------------------------------------------------*/
-        if(!SetColorDirect(pair.first, pair.second))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-static const RGBColor rainbow_colors[4][7] =
-{
-    { 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF, 0x800080 },
-    { 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF },
-    { 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF },
-    { 0x00BFFF, 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000 }
-};
-
-void AlienwareController::UpdateMode()
-{
-    /*-----------------------------------------------------*\
-    | If there are no updates, don't bother running this    |
-    \*-----------------------------------------------------*/
-    if(!dirty)
-    {
-        return;
-    }
-
-    bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
-
-    if(!result)
-    {
-        return;
-    }
-
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        alienware_zone zone = zones[zone_idx];
-
-        result = SelectZones({static_cast<uint8_t>(zone_idx)});
-
-        if(!result)
-        {
-            return;
-        }
-
-        /*-------------------------------------------------*\
-        | Some modes use 0x07D0 for their duration as sent  |
-        | by AWCC traces, maybe 2000ms?                     |
-        \*-------------------------------------------------*/
-        switch (zone.mode)
-        {
-            case ALIENWARE_MODE_COLOR:
-                result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
-                break;
-
-            case ALIENWARE_MODE_PULSE:
-                result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
-                break;
-
-            case ALIENWARE_MODE_MORPH:
-                {
-                    uint8_t  zones[2]   = { zone.mode,              zone.mode     };
-                    uint16_t periods[2] = { zone.period,            zone.period   };
-                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo    };
-                    RGBColor colors[2]  = { zone.color[0],          zone.color[1] };
-
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
-                }
-                break;
-
-            case ALIENWARE_MODE_SPECTRUM:
-                {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH };
-                    uint16_t periods[7] = { zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period };
-                    uint16_t tempos[7] = {  zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo };
-
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
-                }
-                break;
-
-            case ALIENWARE_MODE_RAINBOW:
-                {
-                    uint8_t  zones[7]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH,
-                                            ALIENWARE_MODE_MORPH };
-                    uint16_t periods[7] = { zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period,            zone.period,
-                                            zone.period };
-                    uint16_t tempos[7]  = { zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo,             zone.tempo,
-                                            zone.tempo };
-
-                    result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
-                }
-                break;
-
-            case ALIENWARE_MODE_BREATHING:
-                {
-                    uint8_t  zones[2]   = { ALIENWARE_MODE_MORPH,   ALIENWARE_MODE_MORPH };
-                    uint16_t periods[2] = { zone.period,            zone.period          };
-                    uint16_t tempos[2]  = { zone.tempo,             zone.tempo           };
-                    RGBColor colors[2]  = { zone.color[0],          0x0                  };
-
-                    result = MultiModeAction(zones, periods, tempos, colors, 2);
-                }
-                break;
-
-            default:
-                result = false;
-        }
-
-        if(!result)
-        {
-            return;
-        }
-    }
-
-    result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
-
-    /*-------------------------------------------------*\
-    | Don't update dirty flag if there's an error       |
-    \*-------------------------------------------------*/
-    if(!result)
-    {
-        return;
-    }
-
-    dirty = false;
-}
-
-void AlienwareController::UpdateController()
-{
-    UpdateMode();
-    UpdateDim();
-}
@@ -1,161 +0,0 @@
-/*-----------------------------------------*\
-|  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
-
-/*----------------------------------------------------------------------------------------------*\
-| Definitions for Alienware Controller                                                           |
-\*----------------------------------------------------------------------------------------------*/
-
-#define ALIENWARE_REPORT_SIZE               33
-#define HIDAPI_ALIENWARE_REPORT_SIZE        (ALIENWARE_REPORT_SIZE + 1)
-
-enum
-{
-    ALIENWARE_COMMAND_REPORT                = 0x20,     /* Set report type to get               */
-    ALIENWARE_COMMAND_USER_ANIM             = 0x21,     /* Set user animation settings          */
-    ALIENWARE_COMMAND_POWER_ANIM            = 0x22,     /* Set power animation settings         */
-    ALIENWARE_COMMAND_SELECT_ZONES          = 0x23,     /* Select zones to apply actions to     */
-    ALIENWARE_COMMAND_ADD_ACTION            = 0x24,     /* Set actions to apply                 */
-    ALIENWARE_COMMAND_UNKNOWN1              = 0x25,     /* Supposedly set event?                */
-    ALIENWARE_COMMAND_DIM                   = 0x26,     /* Set dim percentage                   */
-    ALIENWARE_COMMAND_SET_COLOR             = 0x27,     /* Unclear (causes color flash)         */
-    ALIENWARE_COMMAND_RESET                 = 0x28,     /* Reset                                */
-    ALIENWARE_COMMAND_ERASE_FLASH           = 0xFF,     /* Erases flash memory on controller    */
-};
-
-enum
-{
-    ALIENWARE_COMMAND_REPORT_FIRMWARE       = 0x00,     /* Get firmware verion                  */
-    ALIENWARE_COMMAND_REPORT_STATUS         = 0x01,     /* Get status                           */
-    ALIENWARE_COMMAND_REPORT_CONFIG         = 0x02,     /* Get firmware config                  */
-    ALIENWARE_COMMAND_REPORT_ANIMATION      = 0x03,     /* Get animation count and last id      */
-    ALIENWARE_COMMAND_REPORT_UNKNOWN1       = 0x04,     /* Get ELC animation by ID              */
-    ALIENWARE_COMMAND_REPORT_UNKNOWN2       = 0x05,     /* Read series???                       */
-    ALIENWARE_COMMAND_REPORT_UNKNOWN3       = 0x06,     /* Get action???                        */
-    ALIENWARE_COMMAND_REPORT_UNKNOWN4       = 0x07,     /* Get Caldera status???                */
-};
-
-enum
-{
-    ALIENWARE_COMMAND_USER_ANIM_NEW         = 0x0001,   /* Start new animation                  */
-    ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE = 0x0002,   /* Finish and save animation            */
-    ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY = 0x0003,   /* Finish and play animation            */
-    ALIENWARE_COMMAND_USER_ANIM_REMOVE      = 0x0004,   /* Remove/erase animation               */
-    ALIENWARE_COMMAND_USER_ANIM_PLAY        = 0x0005,   /* Play animation                       */
-    ALIENWARE_COMMAND_USER_ANIM_DEFAULT     = 0x0006,   /* Set default animation                */
-    ALIENWARE_COMMAND_USER_ANIM_STARTUP     = 0x0007,   /* Set startup animation                */
-};
-
-enum
-{
-    ALIENWARE_ANIM_DEFAULT_STARTUP          = 0x0008,   /* Default slot for startup             */
-    ALIENWARE_ANIM_DEFAULT                  = 0x0061,   /* Default slot                         */
-    ALIENWARE_COMMAND_USER_ANIM_KEYBOARD    = 0xFFFF,   /* Non-saved animation slot             */
-};
-
-enum
-{
-    ALIENWARE_MODE_COLOR                    = 0x00,     /* Action to set color mode             */
-    ALIENWARE_MODE_PULSE                    = 0x01,     /* Action to set pulse mode             */
-    ALIENWARE_MODE_MORPH                    = 0x02,     /* Action to set morph mode             */
-    ALIENWARE_MODE_SPECTRUM,                            /* Abitrary code for spectrum mode      */
-    ALIENWARE_MODE_RAINBOW,                             /* Arbitrary code for rainbow wave mode */
-    ALIENWARE_MODE_BREATHING,                           /* Arbitrary code for rainbow wave mode */
-};
-
-enum
-{
-    ALIENWARE_TEMPO_MIN                     = 0x0064,   /* Min tempo (as used by AWCC)          */
-    ALIENWARE_TEMPO_MAX                     = 0x00FA,   /* Max tempo (as used by AWCC)          */
-    ALIENWARE_TEMPO_SPECTRUM                = 0x000F,   /* Used by Spectrum mode                */
-};
-
-enum
-{
-    ALIENWARE_DURATION_LONG                 = 0x09C4,   /* Min tempo (as used by AWCC)          */
-    ALIENWARE_DURATION_MED                  = 0x05DC,   /* Max tempo (as used by AWCC)          */
-    ALIENWARE_DURATION_SHORT                = 0x01F3,   /* Max tempo (as used by AWCC)          */
-    ALIENWARE_DURATION_SPECTRUM             = 0x01AC,   /* Used by Spectrum mode                */
-};
-
-typedef struct
-{
-    unsigned char           data[ALIENWARE_REPORT_SIZE];
-} AlienwareReport;
-
-class AlienwareController
-{
-public:
-    AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name);
-    ~AlienwareController();
-
-    std::string                 GetSerialString();
-    std::string                 GetDeviceLocation();
-    std::string                 GetDeviceName();
-    std::string                 GetFirmwareVersion();
-    unsigned                    GetZoneCount();
-    std::vector<const char*>    GetZoneNames();
-
-    void                        SetColor(uint8_t zone, RGBColor color);
-    void                        SetColor(uint8_t zone, RGBColor color1, RGBColor color2);
-    void                        SetMode(uint8_t zone, uint8_t mode);
-    void                        SetPeriod(uint8_t zone, uint16_t period);
-    void                        SetTempo(uint8_t zone, uint16_t tempo);
-    void                        SetDim(uint8_t zone, uint8_t dim);
-    AlienwareReport             GetStatus(uint8_t subcommand);
-
-    void                        UpdateDim();
-    void                        UpdateMode();
-    void                        UpdateController();
-
-protected:
-    hid_device* dev;
-
-private:
-    typedef struct
-    {
-        RGBColor                color[2];
-        uint8_t                 mode;
-        uint16_t                period;
-        uint16_t                tempo;
-        uint8_t                 dim;
-    } alienware_zone;
-
-    typedef struct
-    {
-        unsigned char           data[HIDAPI_ALIENWARE_REPORT_SIZE];
-    } HidapiAlienwareReport;
-
-    std::string                 device_name;
-    std::string                 location;
-    std::vector<alienware_zone> zones;
-    std::string                 serial_number;
-    std::string                 version;
-    std::vector<const char*>    zone_names;
-    bool                        dirty;
-    bool                        dirty_dim;
-
-    HidapiAlienwareReport       GetResponse();
-    HidapiAlienwareReport       Report(uint8_t subcommand);
-
-    bool                        Dim(std::vector<uint8_t> zones, double percent);
-    bool                        UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration);
-    bool                        SelectZones(const std::vector<uint8_t>& zones);
-    bool                        ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color);
-    bool                        ModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
-    bool                        MultiModeAction(const uint8_t *mode, const uint16_t *duration, const uint16_t *tempo, const RGBColor *color, unsigned amount);
-    bool                        SetColorDirect(RGBColor color, std::vector<uint8_t> zones);
-    bool                        UpdateDirect();
-    bool                        Reset();
-};
@@ -1,29 +0,0 @@
-#include "Detector.h"
-#include "AlienwareController.h"
-#include "RGBController.h"
-#include "RGBController_Alienware.h"
-
-/*---------------------------------------------------------*\
-| Alienware vendor ID                                       |
-\*---------------------------------------------------------*/
-#define ALIENWARE_VID                               0x187C
-
-/*---------------------------------------------------------*\
-| Alienware product ID                                      |
-\*---------------------------------------------------------*/
-#define ALIENWARE_G_SERIES_PID                         0x0550
-
-void DetectAlienwareControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AlienwareController*     controller     = new AlienwareController(dev, *info, name);
-        RGBController_Alienware* rgb_controller = new RGBController_Alienware(controller);
-
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR("Dell G Series LED Controller", DetectAlienwareControllers, ALIENWARE_VID, ALIENWARE_G_SERIES_PID);
@@ -1,288 +0,0 @@
-/*-----------------------------------------*\
-|  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>
-
-/**------------------------------------------------------------------*\
-    @name Alienware
-    @type USB
-    @save :x:
-    @direct :x:
-    @effects :white_check_mark:
-    @detectors DetectAlienwareControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_Alienware::RGBController_Alienware(AlienwareController* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetDeviceName();
-    vendor                      = "Alienware";
-    type                        = DEVICE_TYPE_KEYBOARD;
-    description                 = "Alienware USB Device";
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
-    version                     = controller->GetFirmwareVersion();
-
-    mode Color;
-    Color.name                 = "Static";
-    Color.value                = ALIENWARE_MODE_COLOR;
-    Color.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Color.color_mode           = MODE_COLORS_PER_LED;
-    Color.colors_min           = 1;
-    Color.colors_max           = 1;
-    Color.brightness_min       = 100;
-    Color.brightness_max       = 0;
-    Color.brightness           = 0;
-    modes.push_back(Color);
-
-    mode Pulse;
-    Pulse.name                 = "Flashing";
-    Pulse.value                = ALIENWARE_MODE_PULSE;
-    Pulse.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Pulse.color_mode           = MODE_COLORS_PER_LED;
-    Pulse.colors_min           = 1;
-    Pulse.colors_max           = 1;
-    Pulse.speed_min            = ALIENWARE_TEMPO_MIN;
-    Pulse.speed_max            = ALIENWARE_TEMPO_MAX;
-    Pulse.speed                = ALIENWARE_TEMPO_MIN;
-    Pulse.brightness_min       = 100;
-    Pulse.brightness_max       = 0;
-    Pulse.brightness           = 0;
-    modes.push_back(Pulse);
-
-    mode Morph;
-    Morph.name                 = "Morph";
-    Morph.value                = ALIENWARE_MODE_MORPH;
-    Morph.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Morph.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Morph.colors_min           = 2 * controller->GetZoneCount();
-    Morph.colors_max           = Morph.colors_min;
-    Morph.colors.resize(Morph.colors_max);
-    Morph.speed_min            = ALIENWARE_TEMPO_MIN;
-    Morph.speed_max            = ALIENWARE_TEMPO_MAX;
-    Morph.speed                = ALIENWARE_TEMPO_MIN;
-    Morph.brightness_min       = 100;
-    Morph.brightness_max       = 0;
-    Morph.brightness           = 0;
-    modes.push_back(Morph);
-
-    mode Spectrum;
-    Spectrum.name              = "Spectrum Cycle";
-    Spectrum.value             = ALIENWARE_MODE_SPECTRUM;
-    Spectrum.flags             = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Spectrum.color_mode        = MODE_COLORS_NONE;
-    Spectrum.speed_min         = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.speed_max         = ALIENWARE_TEMPO_MAX;
-    Spectrum.speed             = ALIENWARE_TEMPO_SPECTRUM;
-    Spectrum.brightness_min    = 100;
-    Spectrum.brightness_max    = 0;
-    Spectrum.brightness        = 0;
-    modes.push_back(Spectrum);
-
-    mode Rainbow;
-    Rainbow.name               = "Rainbow Wave";
-    Rainbow.value              = ALIENWARE_MODE_RAINBOW;
-    Rainbow.flags              = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Rainbow.color_mode         = MODE_COLORS_NONE;
-    Rainbow.speed_min          = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.speed_max          = ALIENWARE_TEMPO_MAX;
-    Rainbow.speed              = ALIENWARE_TEMPO_SPECTRUM;
-    Rainbow.brightness_min     = 100;
-    Rainbow.brightness_max     = 0;
-    Rainbow.brightness         = 0;
-    modes.push_back(Rainbow);
-
-    mode Breathing;
-    Breathing.name             = "Breathing";
-    Breathing.value            = ALIENWARE_MODE_BREATHING;
-    Breathing.flags            = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
-    Breathing.color_mode       = MODE_COLORS_PER_LED;
-    Breathing.colors_min       = 1;
-    Breathing.colors_max       = 1;
-    Breathing.speed_min        = ALIENWARE_TEMPO_MIN;
-    Breathing.speed_max        = ALIENWARE_TEMPO_MAX;
-    Breathing.speed            = ALIENWARE_TEMPO_MIN;
-    Breathing.brightness_min   = 100;
-    Breathing.brightness_max   = 0;
-    Breathing.brightness       = 0;
-    modes.push_back(Breathing);
-
-    SetupZones();
-
-    controller->UpdateDim();
-}
-
-void RGBController_Alienware::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Set zones and leds                                |
-    \*-------------------------------------------------*/
-    std::vector<const char*> zone_names = controller->GetZoneNames();
-
-    for(unsigned int zone_idx = 0; zone_idx < controller->GetZoneCount(); zone_idx++)
-    {
-        zone new_zone;
-
-        new_zone.name       = zone_names[zone_idx];
-        new_zone.type       = ZONE_TYPE_SINGLE;
-        new_zone.leds_min   = 1;
-        new_zone.leds_max   = 1;
-        new_zone.leds_count = 1;
-        new_zone.matrix_map = nullptr;
-
-        zones.emplace_back(new_zone);
-    }
-
-    for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
-    {
-        led new_led;
-        
-        new_led.name        = zones[led_idx].name + std::string(" LED");
-
-        leds.emplace_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_Alienware::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_Alienware::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_Alienware::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_Alienware::UpdateSingleLED(int led)
-{
-    UpdateZoneLEDs(led);
-}
-
-void RGBController_Alienware::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-static bool modes_eq(const mode& mode1, const mode& mode2)
-{
-    return( ( mode1.name           == mode2.name       )
-         && ( mode1.value          == mode2.value      )
-         && ( mode1.flags          == mode2.flags      )
-         && ( mode1.speed_min      == mode2.speed_min  )
-         && ( mode1.speed_max      == mode2.speed_max  )
-         && ( mode1.colors_min     == mode2.colors_min )
-         && ( mode1.colors_max     == mode2.colors_max )
-         && ( mode1.speed          == mode2.speed      )
-         && ( mode1.direction      == mode2.direction  )
-         && ( mode1.color_mode     == mode2.color_mode )
-         && ( mode1.colors         == mode2.colors     )
-         && ( mode1.brightness     == mode2.brightness )
-         && ( mode1.brightness_min == mode2.brightness_min )
-         && ( mode1.brightness_max == mode2.brightness_max ) );
-}
-
-void RGBController_Alienware::DeviceUpdateMode()
-{
-    /*---------------------------------------------------------*\
-    | Copy mode to get the current state-- this is racy, as the |
-    | UI thread can be actively modifying this variable         |
-    \*---------------------------------------------------------*/
-    int  current_mode_idx = active_mode;
-    mode current_mode     = modes[current_mode_idx];
-
-    bool done             = false;
-
-    while(!done)
-    {
-        /*-----------------------------------------------------*\
-        | Setup state per zone                                  |
-        \*-----------------------------------------------------*/
-        for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-        {
-            zone current_zone = zones[zone_idx];
-
-            /*-------------------------------------------------*\
-            | Some modes use 2000ms (0x07D0) for their duration,|
-            | per traces                                        |
-            \*-------------------------------------------------*/
-            uint16_t period = 0x07d0;
-
-            controller->SetMode(zone_idx, current_mode.value);
-            
-            switch(current_mode_idx)
-            {
-                case ALIENWARE_MODE_COLOR:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, colors[current_zone.start_idx]);
-                    controller->SetTempo( zone_idx, ALIENWARE_TEMPO_MAX);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    break;
-
-                case ALIENWARE_MODE_PULSE:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, colors[current_zone.start_idx]);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    break;
-
-                case ALIENWARE_MODE_MORPH:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, current_mode.colors[zone_idx * 2], current_mode.colors[(zone_idx * 2) + 1]);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    break;
-
-                case ALIENWARE_MODE_SPECTRUM:
-                case ALIENWARE_MODE_RAINBOW:
-                    controller->SetPeriod(zone_idx, ALIENWARE_DURATION_SPECTRUM);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    break;
-
-                case ALIENWARE_MODE_BREATHING:
-                    controller->SetPeriod(zone_idx, period);
-                    controller->SetColor( zone_idx, colors[current_zone.start_idx], 0x0);
-                    controller->SetTempo( zone_idx, current_mode.speed);
-                    controller->SetDim(   zone_idx, modes[current_mode_idx].brightness);
-                    break;
-            }
-        }
-
-        /*-----------------------------------------------------*\
-        | Due to rate-limiting, this can take more than one     |
-        | second to execute                                     |
-        \*-----------------------------------------------------*/
-        controller->UpdateController();
-
-        /*-----------------------------------------------------*\
-        | Re-run update if there's anything that's changed from |
-        | under us...                                           |
-        \*-----------------------------------------------------*/
-        int  new_current_mode_idx = active_mode;
-        mode new_current_mode     = modes[current_mode_idx];
-
-        done                      = (current_mode_idx == new_current_mode_idx && modes_eq(new_current_mode, current_mode));
-        current_mode_idx          = new_current_mode_idx;
-        current_mode              = new_current_mode;
-    }
-}
@@ -1,37 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_Alienware.h                |
-|                                           |
-|  Generic RGB Interface for OpenRGB        |
-|  Alienware RGB USB Driver                 |
-|                                           |
-|  Gabriel Marcano (gemarcano) 4/19/2021    |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AlienwareController.h"
-
-#include <chrono>
-
-class RGBController_Alienware : public RGBController
-{
-public:
-    RGBController_Alienware(AlienwareController* controller_ptr);
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        DeviceUpdateMode();
-
-    void        SetCustomMode();
-
-private:
-    AlienwareController*                    controller;
-    std::chrono::steady_clock::time_point   last_packet_ts;
-};
@@ -1,442 +0,0 @@
-/*-----------------------------------------*\
-|  AlienwareAW510KController.cpp            |
-|                                           |
-|  Driver for Alienware AW510K              |
-|  keyboard light controller                |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
-
-#include "AlienwareAW510KController.h"
-#include <cstring>
-
-AlienwareAW510KController::AlienwareAW510KController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    SendCommit();
-}
-
-AlienwareAW510KController::~AlienwareAW510KController()
-{
-    hid_close(dev);
-}
-
-std::string AlienwareAW510KController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AlienwareAW510KController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    hid_get_serial_number_string(dev, serial_string, 128);
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-void AlienwareAW510KController::SendCommit()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x0A]           = 0x10;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0C]           = 0x01;
-    usb_buf[0x0D]           = 0x02;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-}
-
-
-void AlienwareAW510KController::SendfeatureReport
-    (
-    unsigned char   first_byte,
-    unsigned char   second_byte,
-    unsigned char   third_byte,
-    unsigned char   forth_byte
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Feature report packet                          |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = first_byte;
-    usb_buf[0x02]           = second_byte;
-    usb_buf[0x03]           = third_byte;
-    usb_buf[0x04]           = forth_byte;
-
-    /*-----------------------------------------------------*\
-    | Send Feature report packet                            |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 10 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(10));
-}
-
-void AlienwareAW510KController::SendEdit()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Edit packet                                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x01;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW510KController::SendInitialize()
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Commit packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = 0xAD;
-    usb_buf[0x06]           = 0x80;
-    usb_buf[0x07]           = 0x10;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW510KController::SetDirect
-    (
-    unsigned char   zone,
-    unsigned char   r,
-    unsigned char   g,
-    unsigned char   b
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x01;
-    usb_buf[0x04]           = r;
-    usb_buf[0x05]           = g;
-    usb_buf[0x06]           = b;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 2 milliseconds                                  |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(2));
-}
-
-void AlienwareAW510KController::SendDirectOn
-    (
-    std::vector<SelectedKeys>     &frame_data
-    )
-{
-    SendfeatureReport(0x0E, frame_data.size(), 0x00, 0x01);
-
-    /*-----------------------------------------------*\
-    | To Guarantee the data are always %4 =0 append   |
-    | zeros at end of last packet                     |
-    \*-----------------------------------------------*/
-    for(int i = 0; i < (frame_data.size() % 4); i++)
-    {
-        SelectedKeys key;
-        key.idx     = 0x00;
-        key.red     = 0x00;
-        key.green   = 0x00;
-        key.blue    = 0x00;
-
-        frame_data.push_back(key);
-    }
-
-    unsigned char usb_buf[65];
-    unsigned int  frame_idx = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 65);
-
-    for(unsigned int packet_idx = 0; packet_idx < frame_data.size(); packet_idx++)
-    {
-        usb_buf[0x00]           = 0x00;
-        usb_buf[0x01]           = 0x0E;
-        usb_buf[0x02]           = 0x01;
-        usb_buf[0x03]           = 0x00;
-        usb_buf[0x04]           = ++frame_idx;
-        usb_buf[0x05]           = frame_data[packet_idx].idx;
-        usb_buf[0x06]           = 0x81;
-        usb_buf[0x07]           = 0x00;
-        usb_buf[0x08]           = 0xA5;
-        usb_buf[0x0A]           = 0x0A;
-        usb_buf[0x0B]           = frame_data[packet_idx].red;
-        usb_buf[0x0C]           = frame_data[packet_idx].green;
-        usb_buf[0x0D]           = frame_data[packet_idx].blue;
-        usb_buf[0x12]           = 0x01;
-
-        usb_buf[0x14]           = frame_data[++packet_idx].idx;
-        usb_buf[0x15]           = 0x81;
-        usb_buf[0x16]           = 0x00;
-        usb_buf[0x17]           = 0xA5;
-        usb_buf[0x19]           = 0x0A;
-        usb_buf[0x1A]           = frame_data[packet_idx].red;
-        usb_buf[0x1B]           = frame_data[packet_idx].green;
-        usb_buf[0x1C]           = frame_data[packet_idx].blue;
-        usb_buf[0x21]           = 0x01;
-
-        usb_buf[0x23]           = frame_data[++packet_idx].idx;
-        usb_buf[0x24]           = 0x81;
-        usb_buf[0x25]           = 0x00;
-        usb_buf[0x26]           = 0xA5;
-        usb_buf[0x28]           = 0x0A;
-        usb_buf[0x29]           = frame_data[packet_idx].red;
-        usb_buf[0x2A]           = frame_data[packet_idx].green;
-        usb_buf[0x2B]           = frame_data[packet_idx].blue;
-        usb_buf[0x30]           = 0x01;
-
-        usb_buf[0x32]           = frame_data[++packet_idx].idx;
-        usb_buf[0x33]           = 0x81;
-        usb_buf[0x34]           = 0x00;
-        usb_buf[0x35]           = 0xA5;
-        usb_buf[0x37]           = 0x0A;
-        usb_buf[0x38]           = frame_data[packet_idx].red;
-        usb_buf[0x39]           = frame_data[packet_idx].green;
-        usb_buf[0x3A]           = frame_data[packet_idx].blue;
-        usb_buf[0x3F]           = 0x01;
-
-        hid_write(dev, (unsigned char *)usb_buf, 65);
-    }
-}
-
-
-void AlienwareAW510KController::SetMode
-    (
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendMode(ALIENWARE_AW510K_ZONE_MODE_KEYBOARD, mode, speed, direction, colorMode, red, green, blue);
-    SendCommit();
-}
-
-void AlienwareAW510KController::UpdateSingleLED
-    (
-    unsigned char   led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    SendfeatureReport(0x0E, 0x01, 0x00, 0x01);
-
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Single LED packet                              |
-    \*-----------------------------------------------------*/
-
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x0E;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = 0x00;
-    usb_buf[0x04]           = 0x01;
-    usb_buf[0x05]           = led;
-    usb_buf[0x06]           = 0x81;
-    usb_buf[0x07]           = 0x00;
-    usb_buf[0x08]           = 0xA5;
-    usb_buf[0x09]           = 0x00;
-    usb_buf[0x0A]           = 0x0A;
-    usb_buf[0x0B]           = red;
-    usb_buf[0x0C]           = green;
-    usb_buf[0x0D]           = blue;
-    usb_buf[0x12]           = 0x01;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Delay 20 milliseconds                                 |
-    \*-----------------------------------------------------*/
-    std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
-}
-void AlienwareAW510KController::SendMode
-    (
-    unsigned char   zone,
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   direction,
-    unsigned char   colorMode,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Mode Control packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red;
-    usb_buf[0x05]           = green;
-    usb_buf[0x06]           = blue;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = colorMode;
-    usb_buf[0x0F]           = direction;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-}
-
-void AlienwareAW510KController::SetMorphMode
-    (
-    unsigned char   mode,
-    unsigned short  speed,
-    unsigned char   red1,
-    unsigned char   green1,
-    unsigned char   blue1,
-    unsigned char   red2,
-    unsigned char   green2,
-    unsigned char   blue2
-    )
-{
-    char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Morph Mode packet                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x00;
-    usb_buf[0x01]           = 0x05;
-    usb_buf[0x02]           = 0x01;
-    usb_buf[0x03]           = mode;
-    usb_buf[0x04]           = red1;
-    usb_buf[0x05]           = green1;
-    usb_buf[0x06]           = blue1;
-    usb_buf[0x07]           = red2;
-    usb_buf[0x08]           = green2;
-    usb_buf[0x09]           = blue2;
-    usb_buf[0x0E]           = 0x02;
-    usb_buf[0x0A]           = speed;
-    usb_buf[0x0B]           = 0x0A;
-    usb_buf[0x0D]           = 0x01;
-    usb_buf[0x0E]           = ALIENWARE_AW510K_TWO_USER_DEFINED_COLOR_MODE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 65);
-}
@@ -1,156 +0,0 @@
-/*-----------------------------------------*\
-|  AlienwareAW510KController.h              |
-|                                           |
-|  Definitions and types for alienware      |
-|  AW510K Keyboard                          |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    ALIENWARE_AW510K_ZONE_MODE_KEYBOARD         = 0x01,
-    ALIENWARE_AW510K_ZONE_MODE_LOGO             = 0x07,     /* logo is only need key value, which equal 07  */
-};
-
-enum
-{
-    ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD       = 0x01,
-    ALIENWARE_AW510K_ZONE_DIRECT_MEDIA          = 0x02,
-    ALIENWARE_AW510K_ZONE_DIRECT_LOGO           = 0x07,
-    ALIENWARE_AW510K_ZONE_DIRECT_INDICATORS     = 0x40,
-};
-
-enum
-{
-    ALIENWARE_AW510K_MODE_OFF                   = 0x00,
-    ALIENWARE_AW510K_MODE_DIRECT_PER_LED        = 0x01,
-    ALIENWARE_AW510K_MODE_DIRECT                = 0x01,
-    ALIENWARE_AW510K_MODE_PULSE                 = 0x02,
-    ALIENWARE_AW510K_MODE_MORPH                 = 0x03,
-    ALIENWARE_AW510K_MODE_BREATHING             = 0x07,
-    ALIENWARE_AW510K_MODE_SPECTRUM              = 0x08,
-    ALIENWARE_AW510K_MODE_SINGLE_WAVE           = 0x0F,
-    ALIENWARE_AW510K_MODE_RAINBOW_WAVE          = 0x10,
-    ALIENWARE_AW510K_MODE_SCANNER               = 0x11,
-    ALIENWARE_AW510K_MODE_STATIC                = 0x13,
-};
-
-enum
-{
-    ALIENWARE_AW510K_SPEED_SLOWEST              = 0x2D,     /* Slowest speed                                */
-    ALIENWARE_AW510K_SPEED_NORMAL               = 0x19,     /* Normal speed                                 */
-    ALIENWARE_AW510K_SPEED_FASTEST              = 0x0A,     /* Fastest speed                                */
-};
-
-enum
-{
-    ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT    = 0x01,
-    ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT    = 0x02,
-    ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM    = 0x03,
-    ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP    = 0x04,
-};
-
-enum
-{
-    ALIENWARE_AW510K_SINGLE_COLOR_MODE          = 0x01,
-    ALIENWARE_AW510K_TWO_USER_DEFINED_COLOR_MODE= 0x02,
-    ALIENWARE_AW510K_RANBOW_COLOR_MODE          = 0x03,
-};
-
-struct SelectedKeys
-{
-    unsigned char idx;
-    unsigned char red;
-    unsigned char green;
-    unsigned char blue;
-};
-
-class AlienwareAW510KController
-{
-public:
-    AlienwareAW510KController(hid_device* dev_handle, const char* path);
-    ~AlienwareAW510KController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void        SendInitialize();
-    void        SendCommit();
-    void        SendfeatureReport
-                    (
-                    unsigned char   first_byte,
-                    unsigned char   second_byte,
-                    unsigned char   third_byte,
-                    unsigned char   forth_byte
-                    );
-
-    void        SendEdit();
-
-    void        SetDirect
-                    (
-                    unsigned char   zone,
-                    unsigned char   r,
-                    unsigned char   g,
-                    unsigned char   b
-                    );
-
-    void    SendDirectOn
-                    (
-                    std::vector<SelectedKeys>     &frame_data
-                    );
-
-    void        SetMode
-                    (
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-    void        SetMorphMode
-                    (
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   red1,
-                    unsigned char   green1,
-                    unsigned char   blue1,
-                    unsigned char   red2,
-                    unsigned char   green2,
-                    unsigned char   blue2
-                    );
-
-    void        UpdateSingleLED
-                    (
-                    unsigned char   led,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void        SendMode
-                    (
-                    unsigned char   zone,
-                    unsigned char   mode,
-                    unsigned short  speed,
-                    unsigned char   direction,
-                    unsigned char   colorMode,
-                    unsigned char   red,
-                    unsigned char   green,
-                    unsigned char   blue
-                    );
-};
@@ -1,38 +0,0 @@
-#include "Detector.h"
-#include "AlienwareAW510KController.h"
-#include "RGBController.h"
-#include "RGBController_AlienwareAW510K.h"
-#include <hidapi/hidapi.h>
-
-/*-----------------------------------------------------*\
-| Alienware vendor ID                                   |
-\*-----------------------------------------------------*/
-#define ALIENWARE_VID           0x04F2
-
-/*-----------------------------------------------------*\
-| Keyboard product IDs                                  |
-\*-----------------------------------------------------*/
-#define ALIENWARE_AW510K_PID    0x1830
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAlienwareKeyboardControllers                                                     *
-*                                                                                          *
-*       Tests the USB address to see if a Alienware RGB Keyboard controller exists there.  *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAlienwareAW510KControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AlienwareAW510KController*     controller     = new AlienwareAW510KController(dev, info->path);
-        RGBController_AlienwareAW510K* rgb_controller = new RGBController_AlienwareAW510K(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}   /* DetectAlienwareKeyboardControllers() */
-
-
-REGISTER_HID_DETECTOR_IPU("Alienware AW510K",   DetectAlienwareAW510KControllers,   ALIENWARE_VID,  ALIENWARE_AW510K_PID,   0x02,   0xFF00, 0x01);
@@ -1,499 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AlienwareAW510K.cpp        |
-|                                           |
-|  Generic RGB Interface for alienware      |
-|  AW510K Keyboard                          |
-|                                           |
-|  Mohamad Sallal - msallal      05/22/2021 |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_AlienwareAW510K.h"
-#include <iterator>
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-int GetAW520K_WaveDirection(int input);
-
-static unsigned int matrix_map[7][24] =
-{ {  0,   NA,   1,   2,   3,   4,  NA,   5,   6,   7,   8,   9,  10,  11,  12,  NA,  13,  14,  15,  NA,  16,  NA,  NA,  NA },
-  {  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  NA,  NA,  31,  32,  33,  NA,  34,  35,  36,  37 },
-  {  38,  NA,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  NA,  52,  53,  54,  NA,  55,  56,  57,  74 },
-  {  58,  NA,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  NA,  70,  NA,  NA,  NA,  NA,  NA,  71,  72,  73,  NA },
-  {  75,  NA,  NA,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  NA,  NA,  NA,  87,  NA,  NA,  88,  89,  90, 104 },
-  {  91,  NA,  92,  93,  NA,  94,  NA,  NA,  NA,  NA,  NA,  95,  96,  97,  98,  NA,  99, 100, 101,  NA, 102,  NA, 103,  NA },
-  {  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  105, NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA }};
-
-static const char* zone_names[] =
-{
-    "AW510K",
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX,
-};
-
-static const unsigned int zone_sizes[] =
-{
-    106,
-};
-
-typedef struct
-{
-    const char *        name;
-    const unsigned char zone;
-    const unsigned char idx;
-} led_type;
-
-static const led_type led_names[] =
-{
-    /* Key Label                Zone,                                      Index  */
-    { KEY_EN_ESCAPE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB0    },
-    { KEY_EN_F1,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x98    },
-    { KEY_EN_F2,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x90    },
-    { KEY_EN_F3,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x88    },
-    { KEY_EN_F4,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x80    },
-    { KEY_EN_F5,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x70    },
-    { KEY_EN_F6,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x68    },
-    { KEY_EN_F7,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x60    },
-    { KEY_EN_F8,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x58    },
-    { KEY_EN_F9,                ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x50    },
-    { KEY_EN_F10,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x48    },
-    { KEY_EN_F11,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x40    },
-    { KEY_EN_F12,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x38    },
-    { KEY_EN_PRINT_SCREEN,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x30    },
-    { KEY_EN_SCROLL_LOCK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x28    },
-    { KEY_EN_PAUSE_BREAK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x20    },
-    { KEY_EN_MEDIA_MUTE,        ALIENWARE_AW510K_ZONE_DIRECT_MEDIA,        0x18    },
-    { KEY_EN_BACK_TICK,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB1    },
-    { KEY_EN_1,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA1    },
-    { KEY_EN_2,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x99    },
-    { KEY_EN_3,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x91    },
-    { KEY_EN_4,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x89    },
-    { KEY_EN_5,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x81    },
-    { KEY_EN_6,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x79    },
-    { KEY_EN_7,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x71    },
-    { KEY_EN_8,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x69    },
-    { KEY_EN_9,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x61    },
-    { KEY_EN_0,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x59    },
-    { KEY_EN_MINUS,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x51    },
-    { KEY_EN_EQUALS,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x49    },
-    { KEY_EN_BACKSPACE,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x39    },
-    { KEY_EN_INSERT,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x31    },
-    { KEY_EN_HOME,              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x29    },
-    { KEY_EN_PAGE_UP,           ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x21    },
-    { KEY_EN_NUMPAD_LOCK,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x19    },
-    { KEY_EN_NUMPAD_DIVIDE,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x11    },
-    { KEY_EN_NUMPAD_TIMES,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x09    },
-    { KEY_EN_NUMPAD_MINUS,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x01    },
-    { KEY_EN_TAB,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB2    },
-    { KEY_EN_Q,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA2    },
-    { KEY_EN_W,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9A    },
-    { KEY_EN_E,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x92    },
-    { KEY_EN_R,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8A    },
-    { KEY_EN_T,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x82    },
-    { KEY_EN_Y,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7A    },
-    { KEY_EN_U,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x72    },
-    { KEY_EN_I,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6A    },
-    { KEY_EN_O,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x62    },
-    { KEY_EN_P,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5A    },
-    { KEY_EN_LEFT_BRACKET,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x52    },
-    { KEY_EN_RIGHT_BRACKET,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4A    },
-    { KEY_EN_ANSI_BACK_SLASH,   ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x42    },//ANSI only
-    { KEY_EN_DELETE,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x32    },
-    { KEY_EN_END,               ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2A    },
-    { KEY_EN_PAGE_DOWN,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x22    },
-    { KEY_EN_NUMPAD_7,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1A    },
-    { KEY_EN_NUMPAD_8,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x12    },
-    { KEY_EN_NUMPAD_9,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0A    },
-    { KEY_EN_CAPS_LOCK,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB3    },
-    { KEY_EN_A,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA3    },
-    { KEY_EN_S,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9B    },
-    { KEY_EN_D,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x93    },
-    { KEY_EN_F,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8B    },
-    { KEY_EN_G,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x83    },
-    { KEY_EN_H,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7B    },
-    { KEY_EN_J,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x73    },
-    { KEY_EN_K,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6B    },
-    { KEY_EN_L,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x63    },
-    { KEY_EN_SEMICOLON,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5B    },
-    { KEY_EN_QUOTE,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x53    },
-    { KEY_EN_ANSI_ENTER,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x43    },
-    { KEY_EN_NUMPAD_4,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1B    },
-    { KEY_EN_NUMPAD_5,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x13    },
-    { KEY_EN_NUMPAD_6,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0B    },
-    { KEY_EN_NUMPAD_PLUS,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x03    },
-    { KEY_EN_LEFT_SHIFT,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB4    },
-    { KEY_EN_Z,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA4    },
-    { KEY_EN_X,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x9C    },
-    { KEY_EN_C,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x94    },
-    { KEY_EN_V,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x8C    },
-    { KEY_EN_B,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x84    },
-    { KEY_EN_N,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x7C    },
-    { KEY_EN_M,                 ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x74    },
-    { KEY_EN_COMMA,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x6C    },
-    { KEY_EN_PERIOD,            ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x64    },
-    { KEY_EN_FORWARD_SLASH,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5C    },
-    { KEY_EN_RIGHT_SHIFT,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4C    },
-    { KEY_EN_UP_ARROW,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2C    },
-    { KEY_EN_NUMPAD_1,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1C    },
-    { KEY_EN_NUMPAD_2,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x14    },
-    { KEY_EN_NUMPAD_3,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0C    },
-    { KEY_EN_LEFT_CONTROL,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xB5    },
-    { KEY_EN_LEFT_WINDOWS,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xAD    },
-    { KEY_EN_LEFT_ALT,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0xA5    },
-    { KEY_EN_SPACE,             ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x85    },
-    { KEY_EN_RIGHT_ALT,         ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x65    },
-    { KEY_EN_RIGHT_FUNCTION,    ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x5D    },
-    { KEY_EN_MENU,              ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x55    },
-    { KEY_EN_RIGHT_CONTROL,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x4D    },
-    { KEY_EN_LEFT_ARROW,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x35    },
-    { KEY_EN_DOWN_ARROW,        ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x2D    },
-    { KEY_EN_RIGHT_ARROW,       ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x25    },
-    { KEY_EN_NUMPAD_0,          ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x1D    },
-    { KEY_EN_NUMPAD_PERIOD,     ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x0D    },
-    { KEY_EN_NUMPAD_ENTER,      ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD,     0x05    },
-    { "Logo",                   ALIENWARE_AW510K_ZONE_DIRECT_LOGO,         0x07    }
-};
-
-/**------------------------------------------------------------------*\
-    @name Alienware AW510 Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAlienwareAW510KControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "Alienware AW510K Keyboard Device";
-    vendor      = "Alienware";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Alienware AW510K Keyboard Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct_Per_LED;
-    Direct_Per_LED.name             = "Direct";
-    Direct_Per_LED.value            = ALIENWARE_AW510K_MODE_DIRECT_PER_LED;
-    Direct_Per_LED.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct_Per_LED.color_mode       = MODE_COLORS_PER_LED;
-    modes.push_back(Direct_Per_LED);
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = ALIENWARE_AW510K_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Pulse;
-    Pulse.name                      = "Pulse";
-    Pulse.value                     = ALIENWARE_AW510K_MODE_PULSE;
-    Pulse.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulse.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
-    Pulse.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
-    Pulse.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
-    Pulse.colors_min                = 1;
-    Pulse.colors_max                = 1;
-    Pulse.colors.resize(1);
-    modes.push_back(Pulse);
-
-    mode Morph;
-    Morph.name                      = "Morph";
-    Morph.value                     = ALIENWARE_AW510K_MODE_MORPH;
-    Morph.flags                     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Morph.color_mode                = MODE_COLORS_MODE_SPECIFIC;
-    Morph.speed_min                 = ALIENWARE_AW510K_SPEED_SLOWEST;
-    Morph.speed_max                 = ALIENWARE_AW510K_SPEED_NORMAL;
-    Morph.speed                     = ALIENWARE_AW510K_SPEED_NORMAL;
-    Morph.colors_min                = 2;
-    Morph.colors_max                = 2;
-    Morph.colors.resize(2);
-    modes.push_back(Morph);
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = ALIENWARE_AW510K_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    Breathing.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
-    Breathing.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
-    Breathing.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
-    modes.push_back(Breathing);
-
-    mode SingleWave;
-    SingleWave.name                  = "Single Wave";
-    SingleWave.value                 = ALIENWARE_AW510K_MODE_SINGLE_WAVE;
-    SingleWave.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    SingleWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
-    SingleWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
-    SingleWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
-    SingleWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    SingleWave.colors_min            = 1;
-    SingleWave.colors_max            = 1;
-    SingleWave.colors.resize(1);
-    modes.push_back(SingleWave);
-
-    mode RainbowWave;
-    RainbowWave.name                  = "Rainbow Wave";
-    RainbowWave.value                 = ALIENWARE_AW510K_MODE_RAINBOW_WAVE;
-    RainbowWave.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
-    RainbowWave.speed_min             = ALIENWARE_AW510K_SPEED_SLOWEST;
-    RainbowWave.speed_max             = ALIENWARE_AW510K_SPEED_FASTEST;
-    RainbowWave.speed                 = ALIENWARE_AW510K_SPEED_NORMAL;
-    RainbowWave.colors_min            = 1;
-    RainbowWave.colors_max            = 1;
-    RainbowWave.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RainbowWave.colors.resize(1);
-    modes.push_back(RainbowWave);
-
-    mode Off;
-    Off.name                          = "Off";
-    Off.value                         = ALIENWARE_AW510K_MODE_OFF;
-    Off.flags                         = 0;
-    Off.color_mode                    = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    SetupZones();
-    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
-}
-
-RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
-{
-    /*---------------------------------------------------------*\
-    | Delete the matrix map                                     |
-    \*---------------------------------------------------------*/
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        if(zones[zone_index].matrix_map != NULL)
-        {
-            delete zones[zone_index].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_AlienwareAW510K::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 7;
-            new_zone.matrix_map->width  = 24;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AlienwareAW510K::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AlienwareAW510K::DeviceUpdateLEDs()
-{
-    std::vector<SelectedKeys>   frame_buf_keys;
-    std::vector<RGBColor>       new_colors;
-
-    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
-
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        if (current_colors[led_idx]==new_colors[led_idx])
-        {
-            /*-------------------------------------------------*\
-            | Don't send if key color is not changed            |
-            \*-------------------------------------------------*/
-            continue;
-        }
-
-        if(RGBGetRValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00 || RGBGetBValue(colors[led_idx]) != 0x00)
-        {
-            SelectedKeys key;
-
-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
-
-            frame_buf_keys.push_back(key);
-        }
-        else
-        {
-            SelectedKeys key;
-
-            key.idx     = (unsigned char)leds[led_idx].value;
-            key.red     = RGBGetRValue(colors[led_idx]);
-            key.green   = RGBGetGValue(colors[led_idx]);
-            key.blue    = RGBGetBValue(colors[led_idx]);
-
-            frame_buf_keys.push_back(key);
-        }
-    }
-
-    controller->SendInitialize();
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    controller->SendCommit();
-
-    if(frame_buf_keys.size() > 0)
-    {
-        controller->SendDirectOn(frame_buf_keys);
-    }
-
-    std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
-}
-
-void RGBController_AlienwareAW510K::UpdateZoneLEDs(int zone)
-{
-    controller->SetDirect((unsigned char) zone, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
-}
-
-void RGBController_AlienwareAW510K::UpdateSingleLED(int led)
-{
-    controller->UpdateSingleLED(leds[led].value, RGBGetRValue(colors[led]), RGBGetGValue(colors[led]), RGBGetBValue(colors[led]));
-}
-
-void RGBController_AlienwareAW510K::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AlienwareAW510K::DeviceUpdateMode()
-{
-    if(active_mode == 0xFFFF)
-    {
-        UpdateLEDs();
-        return;
-    }
-
-    controller->SendfeatureReport(0x05, 0x01, 0x51, 0x00);
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    switch(modes[active_mode].value)
-    {
-        case ALIENWARE_AW510K_MODE_MORPH:
-            /*-------------------------------------------------------------*\
-            | In case of morph it requires two colors (color1 and color2)   |
-            \*-------------------------------------------------------------*/
-            {
-                unsigned char red2 = RGBGetRValue(modes[active_mode].colors[1]);
-                unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
-                unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
-
-                controller->SetMorphMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, red2, grn2, blu2);
-            }
-            break;
-
-        case ALIENWARE_AW510K_MODE_SPECTRUM:
-            /*-------------------------------------------------------------*\
-            | Spectrum only set mode, speed and colorMode                   |
-            \*-------------------------------------------------------------*/
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            break;
-
-        case ALIENWARE_AW510K_MODE_SINGLE_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-                int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
-                controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
-            }
-            break;
-
-        case ALIENWARE_AW510K_MODE_RAINBOW_WAVE:
-            /*-------------------------------------------------------------*\
-            | Wave only set mode, speed, direction and colorMode            |
-            \*-------------------------------------------------------------*/
-            {
-            int waveDirection = GetAW520K_WaveDirection(modes[active_mode].direction);
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, waveDirection, ALIENWARE_AW510K_RANBOW_COLOR_MODE, 0x00, 0x00, 0x00);
-            }
-            break;
-
-
-        default:
-            controller->SetMode(modes[active_mode].value, modes[active_mode].speed, 0x00, ALIENWARE_AW510K_SINGLE_COLOR_MODE, red, grn, blu);
-            break;
-    }
-}
-
-int GetAW520K_WaveDirection(int input)
-{
-    switch(input)
-    {
-        case MODE_DIRECTION_LEFT:
-            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
-
-        case MODE_DIRECTION_RIGHT:
-            return(ALIENWARE_AW510K_DIRECTION_LEFT_TO_RIGHT);
-
-        case MODE_DIRECTION_UP:
-            return(ALIENWARE_AW510K_DIRECTION_BOTTOM_TO_TOP);
-
-        case MODE_DIRECTION_DOWN:
-            return(ALIENWARE_AW510K_DIRECTION_TOP_TO_BOTTOM);
-
-        default:
-            return(ALIENWARE_AW510K_DIRECTION_RIGHT_TO_LEFT);
-    }
-}
-
@@ -1,35 +0,0 @@
-/*-----------------------------------------*\
-|  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        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AlienwareAW510KController*  controller;
-    std::vector<RGBColor>       current_colors;
-};
@@ -1,122 +0,0 @@
-/*-----------------------------------------*\
-|  AnnePro2Controller.cpp                   |
-|                                           |
-|  Driver for Obins Lab AnnePro2 keyboard   |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
-
-#include "AnnePro2Controller.h"
-
-using namespace std::chrono_literals;
-
-AnnePro2Controller::AnnePro2Controller(hid_device* dev_handle, const char* path) 
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AnnePro2Controller::~AnnePro2Controller() 
-{
-    hid_close(dev);
-}
-
-std::string AnnePro2Controller::GetDeviceLocation() 
-{
-    return("HID: " + location);
-}
-
-std::string AnnePro2Controller::GetSerialString() 
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-void AnnePro2Controller::SendDirect(unsigned char frame_count, unsigned char * frame_data) 
-{
-    /*-------------------------------------------------------------*\
-    | Reverse engineered by https://github.com/manualmanul/Annemone |
-    \*-------------------------------------------------------------*/
-
-    const unsigned char hid_cmd_service_data_length                             = 4;
-    const unsigned char hid_cmd_service_data[hid_cmd_service_data_length]       = {0, 123, 16, 65};
-
-    const unsigned char hid_cmd_static_message_length                           = 3;
-    const unsigned char hid_cmd_static_message[hid_cmd_static_message_length]   = {0, 0, 125};
-
-    const unsigned char hid_cmd_command_info_length                             = 3;
-    const unsigned char hid_cmd_command_info[hid_cmd_command_info_length]       = {32, 3, 255};
-
-    const unsigned char real_command_info_length                                = hid_cmd_command_info_length + 1;
-    const unsigned char max_hid_length                                          = 64;
-
-    const unsigned char max_command_length                                      = max_hid_length - hid_cmd_service_data_length - 2 - hid_cmd_static_message_length;
-    const unsigned char max_message_length                                      = max_command_length - real_command_info_length;
-    const unsigned char messages_to_send_amount                                 = frame_count / max_message_length + 1;
-    const unsigned char val_1                                                   = frame_count % max_message_length;
-    const unsigned char val_2                                                   = (0 == val_1) ? max_message_length : val_1;
-
-    unsigned char hid_command[max_hid_length];
-
-    unsigned char led_data = 0;
-
-    for(unsigned char p = 0; p < messages_to_send_amount; p++)
-    {
-        const unsigned char e = (messages_to_send_amount << 4) + p;
-        const unsigned char a = ((messages_to_send_amount - 1) == p) ? val_2 + real_command_info_length : max_message_length + real_command_info_length;
-        
-        /*---------------------------------------------------------*\
-        | Service data                                              |
-        \*---------------------------------------------------------*/
-        hid_command[0] = hid_cmd_service_data[0];
-        hid_command[1] = hid_cmd_service_data[1];
-        hid_command[2] = hid_cmd_service_data[2];
-        hid_command[3] = hid_cmd_service_data[3];
-
-        hid_command[4] = e;
-        hid_command[5] = a;
-
-        /*---------------------------------------------------------*\
-        | Static message                                            |
-        \*---------------------------------------------------------*/
-        hid_command[6] = hid_cmd_static_message[0];
-        hid_command[7] = hid_cmd_static_message[1];
-        hid_command[8] = hid_cmd_static_message[2];
-
-        /*---------------------------------------------------------*\
-        | Command info                                              |
-        \*---------------------------------------------------------*/
-        hid_command[9] = hid_cmd_command_info[0];
-        hid_command[10] = hid_cmd_command_info[1];
-        hid_command[11] = hid_cmd_command_info[2];
-
-        hid_command[12] = 2;
-
-        /*---------------------------------------------------------*\
-        | LED data                                                  |
-        \*---------------------------------------------------------*/
-        for(uint8_t i = 0; i < max_message_length; i++)
-        {
-            hid_command[13 + i] = frame_data[led_data];
-            led_data++;
-        }
-
-        hid_write(dev, hid_command, max_hid_length);
-
-        /*---------------------------------------------------------*\
-        | Needed due to Anne Pro 2 ignoring commands when they're   |
-        | sent faster than 50ms apart from each other.              |
-        \*---------------------------------------------------------*/
-        std::this_thread::sleep_for(50ms);
-    }
-}
@@ -1,36 +0,0 @@
-/*-----------------------------------------*\
-|  AnnePro2Controller.h                     |
-|                                           |
-|  Driver for Obins Lab AnnePro2 keyboard   |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-class AnnePro2Controller
-{
-public:
-    AnnePro2Controller(hid_device* dev_handle, const char* path);
-    ~AnnePro2Controller();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-        (
-        unsigned char       frame_count,
-        unsigned char *     frame_data
-        );
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,36 +0,0 @@
-#include "Detector.h"
-#include "AnnePro2Controller.h"
-#include "RGBController.h"
-#include "RGBController_AnnePro2.h"
-#include <hidapi/hidapi.h>
-
-#define ANNE_PRO_2_VID 0x04D9
-#define ANNE_PRO_2_PID_1 0x8008
-#define ANNE_PRO_2_PID_2 0x8009
-#define ANNE_PRO_2_PID_3 0xA292
-#define ANNE_PRO_2_PID_4 0xA293
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAnnePro2Controllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Obins Lab AnnePro2 keyboard exists there.       *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAnnePro2Controllers(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AnnePro2Controller*     controller     = new AnnePro2Controller(dev, info->path);
-        RGBController_AnnePro2* rgb_controller = new RGBController_AnnePro2(controller);
-        // Constructor sets the name
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_1, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
-REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
@@ -1,246 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AnnePro2.cpp               |
-|                                           |
-|  Generic RGB Interface for Obins Lab      |
-|  AnnePro2 keyboard                        |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_AnnePro2.h"
-
-#define NA              0xFFFFFFFF
-#define LED_REAL_COUNT  (5*14)
-#define LED_COUNT       (LED_REAL_COUNT - 9)
-
-static unsigned int matrix_map[5][14] =
-    { { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 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, NA },
-      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA }, 
-      { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };
-
-static const char* zone_names[] =
-{
-    "Keyboard",
-};
-
-static zone_type zone_types[] =
-{
-    ZONE_TYPE_MATRIX
-};
-
-static const unsigned int zone_sizes[] =
-{
-    LED_COUNT,
-};
-
-typedef struct
-{
-    const char *        name;
-    const unsigned char idx;
-} led_type;
-
-static const led_type led_names[] =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0       },
-    { KEY_EN_1,                 1       },
-    { KEY_EN_2,                 2       },
-    { KEY_EN_3,                 3       },
-    { KEY_EN_4,                 4       },
-    { KEY_EN_5,                 5       },
-    { KEY_EN_6,                 6       },
-    { KEY_EN_7,                 7       },
-    { KEY_EN_8,                 8       },
-    { KEY_EN_9,                 9       },
-    { KEY_EN_0,                 10      },
-    { KEY_EN_MINUS,             11      },
-    { KEY_EN_EQUALS,            12      },
-    { KEY_EN_BACKSPACE,         13      },
-    { KEY_EN_TAB,               14      },
-    { KEY_EN_Q,                 15      },
-    { KEY_EN_W,                 16      },
-    { KEY_EN_E,                 17      },
-    { KEY_EN_R,                 18      },
-    { KEY_EN_T,                 19      },
-    { KEY_EN_Y,                 20      },
-    { KEY_EN_U,                 21      },
-    { KEY_EN_I,                 22      },
-    { KEY_EN_O,                 23      },
-    { KEY_EN_P,                 24      },
-    { KEY_EN_LEFT_BRACKET,      25      },
-    { KEY_EN_RIGHT_BRACKET,     26      },
-    { KEY_EN_ANSI_BACK_SLASH,   27      },
-    { KEY_EN_CAPS_LOCK,         28      },
-    { KEY_EN_A,                 29      },
-    { KEY_EN_S,                 30      },
-    { KEY_EN_D,                 31      },
-    { KEY_EN_F,                 32      },
-    { KEY_EN_G,                 33      },
-    { KEY_EN_H,                 34      },
-    { KEY_EN_J,                 35      },
-    { KEY_EN_K,                 36      },
-    { KEY_EN_L,                 37      },
-    { KEY_EN_SEMICOLON,         38      },
-    { KEY_EN_QUOTE,             39      },
-    { KEY_EN_ANSI_ENTER,        40      },
-    { KEY_EN_LEFT_SHIFT,        41      },
-    { KEY_EN_Z,                 42      },
-    { KEY_EN_X,                 43      },
-    { KEY_EN_C,                 44      },
-    { KEY_EN_V,                 45      },
-    { KEY_EN_B,                 46      },
-    { KEY_EN_N,                 47      },
-    { KEY_EN_M,                 48      },
-    { KEY_EN_COMMA,             49      },
-    { KEY_EN_PERIOD,            50      },
-    { KEY_EN_FORWARD_SLASH,     51      },
-    { KEY_EN_RIGHT_SHIFT,       52      },
-    { KEY_EN_LEFT_CONTROL,      53      },
-    { KEY_EN_LEFT_WINDOWS,      54      },
-    { KEY_EN_LEFT_ALT,          55      },
-    { KEY_EN_SPACE,             56      },
-    { KEY_EN_RIGHT_ALT,         57      },
-    { KEY_EN_RIGHT_FUNCTION,    58      },
-    { KEY_EN_MENU,              59      },
-    { KEY_EN_RIGHT_CONTROL,     60      },
-};
-
-/**------------------------------------------------------------------*\
-    @name Anne Pro 2
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAnnePro2Controllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr) 
-{
-    controller  = controller_ptr;
-
-    name        = "Anne Pro 2";
-    vendor      = "Obinslab";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "Obinslab Anne Pro 2 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_AnnePro2::~RGBController_AnnePro2() 
-{
-    delete controller;
-}
-
-void RGBController_AnnePro2::SetupZones() 
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < 1; zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = zone_names[zone_idx];
-        new_zone.type                   = zone_types[zone_idx];
-        new_zone.leds_min               = zone_sizes[zone_idx];
-        new_zone.leds_max               = zone_sizes[zone_idx];
-        new_zone.leds_count             = zone_sizes[zone_idx];
-
-        if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = new matrix_map_type;
-            new_zone.matrix_map->height = 5;
-            new_zone.matrix_map->width  = 14;
-            new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += zone_sizes[zone_idx];
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/) 
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AnnePro2::DeviceUpdateLEDs() 
-{
-    const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
-    unsigned char frame_buf[frame_buf_length];
-
-    /*---------------------------------------------------------*\
-    | TODO: Send packets with multiple LED frames               |
-    \*---------------------------------------------------------*/
-    std::size_t led_real_idx = 0;
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        frame_buf[(led_real_idx * 3) + 0] = RGBGetRValue(colors[led_idx]);
-        frame_buf[(led_real_idx * 3) + 1] = RGBGetGValue(colors[led_idx]);
-        frame_buf[(led_real_idx * 3) + 2] = RGBGetBValue(colors[led_idx]);
-
-        if(led_idx == 40 || led_idx == 41 || led_idx == 52 || led_idx == 53 || led_idx == 60)
-        {
-            led_real_idx++;
-        }
-        else if(led_idx == 55 || led_idx == 56)
-        {
-            led_real_idx++;
-            led_real_idx++;
-        }
-
-        led_real_idx++;
-    }
-
-    controller->SendDirect(frame_buf_length, frame_buf);
-}
-
-void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AnnePro2::UpdateSingleLED(int /*led*/) 
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AnnePro2::SetCustomMode() 
-{
-    active_mode = 0;
-}
-
-void RGBController_AnnePro2::DeviceUpdateMode() 
-{
-    
-}
@@ -1,32 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AnnePro2.h                 |
-|                                           |
-|  Generic RGB Interface for Obins Lab      |
-|  AnnePro2 keyboard                        |
-|                                           |
-|  Sergey Gavrilov (DrZlo13) 06/06/2021     |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AnnePro2Controller.h"
-
-class RGBController_AnnePro2 : public RGBController
-{
-public:
-    RGBController_AnnePro2(AnnePro2Controller* controller_ptr);
-    ~RGBController_AnnePro2();
-
-    void        SetupZones();
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AnnePro2Controller*   controller;
-};
@@ -1,410 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraCoreController.cpp               | 
-|                                           |
-|  Driver for ASUS ROG Aura Core RGB        |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/13/2020   |
-\*-----------------------------------------*/
-
-#include "AsusAuraCoreController.h"
-#include <cstring>
-
-#define AURA_CORE_MAX_MESSAGE_SIZE  64
-
-AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
-{
-    dev                         = dev_handle;
-    location                    = path;
-
-    aura_device.aura_type       = AURA_CORE_DEVICE_UNKNOWN;
-    aura_device.buff_size       = 0;
-    aura_device.report_id       = 0x5D;
-    aura_device.num_leds        = 4;
-    aura_device.supports_direct = false;
-
-    IdentifyDevice();
-    Handshake();
-}
-
-AuraCoreController::~AuraCoreController()
-{
-    hid_close(dev);
-}
-
-std::string AuraCoreController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraCoreController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-void AuraCoreController::SendBrightness
-    (
-    unsigned char   brightness
-    )
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
-    {
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = 0x5A;
-        usb_buf[0x01]   = AURA_CORE_COMMAND_BRIGHTNESS;
-        usb_buf[0x02]   = 0xC5;
-        usb_buf[0x03]   = 0xC4;
-        usb_buf[0x04]   = brightness;
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-    }
-}
-
-void AuraCoreController::SendUpdate
-    (
-    unsigned char   zone,
-    unsigned char   mode,
-    unsigned char   speed,
-    unsigned char   dir,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
-    {
-        if(aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
-        {
-            zone += 1;
-        }
-
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = aura_device.report_id;
-        usb_buf[0x01]   = AURA_CORE_COMMAND_UPDATE;
-        usb_buf[0x02]   = zone;
-        usb_buf[0x03]   = mode;
-        usb_buf[0x04]   = red;
-        usb_buf[0x05]   = green;
-        usb_buf[0x06]   = blue;
-        usb_buf[0x07]   = speed;
-        usb_buf[0x08]   = dir;
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-    }
-}
-
-void AuraCoreController::SendSet()
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
-    {
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = aura_device.report_id;
-        usb_buf[0x01]   = AURA_CORE_COMMAND_SET;
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-    }
-}
-
-void AuraCoreController::SendApply()
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-    if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
-    {
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = aura_device.report_id;
-        usb_buf[0x01]   = AURA_CORE_COMMAND_APPLY;
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-    }
-}
-
-void AuraCoreController::InitDirectMode()
-{
-    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-    unsigned char   msg_num   = 0;
-    int             led_count = aura_device.num_leds;
-
-    if(aura_device.supports_direct)
-    {
-        /*-----------------------------------------------------*\
-        | Zero out buffer                                       |
-        \*-----------------------------------------------------*/
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        /*-----------------------------------------------------*\
-        | Set up message packet                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x00]   = aura_device.report_id;
-        usb_buf[0x01]   = AURA_CORE_COMMAND_DIRECT;
-        usb_buf[0x02]   = 0xD0;
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-
-        while(led_count > 0)
-        {
-            /*-----------------------------------------------------*\
-            | Set up second message packet                         |
-            \*-----------------------------------------------------*/
-            usb_buf[0x03]   = 0x01;
-            usb_buf[0x04]   = 0x02;
-            usb_buf[0x05]   = 0x00;
-            usb_buf[0x06]   = msg_num++;
-            usb_buf[0x07]   = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
-            usb_buf[0x08]   = 0x00;
-
-            /*-----------------------------------------------------*\
-            | Send packet 2                                         |
-            \*-----------------------------------------------------*/
-            hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-
-            led_count -= aura_device.max_leds_per_message;
-        }
-    }
-}
-
-void AuraCoreController::UpdateDirect(std::vector<AuraColor>& color_set)
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-    unsigned char msg_num       = 0;
-    unsigned char color_index   = 0;
-    unsigned char set_count     = 0;
-    int           led_count     = aura_device.num_leds;
-
-    if(aura_device.supports_direct)
-    {
-        while(led_count > 0)
-        {
-            unsigned char msg_index = 0x09;
-
-            /*-----------------------------------------------------*\
-            | Zero out buffer                                       |
-            \*-----------------------------------------------------*/
-            memset(usb_buf, 0x00, sizeof(usb_buf));
-
-            /*-----------------------------------------------------*\
-            | Set up message packet                                 |
-            \*-----------------------------------------------------*/
-            usb_buf[0x00]   = aura_device.report_id;
-            usb_buf[0x01]   = AURA_CORE_COMMAND_DIRECT;
-            usb_buf[0x02]   = 0xD0;
-            usb_buf[0x03]   = 0x01;
-            usb_buf[0x04]   = 0x02;
-            usb_buf[0x05]   = 0x00;
-            usb_buf[0x06]   = msg_num++;
-            usb_buf[0x07]   = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
-            usb_buf[0x08]   = 0x00;
-
-            set_count = 0;
-
-            while( (msg_index < sizeof(usb_buf)                 ) &&
-                   (led_count > 0                               ) &&
-                   (set_count < aura_device.max_leds_per_message)    )
-            {
-                if(color_index < color_set.size())
-                {
-                    usb_buf[msg_index++] = color_set[color_index].red;
-                    usb_buf[msg_index++] = color_set[color_index].green;
-                    usb_buf[msg_index++] = color_set[color_index].blue;
-                }
-                else
-                {
-                    usb_buf[msg_index++] = 0;
-                    usb_buf[msg_index++] = 0;
-                    usb_buf[msg_index++] = 0;
-                }
-
-                led_count--;
-                color_index++;
-                set_count++;
-            }
-
-            /*-----------------------------------------------------*\
-            | Send packet                                           |
-            \*-----------------------------------------------------*/
-            hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-        }
-    }
-}
-
-void AuraCoreController::IdentifyDevice()
-{
-    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-    int             num_bytes       = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | First, attempt to read the report from the Keyboard   |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = aura_device.report_id;
-
-    num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Currently, there is no need to attempt to read the    |
-    | returned data.  If the device responded,to the report,|
-    | we're good.                                           |
-    \*-----------------------------------------------------*/
-    if(num_bytes > 0)
-    {
-        aura_device.aura_type                   = AURA_CORE_DEVICE_KEYBOARD;
-        aura_device.buff_size                   = 17;
-        aura_device.report_id                   = 0x5D;
-        aura_device.num_leds                    = 4;
-        aura_device.supports_direct             = false;
-    }
-    else if(num_bytes == -1)
-    {
-        /*-------------------------------------------------*\
-        | First, attempt to read the report from the        |
-        | Keyboard                                          |
-        \*-------------------------------------------------*/
-        usb_buf[0]                              = 0x5E;
-        num_bytes                               = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
-
-        if(num_bytes > 0)
-        {
-            /*---------------------------------------------*\
-            | Currently, there is no need to attempt to     |
-            | read the returned data.  If the device        |
-            | responded,to the report, we're good.          |
-            \*---------------------------------------------*/
-            aura_device.aura_type               = AURA_CORE_DEVICE_GA15DH;
-            aura_device.buff_size               = 64;
-            aura_device.report_id               = 0x5E;
-            aura_device.num_leds                = 20;
-            aura_device.max_leds_per_message    = 16;
-            aura_device.supports_direct         = true;
-        }
-    }
-}
-
-void AuraCoreController::Handshake()
-{
-    unsigned char     usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-
-    if(aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
-    {
-        usb_buf[0] = 0x5E;
-        SendIdString();
-        hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
-        SendQuery();
-        hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
-    }
-}
-
-void AuraCoreController::SendIdString()
-{
-    unsigned char   usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-    const char      id[] = "ASUS Tech.Inc.";
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = aura_device.report_id;
-
-    /*-----------------------------------------------------*\
-    | Copy in string data                                   |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x01], id, sizeof(id));
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-}
-
-void AuraCoreController::SendQuery()
-{
-    unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = aura_device.report_id;
-    usb_buf[0x01]   = 0x05;
-    usb_buf[0x02]   = 0x20;
-    usb_buf[0x03]   = 0x31;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = 0x10;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
-}
@@ -1,123 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraCoreController.h                 |
-|                                           |
-|  Definitions and types for ASUS ROG Aura  |
-|  Core RGB lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/13/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum AuraCoreDeviceType
-{
-    AURA_CORE_DEVICE_UNKNOWN            = 0,
-    AURA_CORE_DEVICE_KEYBOARD           = 1,
-    AURA_CORE_DEVICE_GA15DH             = 2
-};
-
-enum
-{
-    AURA_CORE_MODE_STATIC               =   0,      /* Static color mode                    */
-    AURA_CORE_MODE_BREATHING            =   1,      /* Breathing effect mode                */
-    AURA_CORE_MODE_SPECTRUM_CYCLE       =   2,      /* Spectrum Cycle mode                  */
-    AURA_CORE_MODE_RAINBOW              =   3,      /* Rainbow mode                         */
-    AURA_CORE_MODE_STROBE               =  10,      /* Strobe mode                          */
-    AURA_CORE_MODE_COMET                =  11,      /* Comet mode                           */
-    AURA_CORE_MODE_FLASHNDASH           =  12,      /* Flash & Dash mode                    */
-    AURA_CORE_MODE_IRRADIATION          =  17,      /* Irradiation mode                     */
-    AURA_CORE_MODE_DIRECT               = 255       /* Not a real mode - but need a way to differentiate */
-};
-
-enum
-{
-    AURA_CORE_COMMAND_UPDATE            = 0xB3,     /* Update mode and color                */
-    AURA_CORE_COMMAND_SET               = 0xB5,     /* Set command                          */
-    AURA_CORE_COMMAND_APPLY             = 0xB4,     /* Apply command                        */
-    AURA_CORE_COMMAND_BRIGHTNESS        = 0xBA,     /* Brightness command                   */
-    AURA_CORE_COMMAND_DIRECT            = 0xBC      /* Set LEDs directly                    */
-};
-
-enum
-{
-    AURA_CORE_ZONE_IDX_ALL              = 0x00,     /* Update all zones                     */
-    AURA_CORE_ZONE_IDX_1                = 0x01,     /* Update zone 1                        */
-    AURA_CORE_ZONE_IDX_2                = 0x02,     /* Update zone 2                        */
-    AURA_CORE_ZONE_IDX_3                = 0x03,     /* Update zone 3                        */
-    AURA_CORE_ZONE_IDX_4                = 0x04,     /* Update zone 4                        */
-};
-
-enum
-{
-    AURA_CORE_SPEED_SLOW                = 0xE1,     /* Slowest speed                        */
-    AURA_CORE_SPEED_NORMAL              = 0xEB,     /* Normal speed                         */
-    AURA_CORE_SPEED_FAST                = 0xF5,     /* Fastest speed                        */
-};
-
-struct AuraDeviceDescriptor
-{
-    AuraCoreDeviceType  aura_type;
-    unsigned char       buff_size;
-    unsigned char       report_id;
-    unsigned char       num_leds;
-    unsigned char       max_leds_per_message;
-    bool                supports_direct;
-};
-
-struct AuraColor
-{
-    unsigned char   red;
-    unsigned char   green;
-    unsigned char   blue;
-};
-
-class AuraCoreController
-{
-public:
-    AuraDeviceDescriptor    aura_device;
-
-    AuraCoreController(hid_device* dev_handle, const char* path);
-    ~AuraCoreController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void    SendBrightness
-                (
-                unsigned char   brightness
-                );
-
-    void    SendUpdate
-                (
-                unsigned char   zone,
-                unsigned char   mode,
-                unsigned char   speed,
-                unsigned char   dir,
-                unsigned char   red,
-                unsigned char   green,
-                unsigned char   blue
-                );
-
-    void    SendSet();
-
-    void    SendApply();
-
-    void    InitDirectMode();
-
-    void    UpdateDirect(std::vector<AuraColor>& color_set);
-
-private:
-    hid_device*             dev;
-    std::string             location;
-
-    void    IdentifyDevice();
-    void    Handshake();
-    void    SendIdString();
-    void    SendQuery();
-
-};
@@ -1,38 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraCoreController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraCore.h"
-#include <hidapi/hidapi.h>
-
-#define AURA_CORE_VID 0x0B05
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraCoreControllers                                                              *
-*                                                                                          *
-*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
-{
-    hid_device* dev = hid_open_path(info->path);
-    if( dev )
-    {
-        AuraCoreController*     controller     = new AuraCoreController(dev, info->path);
-        RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
-        // Constructor sets the name
-        if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
-        {
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        else
-        {
-            delete rgb_controller;
-        }
-    }
-}
-
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
-REGISTER_HID_DETECTOR("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
@@ -1,329 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraCore.cpp           |
-|                                           |
-|  Generic RGB Interface for ROG Aura Core  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/17/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraCore.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus AURA Core
-    @type USB
-    @save :x:
-    @direct :warning:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraCoreControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura Core Device";
-    vendor      = "ASUS";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();    
-    description = "ASUS Aura Core Device";
-    type        = DEVICE_TYPE_UNKNOWN;
-
-    if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
-    {
-        SetupKeyboard();
-    }
-    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
-    {
-        SetupGA15DH();
-    }
-
-    SetupZones();
-}
-
-void RGBController_AuraCore::SetupKeyboard()
-{
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Core Device";
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_CORE_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_CORE_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name       = "Color Cycle";
-    ColorCycle.value      = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags      = 0;
-    ColorCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(ColorCycle);
-}
-
-void RGBController_AuraCore::SetupGA15DH()
-{
-    name        = "ASUS Aura GA15DH";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = "ASUS Aura Core Device";
-
-    mode Static;
-    Static.name             = "Static";
-    Static.value            = AURA_CORE_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min       = 1;
-    Static.colors_max       = 1;
-    Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = AURA_CORE_MODE_BREATHING;
-    Breathing.flags         = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
-    Breathing.speed_min     = AURA_CORE_SPEED_SLOW;
-    Breathing.speed_max     = AURA_CORE_SPEED_FAST;
-    Breathing.speed         = AURA_CORE_SPEED_NORMAL;
-    Breathing.colors_min    = 1;
-    Breathing.colors_max    = 2;
-    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(2);
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name         = "Color Cycle";
-    ColorCycle.value        = AURA_CORE_MODE_SPECTRUM_CYCLE;
-    ColorCycle.flags        = MODE_FLAG_HAS_SPEED;
-    ColorCycle.speed_min    = AURA_CORE_SPEED_SLOW;
-    ColorCycle.speed_max    = AURA_CORE_SPEED_FAST;
-    ColorCycle.speed        = AURA_CORE_SPEED_NORMAL;
-    ColorCycle.color_mode   = MODE_COLORS_NONE;
-    modes.push_back(ColorCycle);
-
-    mode Rainbow;
-    Rainbow.name            = "Rainbow";
-    Rainbow.value           = AURA_CORE_MODE_RAINBOW;
-    Rainbow.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Rainbow.speed_min       = AURA_CORE_SPEED_SLOW;
-    Rainbow.speed_max       = AURA_CORE_SPEED_FAST;
-    Rainbow.speed           = AURA_CORE_SPEED_NORMAL;
-    Rainbow.direction       = MODE_DIRECTION_RIGHT;
-    Rainbow.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode Strobe;
-    Strobe.name             = "Strobe";
-    Strobe.value            = AURA_CORE_MODE_STROBE;
-    Strobe.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Strobe.colors_min       = 1;
-    Strobe.colors_max       = 1;
-    Strobe.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    Strobe.colors.resize(1);
-    modes.push_back(Strobe);
-
-    mode Comet;
-    Comet.name              = "Comet";
-    Comet.value             = AURA_CORE_MODE_COMET;
-    Comet.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Comet.colors_min        = 1;
-    Comet.colors_max        = 1;
-    Comet.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Comet.colors.resize(1);
-    modes.push_back(Comet);
-
-    mode Flash;
-    Flash.name              = "Flash & Dash";
-    Flash.value             = AURA_CORE_MODE_FLASHNDASH;
-    Flash.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flash.colors_min        = 1;
-    Flash.colors_max        = 1;
-    Flash.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Flash.colors.resize(1);
-    modes.push_back(Flash);
-
-    mode Irradiation;
-    Irradiation.name        = "Irradiation";
-    Irradiation.value       = AURA_CORE_MODE_IRRADIATION;
-    Irradiation.flags       = 0;
-    Irradiation.color_mode  = MODE_COLORS_NONE;
-    modes.push_back(Irradiation);
-
-    mode Direct;
-    Static.name       = "Direct";
-    Static.value      = AURA_CORE_MODE_DIRECT;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-}
-
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    delete controller;
-}
-
-void RGBController_AuraCore::SetupZones()
-{
-    zone auraZone;
-
-    if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
-    {
-        auraZone.name       = "Keyboard";
-        auraZone.type       = ZONE_TYPE_SINGLE;
-        auraZone.leds_min   = 4;
-        auraZone.leds_max   = 4;
-        auraZone.leds_count = 4;
-        auraZone.matrix_map = NULL;
-    }
-    else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
-    {
-        auraZone.name       = "GA15DH";
-        auraZone.type       = ZONE_TYPE_LINEAR;
-        auraZone.leds_min   = 20;
-        auraZone.leds_max   = 20;
-        auraZone.leds_count = 20;
-        auraZone.matrix_map = NULL;
-    }
-    else
-    {
-        auraZone.leds_count = 0;
-    }
-
-    zones.push_back(auraZone);
-
-    for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
-    {
-        led KeyLED;
-        KeyLED.name = auraZone.name + " ";
-        KeyLED.name.append(std::to_string(led_idx + 1));
-        leds.push_back(KeyLED);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraCore::DeviceUpdateLEDs()
-{
-    UpdateZoneLEDs(0);
-}
-
-void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
-{
-    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
-    {
-        std::vector<AuraColor>  aura_colors;
-        std::vector<RGBColor>&  color_set = colors;
-
-        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-        {
-            color_set = modes[active_mode].colors;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            AuraColor new_color;
-
-            new_color.red   = RGBGetRValue(color_set[led_idx]);
-            new_color.green = RGBGetGValue(color_set[led_idx]);
-            new_color.blue  = RGBGetBValue(color_set[led_idx]);
-
-            aura_colors.push_back(new_color);
-        }
-
-        controller->UpdateDirect(aura_colors);
-    }
-    else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
-        {
-            UpdateSingleLED(led_idx);
-        }
-    }
-    else
-    {
-        UpdateSingleLED(0);
-    }
-}
-
-void RGBController_AuraCore::UpdateSingleLED(int led)
-{
-    unsigned char speed = 0xFF;
-    unsigned char red   = 0;
-    unsigned char green = 0;
-    unsigned char blue  = 0;
-    unsigned char dir   = 0;
-    mode& curr_mode     = modes[active_mode];
-
-    if(curr_mode.color_mode == MODE_COLORS_PER_LED)
-    {
-        red     = RGBGetRValue(colors[led]);
-        green   = RGBGetGValue(colors[led]);
-        blue    = RGBGetBValue(colors[led]);
-    }
-    else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red     = RGBGetRValue(curr_mode.colors[led]);
-        green   = RGBGetGValue(curr_mode.colors[led]);
-        blue    = RGBGetBValue(curr_mode.colors[led]);
-    }
-
-    if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
-    {
-        speed   = curr_mode.speed;
-    }
-
-    if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
-    {
-        if(curr_mode.direction == MODE_DIRECTION_RIGHT)
-        {
-            dir = 1;
-        }
-    }
-
-    controller->SendUpdate
-            (
-            led,
-            curr_mode.value,
-            speed,
-            dir,
-            red,
-            green,
-            blue
-            );
-
-    controller->SendSet();
-    controller->SendApply();
-}
-
-void RGBController_AuraCore::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraCore::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
-    {
-        controller->InitDirectMode();
-    }
-    else
-    {
-        DeviceUpdateLEDs();
-    }
-}
@@ -1,35 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraCore.h             |
-|                                           |
-|  Generic RGB Interface for ROG Aura Core  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 4/17/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusAuraCoreController.h"
-
-class RGBController_AuraCore : public RGBController
-{
-public:
-    RGBController_AuraCore(AuraCoreController* controller_ptr);
-    ~RGBController_AuraCore();
-
-    void        SetupKeyboard();
-    void        SetupGA15DH();
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraCoreController* controller;
-};
@@ -1,84 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUController.cpp                |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "AsusAuraGPUController.h"
-#include <cstring>
-
-AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "ASUS Aura GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
-}
-
-AuraGPUController::~AuraGPUController()
-{
-
-}
-
-std::string AuraGPUController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned char AuraGPUController::GetLEDRed()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_RED));
-}
-
-unsigned char AuraGPUController::GetLEDGreen()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_GREEN));
-}
-
-unsigned char AuraGPUController::GetLEDBlue()
-{
-    return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
-}
-
-void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-}
-
-void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
-    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
-    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
-void AuraGPUController::SetMode(unsigned char mode)
-{
-    AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
-    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
-}
-
-unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
-{
-    return(bus->i2c_smbus_read_byte_data(dev, reg));
-}
-
-void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
-{
-    bus->i2c_smbus_write_byte_data(dev, reg, val);
-}
@@ -1,64 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUController.h                  |
-|                                           |
-|  Definitions for ASUS Aura RGB on GPUs    |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char aura_gpu_dev_id;
-
-#define AURA_GPU_MAGIC_VAL 0x1589                   /* This magic value is present in all Aura GPU controllers */
-#define AURA_GPU_APPLY_VAL 0x01                     /* Value for Apply Changes Register     */
-
-enum
-{
-    AURA_GPU_REG_RED                        = 0x04,    /* AURA GPU RED Register            */
-    AURA_GPU_REG_GREEN                      = 0x05,    /* AURA GPU GREEN Register          */
-    AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
-    AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
-    AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
-    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
-};
-
-enum
-{
-    AURA_GPU_MODE_OFF                       = 0,        /* OFF mode (not a real Mode! Doesn't do anything!)    */
-    AURA_GPU_MODE_STATIC                    = 1,        /* Static color mode                                   */
-    AURA_GPU_MODE_BREATHING                 = 2,        /* Breathing effect mode                               */
-    AURA_GPU_MODE_FLASHING                  = 3,        /* Flashing effect mode                                */
-    AURA_GPU_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                                 */
-    AURA_GPU_MODE_DIRECT                    = 5,        /* Direct mode (not a real Mode! Doesn't do anything!) */
-    AURA_GPU_NUMBER_MODES
-};
-
-class AuraGPUController
-{
-public:
-    AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id);
-    ~AuraGPUController();
-
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned char GetLEDRed();
-    unsigned char GetLEDGreen();
-    unsigned char GetLEDBlue();
-    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
-    void          SetMode(unsigned char mode);
-
-    unsigned char AuraGPURegisterRead(unsigned char reg);
-    void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
-
-    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
-
-private:
-    char                    device_name[16];
-    i2c_smbus_interface *   bus;
-    aura_gpu_dev_id         dev;
-};
@@ -1,149 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraGPUControllerDetect.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB on GPUs         |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "Detector.h"
-#include "AsusAuraGPUController.h"
-#include "LogManager.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraGPU.h"
-#include "i2c_smbus.h"
-#include "pci_ids.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-using namespace std::chrono_literals;
-
-typedef struct
-{
-    int             pci_vendor;
-    int             pci_device;
-    int             pci_subsystem_vendor;
-    int             pci_subsystem_device;
-    unsigned char   controller_address;
-    const char *    name;
-} gpu_pci_device;
-
-#define ASUSGPU_CONTROLLER_NAME "ASUS Aura GPU"
-#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
-
-static const gpu_pci_device device_list[] =
-{
-    { NVIDIA_VEN,       NVIDIA_GTX1050_DEV,         ASUS_SUB_VEN,       ASUS_GTX1050_STRIX_O2G_GAMING,              0x29,   "ASUS ROG Strix GTX 1050 O2G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING,        0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1050TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2,      0x29,   "ASUS ROG Strix GTX 1050 TI O4G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX_6G_GAMING,               0x29,   "ASUS GTX 1060 Strix 6G Gaming"             },
-    { NVIDIA_VEN,       NVIDIA_GTX1060_DEV,         ASUS_SUB_VEN,       ASUS_GTX1060_STRIX,                         0x29,   "ASUS GTX 1060 Strix"                       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_GAMING,                  0x29,   "ASUS GTX 1070 Strix Gaming"                },
-    { NVIDIA_VEN,       NVIDIA_GTX1070_DEV,         ASUS_SUB_VEN,       ASUS_GTX1070_STRIX_OC,                      0x29,   "ASUS GTX 1070 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_8G_GAMING,         0x29,   "ASUS ROG Strix GTX1070 Ti 8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_GTX1070TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1070TI_A8G_GAMING,        0x29,   "ASUS ROG Strix GTX1070 Ti A8G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_GTX1080_STRIX,                         0x29,   "ASUS GTX 1080 Strix OC"                    },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_A8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 A8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080_DEV,         ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080_O8G_GAMING,          0x29,   "ASUS ROG Strix GTX1080 O8G Gaming"         },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_GAMING,            0x29,   "ASUS ROG Strix GTX1080 Ti Gaming"          },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_11G_GAMING,        0x29,   "ASUS ROG Strix GTX1080 Ti 11G Gaming"      },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING,       0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1080TI_O11G_GAMING_A02,   0x29,   "ASUS ROG Strix GTX1080 Ti O11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_GTX1650S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1650S_OC,                 0x2A,   "ASUS ROG Strix GTX 1650S OC 4G"            },
-    { NVIDIA_VEN,       NVIDIA_GTX1660S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_GTX1660S_O6G_GAMING,         0x2A,   "ASUS ROG Strix GTX 1660S O6G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_GTX1660TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_GTX1660TI_OC,                      0x2A,   "ASUS ROG GTX 1660 Ti OC 6G"                },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_EVO_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 EVO Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU106_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060 O6G Gaming 6G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060_TU104_DEV,   ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING,      0x2A,   "ASUS ROG STRIX RTX 2060 O6G EVO Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2060S 8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING,     0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2060S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2060S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_A8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 A8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070_OC_DEV,      ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2070 O8G Gaming 8G"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706,    0x2A,   "ASUS ROG STRIX RTX 2070S A8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729,    0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707,     0x2A,   "ASUS ROG STRIX RTX 2070S 8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2070S_OC_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2070S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2070S O8G Gaming 8G"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080_A_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080_O8G_GAMING,          0x2A,   "ASUS ROG STRIX RTX 2080 O8G Gaming"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_A8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S A8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_GAMING,         0x2A,   "ASUS ROG STRIX RTX 2080S O8G Gaming"       },
-    { NVIDIA_VEN,       NVIDIA_RTX2080S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080S_O8G_WHITE,          0x2A,   "ASUS ROG STRIX RTX 2080S O8G White"        },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_DEV,       ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_11G_GAMING,        0x2A,   "ASUS ROG STRIX RTX 2080 Ti 11G Gaming"     },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti O11G Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX2080TI_A_DEV,     ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING,       0x2A,   "ASUS ROG STRIX RTX 2080 Ti A11G Gaming"    },
-    { NVIDIA_VEN,       NVIDIA_RTX3060TI_LHR_DEV,   ASUS_SUB_VEN,       ASUS_TUF_RTX_3060_TI_O8G_OC,                0x2A,   "ASUS TUF RTX 3060 Ti 8G Gaming OC"         },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_AREZ_STRIX_VEGA56_08G_GAMING,          0x29,   "ASUS AREZ Strix RX Vega 56 O8G"            },
-    { AMD_GPU_VEN,      AMD_VEGA10_DEV,             ASUS_SUB_VEN,       ASUS_VEGA64_STRIX,                          0x29,   "ASUS Vega 64 Strix"                        },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5600XT_STRIX_O6G_GAMING,             0x2A,   "ASUS RX 5600XT Strix O6G Gaming"           },
-    { AMD_GPU_VEN,      AMD_NAVI10_DEV,             ASUS_SUB_VEN,       ASUS_RX5700XT_STRIX_GAMING_OC,              0x2A,   "ASUS RX 5700XT Strix Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX480_STRIX_GAMING_OC,                 0x29,   "ASUS ROG STRIX RX480 Gaming OC"            },
-    { AMD_GPU_VEN,      AMD_POLARIS11,              ASUS_SUB_VEN,       ASUS_RX560_STRIX_4G_GAMING,                 0x29,   "ASUS ROG STRIX RX560 Gaming"               },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX570_STRIX_O4G_GAMING_OC,             0x29,   "ASUS RX 570 Strix O4G Gaming OC"           },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_OC,                 0x29,   "ASUS RX 580 Strix Gaming OC"               },
-    { AMD_GPU_VEN,      AMD_POLARIS_DEV,            ASUS_SUB_VEN,       ASUS_RX580_STRIX_GAMING_TOP,                0x29,   "ASUS RX 580 Strix Gaming TOP"              },
-};  
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraGPUController                                                               *
-*                                                                                          *
-*       Tests the given address to see if an Aura GPU controller exists there.             *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
-    unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
-
-    LOG_DEBUG("[%s] Test GPU expect: 0x1589 received: 0x%02X%02X", ASUSGPU_CONTROLLER_NAME, aura_gpu_magic_high, aura_gpu_magic_low);
-
-    if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL)
-    {
-        pass = true;
-    }
-
-    return(pass);
-
-}   /* TestForAuraGPUController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraGPUControllers                                                               *
-*                                                                                          *
-*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
-{
-    for(unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
-        {
-            if(busses[bus]->pci_vendor           == device_list[dev_idx].pci_vendor           &&
-               busses[bus]->pci_device           == device_list[dev_idx].pci_device           &&
-               busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
-               busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
-            {
-                LOG_DEBUG(GPU_DETECT_MESSAGE, ASUSGPU_CONTROLLER_NAME, bus, device_list[dev_idx].pci_device, device_list[dev_idx].pci_subsystem_device, device_list[dev_idx].name );
-                
-                if(TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
-                {
-                    AuraGPUController*     controller     = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
-                    RGBController_AuraGPU* rgb_controller = new RGBController_AuraGPU(controller);
-                    rgb_controller->name = device_list[dev_idx].name;
-                    ResourceManager::get()->RegisterRGBController(rgb_controller);
-                }
-            }
-        }
-    }
-} /* DetectAsusAuraGPUControllers() */
-
-REGISTER_I2C_DETECTOR(ASUSGPU_CONTROLLER_NAME, DetectAsusAuraGPUControllers);
@@ -1,211 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraGPU.h"
-
-int RGBController_AuraGPU::GetDeviceMode()
-{
-    int dev_mode = controller->AuraGPURegisterRead(AURA_GPU_REG_MODE);
-    int color_mode = MODE_COLORS_PER_LED;
-
-    if(dev_mode == AURA_GPU_MODE_STATIC)
-    {
-        if (controller->direct)
-        {
-            dev_mode = AURA_GPU_MODE_DIRECT;
-        } 
-    }
-
-    switch(dev_mode)
-    {
-    case AURA_GPU_MODE_OFF:
-    case AURA_GPU_MODE_SPECTRUM_CYCLE:
-        color_mode = MODE_COLORS_NONE;
-        break;
-    }
-
-    for(std::size_t mode = 0; mode < modes.size(); mode++)
-    {
-        if(modes[mode].value == dev_mode)
-        {
-            active_mode            = mode;
-            modes[mode].color_mode = color_mode;
-        }   
-    }
-
-    return(active_mode);
-}
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura GPU
-    @type SMBus
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark::
-    @detectors DetectAsusAuraGPUControllers
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetDeviceName();
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_GPU;
-    description = "ASUS Aura GPU Device";
-    location    = controller->GetDeviceLocation();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_GPU_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_GPU_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_GPU_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_GPU_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Breathing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_GPU_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Flashing.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Flashing);
-
-    mode Spectrum_Cycle;
-    Spectrum_Cycle.name       = "Spectrum Cycle";
-    Spectrum_Cycle.value      = AURA_GPU_MODE_SPECTRUM_CYCLE;
-    Spectrum_Cycle.flags      = 0;
-    Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Spectrum_Cycle);
-
-    SetupZones();
-
-    active_mode = GetDeviceMode();
-}
-
-RGBController_AuraGPU::~RGBController_AuraGPU()
-{
-    delete controller;
-}
-
-void RGBController_AuraGPU::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zone                                               |
-    \*---------------------------------------------------------*/
-    zone aura_gpu_zone;
-    aura_gpu_zone.name          = "GPU";
-    aura_gpu_zone.type          = ZONE_TYPE_SINGLE;
-    aura_gpu_zone.leds_min      = 1;
-    aura_gpu_zone.leds_max      = 1;
-    aura_gpu_zone.leds_count    = 1;
-    aura_gpu_zone.matrix_map    = NULL;
-    zones.push_back(aura_gpu_zone);
-
-    /*---------------------------------------------------------*\
-    | Set up LED                                                |
-    \*---------------------------------------------------------*/
-    led aura_gpu_led;
-    aura_gpu_led.name           = "GPU";
-    leds.push_back(aura_gpu_led);
-
-    SetupColors();
-
-    /*---------------------------------------------------------*\
-    | Initialize color                                          |
-    \*---------------------------------------------------------*/
-    unsigned char red = controller->GetLEDRed();
-    unsigned char grn = controller->GetLEDGreen();
-    unsigned char blu = controller->GetLEDBlue();
-
-    colors[0] =  ToRGBColor(red, grn, blu);
-}
-
-void RGBController_AuraGPU::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraGPU::DeviceUpdateLEDs()
-{
-    for(std::size_t led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        if (GetMode() == 0)
-        {
-            controller->SetLEDColorsDirect(red, grn, blu);
-        }
-        else 
-        {
-            controller->SetLEDColorsEffect(red, grn, blu);
-        }
-    }
-}
-
-void RGBController_AuraGPU::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraGPU::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraGPU::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraGPU::DeviceUpdateMode()
-{
-    int new_mode       = modes[active_mode].value;
-    controller->direct = false;
-    
-    switch(new_mode)
-    {
-        // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
-        case AURA_GPU_MODE_OFF:
-            controller->SetLEDColorsEffect(0, 0, 0);
-            new_mode           = AURA_GPU_MODE_STATIC;
-            break;
-        
-        // Direct mode is done by switching to Static and not applying color changes
-        case AURA_GPU_MODE_DIRECT:
-            controller->direct = true;
-            new_mode           = AURA_GPU_MODE_STATIC;
-            break;
-    }
-
-    controller->SetMode(new_mode);
-}
@@ -1,35 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraGPU.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura GPU  |
-|                                           |
-|  Jan Rettig (Klapstuhl) 14.02.2020        |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include "RGBController.h"
-#include "AsusAuraGPUController.h"
-
-class RGBController_AuraGPU : public RGBController
-{
-public:
-    RGBController_AuraGPU(AuraGPUController* controller_ptr);
-    ~RGBController_AuraGPU();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraGPUController* controller;
-
-    int        GetDeviceMode();
-};
@@ -1,144 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB Addressable     |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "AsusAuraAddressableController.h"
-#include <cstring>
-
-AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
-{
-    /*-----------------------------------------------------*\
-    | Add addressable devices                               |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < config_table[0x02]; ++i)
-    {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
-    }
-}
-
-AuraAddressableController::~AuraAddressableController()
-{
-
-}
-
-void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
-{
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            channel,
-            leds_sent,
-            leds_to_send,
-            led_data
-        );
-
-        leds_sent += leds_to_send;
-    }
-
-    SendDirectApply(channel);
-}
-
-void AuraAddressableController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    SendEffect
-    (
-        channel,
-        mode,
-        red,
-        grn,
-        blu
-    );
-}
-
-void AuraAddressableController::SendEffect
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_ADDRESSABLE_CONTROL_MODE_EFFECT;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x05]   = red;
-    usb_buf[0x06]   = grn;
-    usb_buf[0x07]   = blu;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraAddressableController::SendDirectApply
-    (
-    unsigned char   channel
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = 0x80 | channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
@@ -1,60 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraAddressableController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  Addressable RGB lighting controller      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_ADDRESSABLE_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
-};
-
-class AuraAddressableController : public AuraUSBController
-{
-public:
-    AuraAddressableController(hid_device* dev_handle, const char* path);
-    ~AuraAddressableController();
-
-    void SetChannelLEDs
-        (
-        unsigned char   channel,
-        RGBColor *      colors,
-        unsigned int    num_colors
-        );
-
-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-private:
-
-    void SendEffect
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-    void    SendDirectApply
-        (
-        unsigned char   channel
-        );
-};
@@ -1,152 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraHeadsetStandController.cpp       |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraHeadsetStandController.h"
-
-#include <cstring>
-
-AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AuraHeadsetStandController::~AuraHeadsetStandController()
-{
-    hid_close(dev);
-}
-
-std::string AuraHeadsetStandController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraHeadsetStandController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-std::string AuraHeadsetStandController::GetVersion()
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x00;
-
-    hid_write(dev, usb_buf, 65);
-
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-
-    char version[5];
-    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
-    return std::string(version);
-}
-
-void AuraHeadsetStandController::UpdateLeds
-    (
-    std::vector<RGBColor>    colors
-    )
-{
-    unsigned char usb_buf_0[365];
-
-    memset(usb_buf_0, 0x00, sizeof(usb_buf_0));
-
-    usb_buf_0[0x00]   = 0x00;
-    usb_buf_0[0x01]   = 0xC0;
-    usb_buf_0[0x02]   = 0x81;
-    usb_buf_0[0x03]   = 0x00;
-    usb_buf_0[0x04]   = 0x00;
-
-    for(unsigned int i = 0; i < 60; i += 4)
-    {
-        usb_buf_0[5 + i]   = 0x00;
-        usb_buf_0[6 + i]   = RGBGetRValue(colors[i / 4]);
-        usb_buf_0[7 + i]   = RGBGetGValue(colors[i / 4]);
-        usb_buf_0[8 + i]   = RGBGetBValue(colors[i / 4]);
-    }
-
-    hid_write(dev, usb_buf_0, 65);
-
-    unsigned char usb_buf_1[65];
-
-    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
-
-    usb_buf_1[0x00]   = 0x00;
-    usb_buf_1[0x01]   = 0xC0;
-    usb_buf_1[0x02]   = 0x81;
-    usb_buf_1[0x03]   = 0x01;
-    usb_buf_1[0x04]   = 0x00;
-
-    for(unsigned int i = 0; i < 12; i += 4)
-    {
-        usb_buf_1[5 + i]   = 0x00;
-        usb_buf_1[6 + i]   = RGBGetRValue(colors[(i / 4) + 15]);
-        usb_buf_1[7 + i]   = RGBGetGValue(colors[(i / 4) + 15]);
-        usb_buf_1[8 + i]   = RGBGetBValue(colors[(i / 4) + 15]);
-    }
-
-    hid_write(dev, usb_buf_1, 65);
-}
-
-void AuraHeadsetStandController::UpdateDevice
-    (
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu,
-    unsigned char   speed,
-    unsigned char   brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-    usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = brightness;
-    usb_buf[0x08]   = 0x00;
-    usb_buf[0x09]   = 0x00;
-    usb_buf[0x0a]   = red;
-    usb_buf[0x0b]   = grn;
-    usb_buf[0x0c]   = blu;
-    hid_write(dev, usb_buf, 65);
-
-}
-
-void AuraHeadsetStandController::SaveMode()
-{
-    unsigned char usb_save_buf[65];
-
-    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-
-    usb_save_buf[0x00]   = 0x00;
-    usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x55;
-
-    hid_write(dev, usb_save_buf, 65);
-}
@@ -1,62 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraHeadsetStandController.h         |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_HEADSET_STAND_ZONE_UNDERGLOW   = 0,
-    AURA_HEADSET_STAND_ZONE_LOGO        = 1
-};
-
-enum
-{
-    AURA_HEADSET_STAND_MODE_DIRECT      = 0,
-    AURA_HEADSET_STAND_MODE_STATIC      = 1,
-    AURA_HEADSET_STAND_MODE_BREATHING   = 2,
-    AURA_HEADSET_STAND_MODE_STROBING    = 3,
-    AURA_HEADSET_STAND_MODE_COLOR_CYCLE = 4,
-    AURA_HEADSET_STAND_MODE_RAINBOW     = 5
-};
-
-class AuraHeadsetStandController
-{
-public:
-    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
-    virtual ~AuraHeadsetStandController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void UpdateLeds
-        (
-        std::vector<RGBColor>    colors
-        );
-
-    void UpdateDevice
-        (
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        unsigned char   speed,
-        unsigned char   brightness
-        );
-
-    void SaveMode();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,115 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraKeyboardController.cpp           |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/19/2020   |
-\*-----------------------------------------*/
-
-#include "AsusAuraKeyboardController.h"
-
-#include <cstring>
-
-AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AuraKeyboardController::~AuraKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AuraKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-void AuraKeyboardController::SendDirect
-    (
-    unsigned char       frame_count,
-    unsigned char *     frame_data
-    )
-{
-    unsigned char usb_buf[65];
-    unsigned int  packet_count = frame_count / 15 + (((frame_count % 15) == 0) ? 0 : 1);
-    unsigned int  total_frame_idx = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0xC0;
-    usb_buf[0x02]   = 0x81;
-    usb_buf[0x03]   = packet_count * 15;
-    usb_buf[0x04]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Copy in frame data and send packets until all data    |
-    | has been sent                                         |
-    \*-----------------------------------------------------*/
-    for(unsigned int packet_idx = 0; packet_idx < packet_count; packet_idx++)
-    {
-        unsigned int packet_data_size = 15 * 4;
-
-        if((frame_count - total_frame_idx) < 15)
-        {
-            packet_data_size = (frame_count - total_frame_idx) * 4;
-            memset(&usb_buf[0x05 + packet_data_size], 0xFF, (15*4) - packet_data_size);
-        }
-
-        memcpy(&usb_buf[0x05], &frame_data[packet_idx * 15 * 4], packet_data_size);
-
-        /*-----------------------------------------------------*\
-        | Send packet                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 65);
-
-        /*-----------------------------------------------------*\
-        | Decrement remaining frame count                       |
-        \*-----------------------------------------------------*/
-        usb_buf[0x03] -= 0x0F;
-        total_frame_idx += 0x0F;
-    }
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0xC0;
-    usb_buf[0x02]   = 0x81;
-    usb_buf[0x03]   = 0x90;
-
-    /*-----------------------------------------------------*\
-    | Read to apply                                         |
-    \*-----------------------------------------------------*/
-    hid_read(dev,usb_buf, 65);
-}
@@ -1,36 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraKeyboardController.h             |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/19/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-class AuraKeyboardController
-{
-public:
-    AuraKeyboardController(hid_device* dev_handle, const char* path);
-    virtual ~AuraKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void SendDirect
-        (
-        unsigned char       frame_count,
-        unsigned char *     frame_data
-        );
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,208 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.cpp          |
-|                                           |
-|  Driver for ASUS Aura RGB USB mainboard   |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AsusAuraMainboardController.h"
-#include <cstring>
-
-AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
-{
-    unsigned char num_total_mainboard_leds  = config_table[0x1B];
-    unsigned char num_rgb_headers           = config_table[0x1D];
-    unsigned char num_addressable_headers   = config_table[0x02];
-
-    if(num_total_mainboard_leds < num_rgb_headers)
-    {
-        num_rgb_headers = 0;
-    }
-
-    /*-----------------------------------------------------*\
-    | Add mainboard device                                  |
-    \*-----------------------------------------------------*/
-    device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
-
-    /*-----------------------------------------------------*\
-    | Add addressable devices                               |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < num_addressable_headers; i++)
-    {
-        device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
-    }
-}
-
-AuraMainboardController::~AuraMainboardController()
-{
-}
-
-void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
-{
-    unsigned char   led_data[60];
-    unsigned int    leds_sent = 0;
-
-    while(leds_sent < num_colors)
-    {
-        unsigned int leds_to_send = 20;
-
-        if((num_colors - leds_sent) < leds_to_send)
-        {
-            leds_to_send = num_colors - leds_sent;
-        }
-
-        for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++)
-        {
-            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
-            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
-        }
-
-        SendDirect
-        (
-            device_info[channel].direct_channel,
-            leds_sent,
-            leds_to_send,
-            led_data,
-            leds_sent + leds_to_send >= num_colors
-        );
-
-        leds_sent += leds_to_send;
-    }
-}
-
-void AuraMainboardController::SetMode
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu
-    )
-{
-    this->mode = mode;
-    RGBColor color = ToRGBColor(red, grn, blu);
-
-    SendEffect(device_info[channel].effect_channel, mode);
-    if(mode == AURA_MODE_DIRECT)
-    {
-        return;
-    }
-
-    unsigned char   led_data[60];
-    unsigned char   start_led = 0;
-
-    for(std::size_t i = 0; i < channel; ++i)
-    {
-        start_led += device_info[i].num_leds;
-    }
-
-    for(std::size_t led_idx = 0; led_idx < device_info[channel].num_leds; led_idx++)
-    {
-        led_data[(led_idx * 3) + 0] = RGBGetRValue(color);
-        led_data[(led_idx * 3) + 1] = RGBGetGValue(color);
-        led_data[(led_idx * 3) + 2] = RGBGetBValue(color);
-    }
-
-    SendColor
-    (
-        channel,
-        start_led,
-        device_info[channel].num_leds,
-        led_data
-    );
-}
-
-unsigned short AuraMainboardController::GetMask(int start, int size)
-{
-    return(((1 << size) - 1) << start);
-}
-
-void AuraMainboardController::SendEffect
-    (
-    unsigned char   channel,
-    unsigned char   mode
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
-    usb_buf[0x02]   = channel;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMainboardController::SendColor
-    (
-    unsigned char   /*channel*/,
-    unsigned char   start_led,
-    unsigned char   led_count,
-    unsigned char*  led_data
-    )
-{
-    unsigned short  mask = GetMask(start_led, led_count);
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
-    usb_buf[0x02]   = mask >> 8;
-    usb_buf[0x03]   = mask & 0xff;
-    usb_buf[0x04]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05 + 3 * start_led], led_data, led_count * 3);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMainboardController::SendCommit()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_COMMIT;
-    usb_buf[0x02]   = 0x55;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
@@ -1,67 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMainboardController.h            |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB Mainboard RGB lighting controller    |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_MAINBOARD_CONTROL_MODE_EFFECT            = 0x35,     /* Effect control mode                  */
-    AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR      = 0x36,     /* Effect color control mode            */
-    AURA_MAINBOARD_CONTROL_MODE_COMMIT            = 0x3F,     /* Commit mode                          */
-};
-
-class AuraMainboardController : public AuraUSBController
-{
-public:
-    AuraMainboardController(hid_device* dev_handle, const char* path);
-    ~AuraMainboardController();
-
-    void SetChannelLEDs
-        (
-        unsigned char   channel,
-        RGBColor *      colors,
-        unsigned int    num_colors
-        );
-
-    void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        );
-
-private:
-    unsigned int mode;
-
-    unsigned short GetMask(int start, int size);
-    
-    void SendEffect
-        (
-        unsigned char   channel,
-        unsigned char   mode
-        );
-
-    void SendColor
-        (
-        unsigned char   channel,
-        unsigned char   start_led,
-        unsigned char   led_count,
-        unsigned char*  led_data
-        );
-
-    void SendCommit();
-};
@@ -1,94 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMonitorController.cpp            |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 08/03/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraMonitorController.h"
-
-#include <cstring>
-#include "LogManager.h"
-
-AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AuraMonitorController::~AuraMonitorController()
-{
-    hid_close(dev);
-}
-
-std::string AuraMonitorController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraMonitorController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-void AuraMonitorController::UpdateLed
-    (
-    int             led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    unsigned char usb_buf[8];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x03;
-    usb_buf[0x01]   = 0x02;
-    usb_buf[0x02]   = 0xa1;
-    usb_buf[0x03]   = 0x80;
-
-    usb_buf[0x04]   = 16 + led * 3;
-    usb_buf[0x05]   = red;
-    
-    hid_send_feature_report(dev, usb_buf, 8);
-
-    usb_buf[0x04]   = 16 + led * 3 + 1;
-    usb_buf[0x05]   = blue;
-    
-    hid_send_feature_report(dev, usb_buf, 8);
-
-    usb_buf[0x04]   = 16 + led * 3 + 2;
-    usb_buf[0x05]   = green;
-    
-    hid_send_feature_report(dev, usb_buf, 8);
-}
-
-void AuraMonitorController::ApplyChanges()
-{
-    unsigned char usb_buf[8];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x03;
-    usb_buf[0x01]   = 0x02;
-    usb_buf[0x02]   = 0xa1;
-    usb_buf[0x03]   = 0x80;
-    usb_buf[0x04]   = 0xa0;
-    usb_buf[0x05]   = 0x01;
-    
-    hid_send_feature_report(dev, usb_buf, 8);
-}
@@ -1,31 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMonitorController.h              |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 08/03/2023                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-class AuraMonitorController
-{
-public:
-    AuraMonitorController(hid_device* dev_handle, const char* path);
-    virtual ~AuraMonitorController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-
-    void UpdateLed(int led, unsigned char red, unsigned char green, unsigned char blue);
-    void ApplyChanges();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,184 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMouseController.cpp              |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/23/2020  |
-\*-----------------------------------------*/
-
-#include "AsusAuraMouseController.h"
-
-#include <cstring>
-
-AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AuraMouseController::~AuraMouseController()
-{
-    hid_close(dev);
-}
-
-std::string AuraMouseController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraMouseController::GetSerialString()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AuraMouseController::GetVersion(bool wireless, int protocol)
-{
-    unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
-
-    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
-    hid_read(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE);
-
-    std::string str;
-
-    switch(protocol)
-    {
-        case 0:
-            {
-                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
-                str = std::string(offset, offset + 4);
-            }
-            break;
-
-        case 1:
-            {
-                char version[9];
-                int offset = (wireless ? 13 : 4);
-                snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
-                str = std::string(version);
-            }
-            break;
-
-        case 2:
-            {
-                unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
-                str = std::string(offset, offset + 4);
-                str = "0." + str.substr(0, 2) + "." + str.substr(2, 2);
-            }
-            break;
-
-        case 3:
-            {
-                char version[9];
-                int offset = (wireless ? 13 : 4);
-                snprintf(version, 9, "%2d.%02d.%02d", usb_buf_out[offset + 1], usb_buf_out[offset + 2], usb_buf_out[offset + 3]);
-                str = std::string(version);
-            }
-            break;
-    }
-
-    return str;
-}
-
-void AuraMouseController::SaveMode()
-{
-    unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };
-
-    hid_write(dev, usb_save_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
-}
-
-void AuraMouseController::SendUpdate
-    (
-    unsigned char   zone,
-    unsigned char   mode,
-    unsigned char   red,
-    unsigned char   grn,
-    unsigned char   blu,
-    unsigned char   dir,
-    bool            random,
-    unsigned char   speed,
-    unsigned char   brightness
-    )
-{
-    int bytes_read = 1;
-    unsigned char usb_buf_flush[ASUS_AURA_MOUSE_PACKET_SIZE];
-
-    while(bytes_read > 0)
-    {
-      bytes_read = hid_read_timeout(dev, usb_buf_flush, ASUS_AURA_MOUSE_PACKET_SIZE, 0);
-    }
-
-    unsigned char usb_buf[ASUS_AURA_MOUSE_PACKET_SIZE];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, ASUS_AURA_MOUSE_PACKET_SIZE);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    
-    if (device_pid == AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID)
-    {
-        // this device supports 2 color for breathing,
-        // but since this mode is per led and openrgb doesn't support 2 colors per led this feature is not implemented
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x51;
-        usb_buf[0x02]   = 0x28;
-        usb_buf[0x03]   = zone;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = mode;
-        usb_buf[0x06]   = brightness;
-        usb_buf[0x07]   = 0x00; // boolean signaling if the 2nd set of colors is in use
-        usb_buf[0x08]   = red;
-        usb_buf[0x09]   = grn;
-        usb_buf[0x0A]   = blu;
-        usb_buf[0x0B]   = 0; // 2nd red
-        usb_buf[0x0C]   = 0; // 2nd green
-        usb_buf[0x0D]   = 0; // 2nd blue
-        usb_buf[0x0E]   = dir;
-        usb_buf[0x0F]   = random;
-        usb_buf[0x10]   = speed;
-    }
-    else
-    {
-        usb_buf[0x00]   = 0x00;
-        usb_buf[0x01]   = 0x51;
-        usb_buf[0x02]   = 0x28;
-        usb_buf[0x03]   = zone;
-        usb_buf[0x04]   = 0x00;
-        usb_buf[0x05]   = mode;
-        usb_buf[0x06]   = brightness;
-        usb_buf[0x07]   = red;
-        usb_buf[0x08]   = grn;
-        usb_buf[0x09]   = blu;
-        usb_buf[0x0A]   = dir;
-        usb_buf[0x0B]   = random;
-        usb_buf[0x0C]   = speed;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, ASUS_AURA_MOUSE_PACKET_SIZE);
-
-    unsigned char usb_buf_out[ASUS_AURA_MOUSE_PACKET_SIZE];
-    hid_read_timeout(dev, usb_buf_out, ASUS_AURA_MOUSE_PACKET_SIZE, 10);
-}
@@ -1,50 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMouseController.h                |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/23/2020  |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraMouseDevices.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-#define ASUS_AURA_MOUSE_PACKET_SIZE 65
-#define HID_MAX_STR 255
-
-class AuraMouseController
-{
-public:
-    AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
-    virtual ~AuraMouseController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion(bool wireless, int protocol);
-
-    void SaveMode();
-    void SendUpdate
-        (
-        unsigned char   zone,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu,
-        unsigned char   dir,
-        bool            random,
-        unsigned char   speed,
-        unsigned char   brightness
-        );
-
-    uint16_t                    device_pid;
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,307 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  AsusAuraMouseDevices.h                                             |
-|                                                                     |
-|  Asus Aura Mouse definitions and mapping                            |
-|                                                                     |
-|  Chris M (Dr_No)         11th July 2021                             |
-\*-------------------------------------------------------------------*/
-
-#include <vector>
-#include <map>
-
-#pragma once
-
-#define AURA_ROG_GLADIUS_II_CORE_PID            0x18DD
-#define AURA_ROG_GLADIUS_II_PID                 0x1845
-#define AURA_ROG_GLADIUS_II_ORIGIN_PID          0x1877
-#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID  0x18CD
-#define AURA_ROG_GLADIUS_II_ORIGIN_COD_PID      0x18B1
-#define AURA_ROG_GLADIUS_II_WIRELESS_1_PID      0x189E
-#define AURA_ROG_GLADIUS_II_WIRELESS_2_PID      0x18A0
-#define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
-#define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
-#define AURA_ROG_CHAKRAM_CORE_PID               0x1958
-#define AURA_ROG_PUGIO_PID                      0x1846
-#define AURA_ROG_PUGIO_II_WIRED_PID             0x1906
-#define AURA_ROG_PUGIO_II_WIRELESS_PID          0x1908
-#define AURA_ROG_STRIX_IMPACT_PID               0x1847
-#define AURA_ROG_STRIX_IMPACT_II_PID            0x18E1
-#define AURA_ROG_KERIS                          0x195C
-#define AURA_ROG_KERIS_WIRELESS_USB_PID         0x195E
-#define AURA_ROG_KERIS_WIRELESS_2_4_PID         0x1960
-#define AURA_ROG_KERIS_WIRELESS_BT_PID          0x1962
-#define AURA_TUF_M3_PID                         0x1910
-#define AURA_TUF_M5_PID                         0x1898
-
-enum
-{
-    AURA_MOUSE_ZONE_LOGO        = 0,
-    AURA_MOUSE_ZONE_SCROLL      = 1,
-    AURA_MOUSE_ZONE_UNDERGLOW   = 2,
-    AURA_MOUSE_ZONE_ALL         = 3,
-};
-
-enum
-{
-    AURA_MOUSE_MODE_STATIC      = 0,
-    AURA_MOUSE_MODE_BREATHING   = 1,
-    AURA_MOUSE_MODE_SPECTRUM    = 2,
-    AURA_MOUSE_MODE_WAVE        = 3,
-    AURA_MOUSE_MODE_REACTIVE    = 4,
-    AURA_MOUSE_MODE_COMET       = 5,
-    AURA_MOUSE_MODE_BATTERY     = 6,
-    AURA_MOUSE_MODE_NONE        = 255,
-};
-
-typedef struct
-{
-    uint8_t                 speed_min;
-    uint8_t                 speed_max;
-    bool                    wireless;
-    int                     version_protocol;
-    std::vector<uint8_t>    mouse_zones;
-    std::vector<uint8_t>    mouse_modes;
-} mouse_type;
-
-/*-----------------------------------------------------------------*\
-|  DEVICE MAP                                                       |
-|                                                                   |
-|    This structure maps the OpenRGB modes to the mode values       |
-|    sent to each mouse. As not all modes are present on each       |
-|    mouse the "mode index" is different. Eg. "Reactive" is mode    |
-|    4 on the Gladius II and mode 3 on the Gladius II wireless      |
-\*-----------------------------------------------------------------*/
-static std::map<int,mouse_type> aura_mouse_devices =
-{
-    {
-        AURA_ROG_GLADIUS_II_CORE_PID, // ROG Gladius II Core
-        {
-            0,    //Speed Min - The Asus Mouse protocol defines larger numbers as slow
-            0,    //Speed Max
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_PID, // ROG Gladius II
-        {
-            255,
-            1,
-            false,
-            0,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_ORIGIN_PID, // ROG Gladius II Origin
-        {
-            255,
-            1,
-            false,
-            0,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_ORIGIN_COD_PID, // ROG Gladius II COD
-        {
-            255,
-            1,
-            false,
-            0,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, // ROG Gladius II PNK LTD
-        {
-            255,
-            1,
-            false,
-            0,
-            { AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_WIRELESS_1_PID, // ROG Gladius II Wireless
-        {
-            0,
-            0,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_GLADIUS_II_WIRELESS_2_PID, // ROG Gladius II Wireless
-        {
-            0,
-            0,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_WIRELESS_PID, // ROG Chakram Wireless
-        {
-            15,
-            1,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_WIRED_1_PID,  // ROG Chakram Wired 1
-        {
-            15,
-            1,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_CHAKRAM_CORE_PID, // ROG Chakram Core
-        {
-            0,
-            0,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-    {
-        AURA_ROG_PUGIO_PID, // ROG Pugio
-        {
-            255,
-            1,
-            false,
-            0,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET }
-        }
-    },
-    {
-        AURA_ROG_PUGIO_II_WIRED_PID, // ROG Pugio II Wired
-        {
-            15,
-            1,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_PUGIO_II_WIRELESS_PID, // ROG Pugio II Wireless
-        {
-            15,
-            1,
-            true,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_STRIX_IMPACT_PID, // ROG Strix Impact
-        {
-            0,
-            0,
-            false,
-            3,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
-        }
-    },
-    {
-        AURA_ROG_STRIX_IMPACT_II_PID, // ROG Strix Impact II
-        {
-            0,
-            0,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-    {
-        AURA_ROG_KERIS, // ROG Keris
-        {
-            0,
-            0,
-            false,
-            1, // might be the wrong protocol for version
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_USB_PID, // ROG Keris
-        {
-            0,
-            0,
-            true,
-            1, // might be the wrong protocol for version
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_2_4_PID, // ROG Keris
-        {
-            0,
-            0,
-            true,
-            1, // might be the wrong protocol for version
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_ROG_KERIS_WIRELESS_BT_PID, // ROG Keris
-        {
-            0,
-            0,
-            true,
-            1, // might be the wrong protocol for version
-            { AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
-        }
-    },
-    {
-        AURA_TUF_M3_PID, // TUF M3
-        {
-            0,
-            0,
-            false,
-            1,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-    {
-        AURA_TUF_M5_PID, // TUF M5
-        {
-            0,
-            0,
-            false,
-            2,
-            { AURA_MOUSE_ZONE_LOGO },
-            { AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
-        }
-    },
-};
@@ -1,134 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMousematController.cpp           |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
-
-#include "AsusAuraMousematController.h"
-#include <cstring>
-
-AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-}
-
-AuraMousematController::~AuraMousematController()
-{
-    hid_close(dev);
-}
-
-std::string AuraMousematController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraMousematController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-std::string AuraMousematController::GetVersion()
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0xEE;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x00;
-
-    hid_write(dev, usb_buf, 65);
-
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-
-    char version[5];
-    snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
-    return std::string(version);
-}
-
-void AuraMousematController::UpdateLeds
-    (
-    std::vector<RGBColor>    colors
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0xEE;
-    usb_buf[0x01]   = 0xC0;
-    usb_buf[0x02]   = 0x81;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-
-    for(unsigned int i = 0; i < 60; i += 4)
-    {
-        usb_buf[5 + i]   = 0x00;
-        usb_buf[6 + i]   = RGBGetRValue(colors[i / 4]);
-        usb_buf[7 + i]   = RGBGetGValue(colors[i / 4]);
-        usb_buf[8 + i]   = RGBGetBValue(colors[i / 4]);
-    }
-
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMousematController::UpdateDevice
-    (
-    unsigned char           mode,
-    std::vector<RGBColor>   colors,
-    unsigned char           speed,
-    unsigned char           brightness,
-    unsigned char           pattern
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0xEE;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x28;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = mode;
-    usb_buf[0x06]   = speed;
-    usb_buf[0x07]   = brightness;
-    usb_buf[0x08]   = pattern;
-    usb_buf[0x09]   = 0x00;
-
-    for(int i = 0; i < colors.size(); i++)
-    {
-        usb_buf[0x0a + i * 3]   = RGBGetRValue(colors[i]);
-        usb_buf[0x0b + i * 3]   = RGBGetGValue(colors[i]);
-        usb_buf[0x0c + i * 3]   = RGBGetBValue(colors[i]);
-    }
-    
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraMousematController::SaveMode()
-{
-    unsigned char usb_save_buf[65];
-
-    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-
-    usb_save_buf[0x00]   = 0xEE;
-    usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x55;
-
-    hid_write(dev, usb_save_buf, 65);
-}
@@ -1,59 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraMousematController.h             |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-
-enum
-{
-    AURA_MOUSEMAT_MODE_STATIC           = 0,
-    AURA_MOUSEMAT_MODE_BREATHING        = 1,
-    AURA_MOUSEMAT_MODE_COLOR_CYCLE      = 2,
-    AURA_MOUSEMAT_MODE_WAVE             = 3,
-    AURA_MOUSEMAT_MODE_WAVE_PLANE       = 4,
-    AURA_MOUSEMAT_MODE_COMET            = 5,
-    AURA_MOUSEMAT_MODE_GLOWING_YOYO     = 6,
-    AURA_MOUSEMAT_MODE_CROSS            = 7,
-    AURA_MOUSEMAT_MODE_STARRY_NIGHT     = 8,
-    AURA_MOUSEMAT_MODE_DIRECT           = 0xFF,
-};
-
-class AuraMousematController
-{
-public:
-    AuraMousematController(hid_device* dev_handle, const char* path);
-    virtual ~AuraMousematController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-
-    void UpdateLeds
-        (
-        std::vector<RGBColor>    colors
-        );
-
-    void UpdateDevice
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           speed,
-        unsigned char           brightness,
-        unsigned char           pattern
-        );
-
-    void SaveMode();
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,146 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraStrixEvolveController.h"
-
-#include <cstring>
-#include <chrono>
-#include <thread>
-
-AuraStrixEvolveController::AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AuraStrixEvolveController::~AuraStrixEvolveController()
-{
-    hid_close(dev);
-}
-
-std::string AuraStrixEvolveController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraStrixEvolveController::GetSerialString()
-{
-    wchar_t serial_string[HID_MAX_STR];
-    int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AuraStrixEvolveController::GetVersion()
-{
-    unsigned char usb_buf[9] = { 0x0c, 0xc4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-    hid_send_feature_report(dev, usb_buf, 9);
-
-    unsigned char usb_buf_out[9] = { 0x0c };
-    hid_get_feature_report(dev, usb_buf_out, 9);
-
-    return std::string("1." +  std::to_string(usb_buf_out[3]));
-}
-
-int AuraStrixEvolveController::GetActiveProfile()
-{
-    int profile;
-
-    do
-    {
-        unsigned char usb_buf[9] = { 0x0c, 0xdf, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-        hid_send_feature_report(dev, usb_buf, 9);
-
-        unsigned char usb_buf_out[9] = { 0x0c };
-        hid_get_feature_report(dev, usb_buf_out, 9);
-
-        profile = usb_buf_out[4] % 16;
-    } while (profile > 2);
-
-    return profile + 1;
-}
-
-void AuraStrixEvolveController::SendUpdate
-    (
-    unsigned char   key,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-    usb_buf[0x02]   = 0x0f;
-    usb_buf[0x03]   = 0x00;
-    usb_buf[0x04]   = key;
-    usb_buf[0x05]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-}
-
-
-void AuraStrixEvolveController::UpdateProfile
-    (
-    unsigned char   key,
-    unsigned char   profile,
-    unsigned char   value
-    )
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xde;
-    usb_buf[0x02]   = key;
-    usb_buf[0x03]   = profile;
-    usb_buf[0x04]   = value;
-    hid_send_feature_report(dev, usb_buf, 9);
-    std::this_thread::sleep_for(std::chrono::milliseconds(5));
-}
-
-void AuraStrixEvolveController::SendSavePacket()
-{
-    unsigned char usb_buf[9];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, 9);
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x0c;
-    usb_buf[0x01]   = 0xc4;
-
-    hid_send_feature_report(dev, usb_buf, 9);
-}
@@ -1,50 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraStrixEvolveController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-#define HID_MAX_STR 255
-
-class AuraStrixEvolveController
-{
-public:
-    AuraStrixEvolveController(hid_device* dev_handle, const char* path, uint16_t pid);
-    virtual ~AuraStrixEvolveController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-    int GetActiveProfile();
-
-    void SendUpdate
-        (
-        unsigned char   key,
-        unsigned char   value
-        );
-
-    void UpdateProfile
-        (
-        unsigned char   key,
-        unsigned char   profile,
-        unsigned char   value
-        );
-
-    void SendSavePacket();
-
-    uint16_t                    device_pid;
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
@@ -1,283 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.cpp        |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#include "AsusAuraTUFKeyboardController.h"
-
-#include <cstring>
-#include <string>
-#include <vector>
-#include <math.h>
-#include <stdio.h>
-#include <string.h>
-#include <cmath>
-
-AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
-{
-    dev         = dev_handle;
-    location    = path;
-    device_pid  = pid;
-}
-
-AuraTUFKeyboardController::~AuraTUFKeyboardController()
-{
-    hid_close(dev);
-}
-
-std::string AuraTUFKeyboardController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraTUFKeyboardController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = hid_get_serial_number_string(dev, serial_string, 128);
-
-    if(ret != 0)
-    {
-        return("");
-    }
-
-    std::wstring return_wstring = serial_string;
-    std::string return_string(return_wstring.begin(), return_wstring.end());
-
-    return(return_string);
-}
-
-std::string AuraTUFKeyboardController::GetVersion()
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x00;
-
-    hid_write(dev, usb_buf, 65);
-
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-
-    char version[9];
-    if (device_pid == AURA_TUF_K3_GAMING_PID)
-    {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
-    }
-    else
-    {
-        snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
-    }
-    
-    return std::string(version);
-}
-
-int AuraTUFKeyboardController::GetLayout()
-{
-    unsigned char usb_buf[65];
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x12;
-    usb_buf[0x02]   = 0x12;
-
-    hid_write(dev, usb_buf, 65);
-
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-
-    return(usb_buf_out[4] * 100 + usb_buf_out[5]);
-}
-
-void AuraTUFKeyboardController::SaveMode()
-{
-    unsigned char usb_save_buf[65];
-
-    memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
-
-    usb_save_buf[0x00]   = 0x00;
-    usb_save_buf[0x01]   = 0x50;
-    usb_save_buf[0x02]   = 0x55;
-
-    hid_write(dev, usb_save_buf, 65);
-}
-
-void AuraTUFKeyboardController::UpdateSingleLed
-    (
-    int             led,
-    unsigned char   red,
-    unsigned char   green,
-    unsigned char   blue
-    )
-{
-    /*-----------------------------------------------------*\
-    | Set up message packet for single LED                  |
-    \*-----------------------------------------------------*/
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0] = 0x00;
-    usb_buf[1] = 0xc0;
-    usb_buf[2] = 0x81;
-    usb_buf[3] = 0x01;
-    usb_buf[4] = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Convert LED index                                     |
-    \*-----------------------------------------------------*/
-    usb_buf[5] = floor(led/6)*8 + led%6;
-    usb_buf[6] = red;
-    usb_buf[7] = green;
-    usb_buf[8] = blue;
-
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraTUFKeyboardController::UpdateLeds
-    (
-    std::vector<RGBColor>    colors
-    )
-{
-    /*-----------------------------------------------------*\
-    | Loop over every column (optimisation needed)          |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < 192; i += 16)
-    {
-        unsigned char usb_buf[69];
-
-        memset(usb_buf, 0x00, sizeof(usb_buf));
-
-        usb_buf[0] = 0x00;
-        usb_buf[1] = 0xc0;
-        usb_buf[2] = 0x81;
-        usb_buf[3] = (138 - i / 16 * 12);
-        usb_buf[4] = 0x00;
-
-        for(unsigned int n = 0; n < 6; n++)
-        {
-            usb_buf[n * 4 + 5] = i + n;
-            usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
-            usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
-            usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
-        }
-
-        for(unsigned int n = 6; n < 8; n++)
-        {
-            usb_buf[n * 4 + 5] = i + n;
-            usb_buf[n * 4 + 6] = 0;
-            usb_buf[n * 4 + 7] = 0;
-            usb_buf[n * 4 + 8] = 0;
-        }
-
-        if(i != 176)
-        {
-            for(unsigned int n = 8; n < 14; n++)
-            {
-                usb_buf[n * 4 + 5] = i + n;
-                usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
-                usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
-                usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
-            }
-
-            for(unsigned int n = 14; n < 16; n++)
-            {
-                usb_buf[n * 4 + 5] = i + n;
-                usb_buf[n * 4 + 6] = 0;
-                usb_buf[n * 4 + 7] = 0;
-                usb_buf[n * 4 + 8] = 0;
-            }
-        }
-
-        hid_write(dev, usb_buf, 69);
-    }
-}
-
-void AuraTUFKeyboardController::UpdateDevice
-    (
-    unsigned char           mode,
-    std::vector<RGBColor>   colors,
-    unsigned char           dir,
-    unsigned char           color_mode,
-    unsigned char           speed,
-    unsigned char           brightness
-    )
-{
-    unsigned char usb_buf[65];
-
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x51;
-    usb_buf[0x02]   = 0x2C;
-    usb_buf[0x03]   = mode;
-    usb_buf[0x04]   = 0x00;
-    usb_buf[0x05]   = speed;
-    usb_buf[0x06]   = brightness;
-    usb_buf[0x07]   = color_mode;
-    usb_buf[0x08]   = dir;
-    usb_buf[0x09]   = 0x02;
-
-    if(mode == 4 || mode == 5)
-    {
-        /*-----------------------------------------------------*\
-        | If mode is Rainbow or Ripple                          |
-        \*-----------------------------------------------------*/
-        usb_buf[0x0A]   = colors.size();
-
-        /*-----------------------------------------------------*\
-        | Loop over every color given                           |
-        \*-----------------------------------------------------*/
-        for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
-        {
-            if(colors[i / 4])
-            {
-                usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
-                usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
-                usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
-                usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
-            }
-        }
-    }
-    else
-    {
-        /*-----------------------------------------------------*\
-        | Loop over Color1, Color2 and Background if there      |
-        \*-----------------------------------------------------*/
-        for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
-        {
-            if(colors[i / 3])
-            {
-                usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
-                usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
-                usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
-            }
-        }
-            
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
-
-void AuraTUFKeyboardController::AwaitResponse()
-{
-    unsigned char usb_buf_out[65];
-    hid_read(dev, usb_buf_out, 65);
-}
-
-void AuraTUFKeyboardController::ClearResponses()
-{
-    int result = 1;
-    unsigned char usb_buf_flush[65];
-    while(result > 0)
-    {
-      result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
-    }
-}
-
@@ -1,92 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "AsusAuraTUFKeyboardLayouts.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_KEYBOARD_ZONE_LOGO         = 0,
-    AURA_KEYBOARD_ZONE_SCROLL       = 1,
-    AURA_KEYBOARD_ZONE_UNDERGLOW    = 2,
-    AURA_KEYBOARD_ZONE_ALL          = 3,
-};
-
-enum
-{
-    AURA_KEYBOARD_MODE_STATIC       =  0,
-    AURA_KEYBOARD_MODE_BREATHING    =  1,
-    AURA_KEYBOARD_MODE_COLOR_CYCLE  =  2,
-    AURA_KEYBOARD_MODE_REACTIVE     =  3,
-    AURA_KEYBOARD_MODE_WAVE         =  4,
-    AURA_KEYBOARD_MODE_RIPPLE       =  5,
-    AURA_KEYBOARD_MODE_STARRY_NIGHT =  6,
-    AURA_KEYBOARD_MODE_QUICKSAND    =  7,
-    AURA_KEYBOARD_MODE_CURRENT      =  8,
-    AURA_KEYBOARD_MODE_RAIN_DROP    =  9,
-    AURA_KEYBOARD_MODE_DIRECT       = 15,
-};
-
-enum
-{
-    AURA_TUF_K7_GAMING_PID          = 0x18AA,
-    AURA_TUF_K3_GAMING_PID          = 0x194B,
-};
-
-
-class AuraTUFKeyboardController
-{
-public:
-    AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
-    ~AuraTUFKeyboardController();
-
-    std::string GetDeviceLocation();
-    std::string GetSerialString();
-    std::string GetVersion();
-    int         GetLayout();
-    void        SaveMode();
-
-    void UpdateSingleLed
-        (
-        int             led,
-        unsigned char   red,
-        unsigned char   green,
-        unsigned char   blue
-        );
-
-    void UpdateLeds
-        (
-        std::vector<RGBColor>    colors
-        );
-
-    void UpdateDevice
-        (
-        unsigned char           mode,
-        std::vector<RGBColor>   colors,
-        unsigned char           dir,
-        unsigned char           color_mode,
-        unsigned char           speed,
-        unsigned char           brightness
-        );
-    void AwaitResponse();
-    void ClearResponses();
-
-    uint16_t                    device_pid;
-
-private:
-    hid_device*                 dev;
-    std::string                 location;
-};
-
@@ -1,412 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraTUFKeyboardController.h          |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Mola19 10/02/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include <vector>
-#include <map>
-#include "RGBController.h"
-
-#pragma once
-
-enum
-{
-    ASUS_TUF_K7_LAYOUT_CA    = 1,
-    ASUS_TUF_K7_LAYOUT_AR    = 2,
-    ASUS_TUF_K7_LAYOUT_DE    = 3,
-    ASUS_TUF_K7_LAYOUT_UK    = 4,
-    ASUS_TUF_K7_LAYOUT_FR    = 5,
-    ASUS_TUF_K7_LAYOUT_CN    = 6,
-    ASUS_TUF_K7_LAYOUT_HU    = 7,
-    ASUS_TUF_K7_LAYOUT_IT    = 8,
-    ASUS_TUF_K7_LAYOUT_TH    = 9,
-    ASUS_TUF_K7_LAYOUT_UA    = 10,
-    ASUS_TUF_K7_LAYOUT_NO    = 11,
-    ASUS_TUF_K7_LAYOUT_PT    = 12,
-    ASUS_TUF_K7_LAYOUT_HE    = 13,
-    ASUS_TUF_K7_LAYOUT_RU    = 14,
-    ASUS_TUF_K7_LAYOUT_ES    = 15,
-    ASUS_TUF_K7_LAYOUT_TW    = 16,
-    ASUS_TUF_K7_LAYOUT_US    = 17,
-    ASUS_TUF_K7_LAYOUT_TR    = 18,
-    ASUS_TUF_K7_LAYOUT_CZ    = 19,
-    ASUS_TUF_K7_LAYOUT_BE    = 20,
-    ASUS_TUF_K7_LAYOUT_JP    = 21,
-    ASUS_TUF_K7_LAYOUT_KR    = 22,
-    ASUS_TUF_K7_LAYOUT_IS    = 23,
-    ASUS_TUF_K7_LAYOUT_WB    = 24,
-    ASUS_TUF_K7_LAYOUT_SW_CH = 25
-};
-
-#define NA  0xFFFFFFFF
-
-typedef struct
-{
-    unsigned int *                matrix_map;
-    std::vector<std::string>      led_names;
-} layout_type;
-
-
-static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_104[6][23] = {
-    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
-    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
-    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  92,  NA,  98, 104, 110, 116, 122, 128, 134 },
-    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  NA,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
-    {   4,  NA,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
-    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
-};
-
-static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_105[6][23] = {
-    {   0,  NA,  18,  24,  30,  36,  NA,  48,  54,  60,  66,  72,  78,  84,  90,  NA,  96, 102, 108,  NA,  NA,  NA,  NA },
-    {   1,  13,  19,  25,  31,  37,  43,  49,  55,  61,  67,  73,  79,  91,  NA,  NA,  97, 103, 109, 115, 121, 127, 133 },
-    {   2,  NA,  14,  20,  26,  32,  38,  44,  50,  56,  62,  68,  74,  80,  NA,  NA,  98, 104, 110, 116, 122, 128, 134 },
-    {   3,  NA,  15,  21,  27,  33,  39,  45,  51,  57,  63,  69,  75,  81,  93,  NA,  NA,  NA,  NA, 117, 123, 129,  NA },
-    {   4,  10,  16,  22,  28,  34,  40,  46,  52,  58,  64,  70,  NA,  94,  NA,  NA,  NA, 106,  NA, 118, 124, 130, 136 },
-    {   5,  11,  17,  NA,  NA,  NA,  41,  NA,  NA,  NA,  59,  71,  77,  NA,  95,  NA, 101, 107, 113, 119,  NA, 131,  NA }
-};
-
-
-static std::map<int,layout_type> AsusTUFK7Layouts =
-{
-    {
-        ASUS_TUF_K7_LAYOUT_UK,
-        {
-            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_105,
-            {
-                KEY_EN_ESCAPE,
-                KEY_EN_BACK_TICK,
-                KEY_EN_TAB,
-                KEY_EN_CAPS_LOCK,
-                KEY_EN_LEFT_SHIFT,
-                KEY_EN_LEFT_CONTROL,
-
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                "Key: \\",
-                KEY_EN_LEFT_WINDOWS,
-
-                KEY_EN_UNUSED,
-                KEY_EN_1,
-                KEY_EN_Q,
-                KEY_EN_A,
-                KEY_EN_Z,
-                KEY_EN_LEFT_ALT,
-
-                KEY_EN_F1,
-                KEY_EN_2,
-                KEY_EN_W,
-                KEY_EN_S,
-                KEY_EN_X,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F2,
-                KEY_EN_3,
-                KEY_EN_E,
-                KEY_EN_D,
-                KEY_EN_C,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F3,
-                KEY_EN_4,
-                KEY_EN_R,
-                KEY_EN_F,
-                KEY_EN_V,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F4,
-                KEY_EN_5,
-                KEY_EN_T,
-                KEY_EN_G,
-                KEY_EN_B,
-                KEY_EN_SPACE,
-
-                KEY_EN_UNUSED,
-                KEY_EN_6,
-                KEY_EN_Y,
-                KEY_EN_H,
-                KEY_EN_N,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F5,
-                KEY_EN_7,
-                KEY_EN_U,
-                KEY_EN_J,
-                KEY_EN_M,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F6,
-                KEY_EN_8,
-                KEY_EN_I,
-                KEY_EN_K,
-                KEY_EN_COMMA,
-                KEY_EN_RIGHT_ALT,
-
-                KEY_EN_F7,
-                KEY_EN_9,
-                KEY_EN_O,
-                KEY_EN_L,
-                KEY_EN_PERIOD,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F8,
-                KEY_EN_0,
-                KEY_EN_P,
-                KEY_EN_SEMICOLON,
-                KEY_EN_FORWARD_SLASH,
-                KEY_EN_RIGHT_FUNCTION,
-
-                KEY_EN_F9,
-                KEY_EN_MINUS,
-                KEY_EN_LEFT_BRACKET,
-                KEY_EN_QUOTE,
-                KEY_EN_UNUSED,
-                KEY_EN_MENU,
-
-                KEY_EN_F10,
-                KEY_EN_EQUALS,
-                KEY_EN_RIGHT_BRACKET,
-                KEY_EN_POUND,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F11,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F12,
-                KEY_EN_BACKSPACE,
-                KEY_EN_UNUSED,
-                KEY_EN_ANSI_ENTER,
-                KEY_EN_RIGHT_SHIFT,
-                KEY_EN_RIGHT_CONTROL,
-
-                KEY_EN_PRINT_SCREEN,
-                KEY_EN_INSERT,
-                KEY_EN_DELETE,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_LEFT_ARROW,
-
-                KEY_EN_SCROLL_LOCK,
-                KEY_EN_HOME,
-                KEY_EN_END,
-                KEY_EN_UNUSED,
-                KEY_EN_UP_ARROW,
-                KEY_EN_DOWN_ARROW,
-
-                KEY_EN_PAUSE_BREAK,
-                KEY_EN_PAGE_UP,
-                KEY_EN_PAGE_DOWN,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_RIGHT_ARROW,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_LOCK,
-                KEY_EN_NUMPAD_7,
-                KEY_EN_NUMPAD_4,
-                KEY_EN_NUMPAD_1,
-                KEY_EN_NUMPAD_0,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_DIVIDE,
-                KEY_EN_NUMPAD_8,
-                KEY_EN_NUMPAD_5,
-                KEY_EN_NUMPAD_2,
-                KEY_EN_UNUSED,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_TIMES,
-                KEY_EN_NUMPAD_9,
-                KEY_EN_NUMPAD_6,
-                KEY_EN_NUMPAD_3,
-                "Key: Number Pad ,",
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_MINUS,
-                KEY_EN_NUMPAD_PLUS,
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_ENTER,
-                KEY_EN_UNUSED,
-            }
-        }
-    },
-    {
-        ASUS_TUF_K7_LAYOUT_US,
-        {
-            (unsigned int *) ASUS_TUF_K7_LAYOUT_KEYS_104,
-            {
-                KEY_EN_ESCAPE,
-                KEY_EN_BACK_TICK,
-                KEY_EN_TAB,
-                KEY_EN_CAPS_LOCK,
-                KEY_EN_LEFT_SHIFT,
-                KEY_EN_LEFT_CONTROL,
-
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_LEFT_WINDOWS,
-
-                KEY_EN_UNUSED,
-                KEY_EN_1,
-                KEY_EN_Q,
-                KEY_EN_A,
-                KEY_EN_Z,
-                KEY_EN_LEFT_ALT,
-
-                KEY_EN_F1,
-                KEY_EN_2,
-                KEY_EN_W,
-                KEY_EN_S,
-                KEY_EN_X,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F2,
-                KEY_EN_3,
-                KEY_EN_E,
-                KEY_EN_D,
-                KEY_EN_C,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F3,
-                KEY_EN_4,
-                KEY_EN_R,
-                KEY_EN_F,
-                KEY_EN_V,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F4,
-                KEY_EN_5,
-                KEY_EN_T,
-                KEY_EN_G,
-                KEY_EN_B,
-                KEY_EN_SPACE,
-
-                KEY_EN_UNUSED,
-                KEY_EN_6,
-                KEY_EN_Y,
-                KEY_EN_H,
-                KEY_EN_N,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F5,
-                KEY_EN_7,
-                KEY_EN_U,
-                KEY_EN_J,
-                KEY_EN_M,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F6,
-                KEY_EN_8,
-                KEY_EN_I,
-                KEY_EN_K,
-                KEY_EN_COMMA,
-                KEY_EN_RIGHT_ALT,
-
-                KEY_EN_F7,
-                KEY_EN_9,
-                KEY_EN_O,
-                KEY_EN_L,
-                KEY_EN_PERIOD,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F8,
-                KEY_EN_0,
-                KEY_EN_P,
-                KEY_EN_SEMICOLON,
-                KEY_EN_FORWARD_SLASH,
-                KEY_EN_RIGHT_FUNCTION,
-
-                KEY_EN_F9,
-                KEY_EN_MINUS,
-                KEY_EN_LEFT_BRACKET,
-                KEY_EN_QUOTE,
-                KEY_EN_UNUSED,
-                KEY_EN_MENU,
-
-                KEY_EN_F10,
-                KEY_EN_EQUALS,
-                KEY_EN_RIGHT_BRACKET,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F11,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-
-                KEY_EN_F12,
-                KEY_EN_BACKSPACE,
-                "Key: \\",
-                KEY_EN_ANSI_ENTER,
-                KEY_EN_RIGHT_SHIFT,
-                KEY_EN_RIGHT_CONTROL,
-
-                KEY_EN_PRINT_SCREEN,
-                KEY_EN_INSERT,
-                KEY_EN_DELETE,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_LEFT_ARROW,
-
-                KEY_EN_SCROLL_LOCK,
-                KEY_EN_HOME,
-                KEY_EN_END,
-                KEY_EN_UNUSED,
-                KEY_EN_UP_ARROW,
-                KEY_EN_DOWN_ARROW,
-
-                KEY_EN_PAUSE_BREAK,
-                KEY_EN_PAGE_UP,
-                KEY_EN_PAGE_DOWN,
-                KEY_EN_UNUSED,
-                KEY_EN_UNUSED,
-                KEY_EN_RIGHT_ARROW,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_LOCK,
-                KEY_EN_NUMPAD_7,
-                KEY_EN_NUMPAD_4,
-                KEY_EN_NUMPAD_1,
-                KEY_EN_NUMPAD_0,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_DIVIDE,
-                KEY_EN_NUMPAD_8,
-                KEY_EN_NUMPAD_5,
-                KEY_EN_NUMPAD_2,
-                KEY_EN_UNUSED,
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_TIMES,
-                KEY_EN_NUMPAD_9,
-                KEY_EN_NUMPAD_6,
-                KEY_EN_NUMPAD_3,
-                "Key: Number Pad ,",
-
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_MINUS,
-                KEY_EN_NUMPAD_PLUS,
-                KEY_EN_UNUSED,
-                KEY_EN_NUMPAD_ENTER,
-                KEY_EN_UNUSED,
-            }
-        }
-    },
-};
@@ -1,178 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraUSBController.cpp                |
-|                                           |
-|  Driver for ASUS Aura RGB USB             |
-|  lighting controller                      |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "AsusAuraUSBController.h"
-#include "LogManager.h"
-
-#include <cstring>
-#include <stdexcept>
-
-AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    GetFirmwareVersion();
-    GetConfigTable();
-}
-
-AuraUSBController::~AuraUSBController()
-{
-    hid_close(dev);
-}
-unsigned int AuraUSBController::GetChannelCount()
-{
-    return(device_info.size());
-}
-
-std::string AuraUSBController::GetDeviceLocation()
-{
-    return("HID: " + location);
-}
-
-std::string AuraUSBController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraUSBController::GetSerialString()
-{
-    wchar_t serial_string[128];
-    int ret = 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(return_string);
-}
-
-const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
-{
-    return(device_info);
-}
-
-void AuraUSBController::GetConfigTable()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up config table request packet                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_REQUEST_CONFIG_TABLE;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Copy the firmware string if the reply ID is correct   |
-    \*-----------------------------------------------------*/
-    if(usb_buf[1] == 0x30)
-    {
-        memcpy(config_table, &usb_buf[4], 60);
-
-        LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name);
-
-        for(int i = 0; i < 60; i+=6)
-        {
-            LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name,
-                                                            config_table[i + 0],
-                                                            config_table[i + 1],
-                                                            config_table[i + 2],
-                                                            config_table[i + 3],
-                                                            config_table[i + 4],
-                                                            config_table[i + 5]);
-        }
-    }
-    else
-    {       
-        LOG_INFO("[%s] Could not read config table, can not add device", device_name);
-        delete this;
-    }
-}
-
-void AuraUSBController::GetFirmwareVersion()
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up firmware version request packet                |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_REQUEST_FIRMWARE_VERSION;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-
-    /*-----------------------------------------------------*\
-    | Copy the firmware string if the reply ID is correct   |
-    \*-----------------------------------------------------*/
-    if(usb_buf[1] == 0x02)
-    {
-        memcpy(device_name, &usb_buf[2], 16);
-    }
-}
-
-void AuraUSBController::SendDirect
-    (
-    unsigned char   device,
-    unsigned char   start_led,
-    unsigned char   led_count,
-    unsigned char*  led_data,
-    bool apply /* = false */
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up message packet                                 |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0xEC;
-    usb_buf[0x01]   = AURA_CONTROL_MODE_DIRECT;
-    usb_buf[0x02]   = apply ? 0x80 : 0x00;
-    usb_buf[0x02]  |= device;
-    usb_buf[0x03]   = start_led;
-    usb_buf[0x04]   = led_count;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x05], led_data, led_count * 3);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-}
@@ -1,112 +0,0 @@
-/*-----------------------------------------*\
-|  AsusAuraUSBController.h                  |
-|                                           |
-|  Definitions and types for ASUS Aura      |
-|  USB RGB lighting controller              |
-|                                           |
-|  Martin Hartl (inlart) 4/25/2020          |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-#include "LogManager.h"
-
-#include <string>
-#include <vector>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
-    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
-    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
-    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
-    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
-    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
-    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
-    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
-    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
-    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
-    AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
-    AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
-    AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
-    AURA_MODE_MUSIC                     = 14,       /* Music effect mode                    */
-    AURA_MODE_DIRECT                    = 0xFF,     /* Direct control mode                  */
-};
-
-enum
-{
-    AURA_REQUEST_FIRMWARE_VERSION       = 0x82,     /* Request firmware string              */
-    AURA_REQUEST_CONFIG_TABLE           = 0xB0,     /* Request configuration table          */
-    AURA_CONTROL_MODE_DIRECT            = 0x40,     /* Direct control mode                  */
-};
-
-enum class AuraDeviceType
-{
-    FIXED,
-    ADDRESSABLE,
-};
-
-struct AuraDeviceInfo
-{
-    unsigned char effect_channel;
-    unsigned char direct_channel;
-    unsigned char num_leds;
-    unsigned char num_headers;
-    AuraDeviceType device_type;
-};
-
-class AuraUSBController
-{
-public:
-    AuraUSBController(hid_device* dev_handle, const char* path);
-    virtual ~AuraUSBController();
-
-    unsigned int GetChannelCount();
-
-    std::string GetDeviceLocation();
-    std::string GetDeviceName();
-    std::string GetSerialString();
-
-    const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
-
-    virtual void SetChannelLEDs
-        (
-        unsigned char   channel,
-        RGBColor *      colors,
-        unsigned int    num_colors
-        ) = 0;
-
-    virtual void SetMode
-        (
-        unsigned char   channel,
-        unsigned char   mode,
-        unsigned char   red,
-        unsigned char   grn,
-        unsigned char   blu
-        ) = 0;
-
-protected:
-    hid_device*                 dev;
-    unsigned char               config_table[60];
-    std::vector<AuraDeviceInfo> device_info;
-    std::string                 location;
-
-    void SendDirect
-        (
-        unsigned char   device,
-        unsigned char   start_led,
-        unsigned char   led_count,
-        unsigned char*  led_data,
-        bool apply = false
-        );
-private:
-    char                        device_name[16];
-    unsigned int                led_count;
-
-    void GetConfigTable();
-
-    void GetFirmwareVersion();
-};
@@ -1,332 +0,0 @@
-#include "Detector.h"
-#include "AsusAuraAddressableController.h"
-#include "AsusAuraHeadsetStandController.h"
-#include "AsusAuraKeyboardController.h"
-#include "AsusAuraTUFKeyboardController.h"
-#include "AsusAuraMainboardController.h"
-#include "AsusAuraMouseController.h"
-#include "AsusAuraMousematController.h"
-#include "AsusAuraStrixEvolveController.h"
-#include "AsusAuraMonitorController.h"
-#include "RGBController.h"
-#include "RGBController_AsusAuraUSB.h"
-#include "RGBController_AsusAuraHeadsetStand.h"
-#include "RGBController_AsusAuraKeyboard.h"
-#include "RGBController_AsusAuraTUFKeyboard.h"
-#include "RGBController_AsusAuraMouse.h"
-#include "RGBController_AsusAuraMousemat.h"
-#include "RGBController_ROGStrixLC_Controller.h"
-#include "RGBController_AsusAuraStrixEvolve.h"
-#include "RGBController_AsusAuraMonitor.h"
-#include <stdexcept>
-#include <hidapi/hidapi.h>
-#include "dependencies/dmiinfo.h"
-
-#define AURA_USB_VID                            0x0B05
-
-/*-----------------------------------------------------------------*\
-|  MOTHERBOARDS                                                     |
-\*-----------------------------------------------------------------*/
-#define AURA_ADDRESSABLE_1_PID                  0x1867
-#define AURA_ADDRESSABLE_2_PID                  0x1872
-#define AURA_ADDRESSABLE_3_PID                  0x18A3
-#define AURA_ADDRESSABLE_4_PID                  0x18A5
-#define AURA_MOTHERBOARD_1_PID                  0x18F3
-#define AURA_MOTHERBOARD_2_PID                  0x1939
-#define AURA_MOTHERBOARD_3_PID                  0x19AF
-
-/*-----------------------------------------------------------------*\
-|  KEYBOARDS                                                        |
-\*-----------------------------------------------------------------*/
-#define AURA_ROG_FALCHION_WIRED_PID             0x193C
-#define AURA_ROG_FALCHION_WIRELESS_PID          0x193E
-#define AURA_ROG_STRIX_FLARE_PID                0x1875
-#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID        0x18CF
-#define AURA_ROG_STRIX_SCOPE_PID                0x18F8
-#define AURA_ROG_STRIX_SCOPE_RX_PID             0x1951
-#define AURA_ROG_STRIX_SCOPE_TKL_PID            0x190C
-#define AURA_TUF_K7_GAMING_PID                  0x18AA
-#define AURA_TUF_K3_GAMING_PID                  0x194B
-
-/*-----------------------------------------------------------------*\
-|  MICE - defined in AsusAuraMouseDevices.h                         |
-\*-----------------------------------------------------------------*/
-
-#define AURA_ROG_STRIX_EVOLVE_PID               0x185B
-
-/*-----------------------------------------------------------------*\
-| MOUSEMATS                                                         |
-\*-----------------------------------------------------------------*/
-#define AURA_ROG_BALTEUS_PID                    0x1891
-#define AURA_ROG_BALTEUS_QI_PID                 0x1890
-
-/*-----------------------------------------------------------------*\
-| MONITORS                                                          |
-\*-----------------------------------------------------------------*/
-
-#define AURA_ROG_STRIX_XG27AQ_PID               0x198C
-
-/*-----------------------------------------------------------------*\
-| HEADSETSTANDS                                                     |
-\*-----------------------------------------------------------------*/
-
-#define AURA_ROG_THRONE_PID                     0x18D9
-#define AURA_ROG_THRONE_QI_PID                  0x18C5
-#define AURA_ROG_THRONE_QI_GUNDAM_PID           0x1994
-
-/*-----------------------------------------------------------------*\
-|  OTHER                                                            |
-\*-----------------------------------------------------------------*/
-#define AURA_TERMINAL_PID                       0x1889
-#define ROG_STRIX_LC120_PID                     0x879E
-
-AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
-{
-    switch(pid)
-    {
-        case AURA_ROG_STRIX_FLARE_PID:
-        case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
-            return FLARE_LAYOUT;
-
-        case AURA_ROG_STRIX_SCOPE_PID:
-            return SCOPE_LAYOUT;
-
-        case AURA_ROG_STRIX_SCOPE_RX_PID:
-            return SCOPE_RX_LAYOUT;
-
-        case AURA_ROG_STRIX_SCOPE_TKL_PID:
-            return SCOPE_TKL_LAYOUT;
-
-        case AURA_ROG_FALCHION_WIRED_PID:
-        case AURA_ROG_FALCHION_WIRELESS_PID:
-            return FALCHION_LAYOUT;
-
-        default:
-            return FLARE_LAYOUT;
-    }
-}
-
-void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*name*/)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        DMIInfo dmi;
-        AuraAddressableController* controller               = new AuraAddressableController(dev, info->path);
-        RGBController_AuraUSB*     rgb_controller           = new RGBController_AuraUSB(controller);
-        rgb_controller->name                                = "ASUS " + dmi.getMainboard() + " Addressable";
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*name*/)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        try
-        {
-            DMIInfo dmi;
-            AuraMainboardController* controller             = new AuraMainboardController(dev, info->path);
-            RGBController_AuraUSB*   rgb_controller         = new RGBController_AuraUSB(controller);
-            rgb_controller->name                            = "ASUS " + dmi.getMainboard();
-            ResourceManager::get()->RegisterRGBController(rgb_controller);
-        }
-        catch(const std::runtime_error& ex)
-        {
-            // reading the config table failed
-            LOG_ERROR("[AsusAuraUSB] An error occured while reading the config table: %s", ex.what());
-        }
-    }
-}
-
-void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraKeyboardController*       controller            = new AuraKeyboardController(dev, info->path);
-        AuraKeyboardMappingLayoutType layout                = GetKeyboardMappingLayoutType(info->product_id);
-        RGBController_AuraKeyboard*   rgb_controller        = new RGBController_AuraKeyboard(controller, layout);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraMouseController*     controller                 = new AuraMouseController(dev, info->path, info->product_id);
-        RGBController_AuraMouse* rgb_controller             = new RGBController_AuraMouse(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraMousematController*     controller              = new AuraMousematController(dev, info->path);
-        RGBController_AuraMousemat* rgb_controller          = new RGBController_AuraMousemat(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        ROGStrixLC_Controller* controller                   = new ROGStrixLC_Controller(dev, info->path);
-        RGBController_ROGStrixLC_Controller* rgb_controller = new RGBController_ROGStrixLC_Controller(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraStrixEvolveController*     controller           = new AuraStrixEvolveController(dev, info->path, info->product_id);
-        RGBController_AuraStrixEvolve* rgb_controller       = new RGBController_AuraStrixEvolve(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraHeadsetStandController*     controller          = new AuraHeadsetStandController(dev, info->path);
-        RGBController_AuraHeadsetStand* rgb_controller      = new RGBController_AuraHeadsetStand(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraTUFKeyboardController*     controller           = new AuraTUFKeyboardController(dev, info->path, info->product_id);
-        RGBController_AuraTUFKeyboard* rgb_controller       = new RGBController_AuraTUFKeyboard(controller);
-        rgb_controller->name                                = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        AuraMonitorController*     controller           = new AuraMonitorController(dev, info->path);
-        RGBController_AuraMonitor* rgb_controller       = new RGBController_AuraMonitor(controller);
-        rgb_controller->name                            = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-    }
-}
-
-/*-----------------------------------------------------------------*\
-|  MOTHERBOARDS                                                     |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
-REGISTER_HID_DETECTOR   ("ASUS Aura Motherboard",               DetectAsusAuraUSBMotherboards,  AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
-
-/*-----------------------------------------------------------------*\
-|  KEYBOARDS                                                        |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)",           DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID,              1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID,           1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX",             DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID,              1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL",            DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID,             1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K7_GAMING_PID,                   1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3",                  DetectAsusAuraTUFUSBKeyboard,   AURA_USB_VID, AURA_TUF_K3_GAMING_PID,                   1,  0xFF00);
-
-/*-----------------------------------------------------------------*\
-|  MICE                                                             |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II",                 DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_PID,                  2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin",          DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID,           2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD",  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID,   2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID,       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID,       1,  0xFF13);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID,       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID,            0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("Asus ROG Chakram Core",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_PID,                       2,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)",           DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID,              0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)",        DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact",               DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID,                0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID,             0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris",                      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS,                           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless USB",         DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_USB_PID,          0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless 2.4Ghz",      DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_2_4_PID,          0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Keris Wireless Bluetooth",   DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_KERIS_WIRELESS_BT_PID,           0,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M3",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M3_PID,                          1,  0xFF01);
-REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5",                  DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_TUF_M5_PID,                          2,  0xFF01);
-
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve",               DetectAsusAuraUSBStrixEvolve,   AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID,                1,  0x0008);
-
-/*-----------------------------------------------------------------*\
-| MOUSEMATS                                                         |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus",                    DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_PID,                     0xFF06, 1);
-REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi",                 DetectAsusAuraUSBMousemats,     AURA_USB_VID, AURA_ROG_BALTEUS_QI_PID,                  0xFF06, 1);
-
-/*-----------------------------------------------------------------*\
-| MONITORS                                                          |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ",               DetectAsusAuraUSBMonitor,       AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID,                0xFFA0, 1);
-
-/*-----------------------------------------------------------------*\
-|  OTHER                                                            |
-\*-----------------------------------------------------------------*/
-REGISTER_HID_DETECTOR    ("ASUS ROG AURA Terminal",             DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
-REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC",                  DetectAsusAuraUSBROGStrixLC,    AURA_USB_VID, ROG_STRIX_LC120_PID,                      0x00FF, 1);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne",                    DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_PID,                      0);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI",                 DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID,                   0);
-REGISTER_HID_DETECTOR_I  ("ASUS ROG Throne QI GUNDAM",          DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID,            0);
@@ -1,214 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraHeadsetStand.cpp   |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraHeadsetStand.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Headset Stand
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBHeadsetStand
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura Headset Stand";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_HEADSET_STAND;
-    description = "ASUS Aura Headset Stand Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_HEADSET_STAND_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name           = "Static";
-    Static.value          = AURA_HEADSET_STAND_MODE_STATIC;
-    Static.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Static.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Static.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Static.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Static.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min     = 1;
-    Static.colors_max     = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name           = "Breathing";
-    Breathing.value          = AURA_HEADSET_STAND_MODE_BREATHING;
-    Breathing.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    Breathing.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    Breathing.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    Breathing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Breathing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Breathing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Breathing.colors_min     = 1;
-    Breathing.colors_max     = 1;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Strobing;
-    Strobing.name           = "Flashing";
-    Strobing.value          = AURA_HEADSET_STAND_MODE_STROBING;
-    Strobing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Strobing.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Strobing.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Strobing.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    Strobing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Strobing.colors_min     = 1;
-    Strobing.colors_max     = 1;
-    Strobing.colors.resize(1);
-    modes.push_back(Strobing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name           = "Spectrum Cycle";
-    SpectrumCycle.value          = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
-    SpectrumCycle.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    SpectrumCycle.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    SpectrumCycle.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    SpectrumCycle.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    SpectrumCycle.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    SpectrumCycle.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    SpectrumCycle.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    SpectrumCycle.color_mode     = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Rainbow;
-    Rainbow.name           = "Rainbow Wave";
-    Rainbow.value          = AURA_HEADSET_STAND_MODE_RAINBOW;
-    Rainbow.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Rainbow.speed_min      = AURA_HEADSETSTAND_SPEED_MIN;
-    Rainbow.speed_max      = AURA_HEADSETSTAND_SPEED_MAX;
-    Rainbow.speed          = AURA_HEADSETSTAND_SPEED_DEFAULT;
-    Rainbow.brightness_min = AURA_HEADSETSTAND_BRIGHTNESS_MIN;
-    Rainbow.brightness_max = AURA_HEADSETSTAND_BRIGHTNESS_MAX;
-    Rainbow.brightness     = AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT;
-    modes.push_back(Rainbow);
-    SetupZones();
-}
-
-RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
-{
-    delete controller;
-}
-
-void RGBController_AuraHeadsetStand::SetupZones()
-{
-    zone underglow_zone;
-
-    underglow_zone.name         = "Underglow";
-    underglow_zone.type         = ZONE_TYPE_LINEAR;
-    underglow_zone.leds_min     = 17;
-    underglow_zone.leds_max     = 17;
-    underglow_zone.leds_count   = 17;
-    underglow_zone.matrix_map   = NULL;
-
-    zones.push_back(underglow_zone);
-
-    for(unsigned int i = 0; i < 17; i++)
-    {
-        led underglow_led;
-
-        underglow_led.name      = "Underglow LED " + std::to_string(i);
-
-        leds.push_back(underglow_led);
-    }
-
-    zone logo_zone;
-
-    logo_zone.name              = "Logo";
-    logo_zone.type              = ZONE_TYPE_SINGLE;
-    logo_zone.leds_min          = 1;
-    logo_zone.leds_max          = 1;
-    logo_zone.leds_count        = 1;
-    logo_zone.matrix_map        = NULL;
-
-    zones.push_back(logo_zone);
-
-    led logo_led;
-
-    logo_led.name               = "Logo LED";
-
-    leds.push_back(logo_led);
-
-    SetupColors();
-}
-
-void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
-{
-    controller->UpdateLeds(std::vector<RGBColor>(colors));
-}
-
-void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraHeadsetStand::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-
-void RGBController_AuraHeadsetStand::DeviceUpdateMode()
-{
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-    switch(modes[active_mode].value)
-    {
-        case 0:
-            controller->UpdateLeds(std::vector<RGBColor>(colors));
-            break;
-        case 1:
-        case 2:
-        case 3:
-            red = RGBGetRValue(modes[active_mode].colors[0]);
-            grn = RGBGetGValue(modes[active_mode].colors[0]);
-            blu = RGBGetBValue(modes[active_mode].colors[0]);
-            controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
-            break;
-        case 4:
-        case 5:
-            controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
-            break;
-    }
-}
-
-void RGBController_AuraHeadsetStand::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    controller->SaveMode();
-}
@@ -1,44 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraHeadsetStand.h     |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraHeadsetStandController.h"
-
-enum
-{
-    AURA_HEADSETSTAND_BRIGHTNESS_MIN     = 0,
-    AURA_HEADSETSTAND_BRIGHTNESS_MAX     = 4,
-    AURA_HEADSETSTAND_BRIGHTNESS_DEFAULT = 4,
-    AURA_HEADSETSTAND_SPEED_MIN          = 0,
-    AURA_HEADSETSTAND_SPEED_MAX          = 255,
-    AURA_HEADSETSTAND_SPEED_DEFAULT      = 127,
-};
-
-class RGBController_AuraHeadsetStand : public RGBController
-{
-public:
-    RGBController_AuraHeadsetStand(AuraHeadsetStandController* controller_ptr);
-    ~RGBController_AuraHeadsetStand();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraHeadsetStandController*  controller;
-};
@@ -1,537 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraKeyboard.cpp       |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/19/2020   |
-\*-----------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_AsusAuraKeyboard.h"
-
-//0xFFFFFFFF indicates an unused entry in matrix
-#define NA  0xFFFFFFFF
-
-static unsigned int flare_matrix_map[6][22] =
-    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
-      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
-      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
-      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
-      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
-      {   5,   7,  12,  NA,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };
-
-static unsigned int scope_matrix_map[6][22] =
-    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  76,  80,  85,  NA,  NA,  NA,  NA },
-      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  77,  81,  86,  89,  94,  98, 103 },
-      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  78,  82,  87,  90,  95,  99, 104 },
-      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA,  91,  96, 100,  NA },
-      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  83,  NA,  92,  97, 101, 105 },
-      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  79,  84,  88,  93,  NA, 102,  NA } };
-
-static unsigned int scope_tkl_matrix_map[6][18] =
-    { {   0,  NA,  13,  18,  23,  28,  38,  43,  49,  54,  60,  65,  69,  70,  NA,  NA,  NA,  NA },
-      {   1,   8,  14,  19,  24,  29,  34,  39,  44,  50,  55,  61,  66,  71,  NA,  76,  79,  83 },
-      {   2,  NA,   9,  15,  20,  25,  30,  35,  40,  45,  51,  56,  62,  67,  72,  77,  80,  84 },
-      {   3,  NA,  10,  16,  21,  26,  31,  36,  41,  46,  52,  57,  63,  68,  73,  NA,  NA,  NA },
-      {   4,   6,  11,  17,  22,  27,  32,  37,  42,  47,  53,  58,  74,  NA,  NA,  NA,  81,  NA },
-      {   5,   NA,  7,  12,  NA,  NA,  NA,  33,  NA,  48,  NA,  59,  64,  75,  NA,  78,  82,  85 } };
-
-static unsigned int falchion_matrix_map[5][16] =
-    { {   0,   5,   9,  14,  18,  22,  26,  31,  35,  39,  44,  49,  54,  58,  NA,  63 },
-      {   1,  NA,   6,  10,  15,  19,  23,  27,  32,  36,  40,  45,  50,  55,  59,  64 },
-      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 }, 
-      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
-      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };
-
-static const std::vector<led_type> default_led_names =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0x00    },
-    { KEY_EN_BACK_TICK,         0x01    },
-    { KEY_EN_TAB,               0x02    },
-    { KEY_EN_CAPS_LOCK,         0x03    },
-    { KEY_EN_LEFT_SHIFT,        0x04    },
-    { KEY_EN_LEFT_CONTROL,      0x05    },
-    { KEY_EN_ISO_BACK_SLASH,    0x0C    },
-    { KEY_EN_1,                 0x11    },
-    { KEY_EN_Q,                 0x12    },
-    { KEY_EN_A,                 0x13    },
-    { KEY_EN_Z,                 0x14    },
-    { KEY_EN_F1,                0x18    },
-    { KEY_EN_2,                 0x19    },
-    { KEY_EN_W,                 0x1A    },
-    { KEY_EN_S,                 0x1B    },
-    { KEY_EN_X,                 0x1C    },
-    { KEY_EN_F2,                0x20    },
-    { KEY_EN_3,                 0x21    },
-    { KEY_EN_E,                 0x22    },
-    { KEY_EN_D,                 0x23    },
-    { KEY_EN_C,                 0x24    },
-    { KEY_EN_F3,                0x28    },
-    { KEY_EN_4,                 0x29    },
-    { KEY_EN_R,                 0x2A    },
-    { KEY_EN_F,                 0x2B    },
-    { KEY_EN_V,                 0x2C    },
-    { KEY_EN_F4,                0x30    },
-    { KEY_EN_5,                 0x31    },
-    { KEY_EN_T,                 0x32    },
-    { KEY_EN_G,                 0x33    },
-    { KEY_EN_B,                 0x34    },
-    { KEY_EN_SPACE,             0x35    },
-    { KEY_EN_6,                 0x39    },
-    { KEY_EN_Y,                 0x3A    },
-    { KEY_EN_H,                 0x3B    },
-    { KEY_EN_N,                 0x3C    },
-    { KEY_EN_F5,                0x40    },
-    { KEY_EN_7,                 0x41    },
-    { KEY_EN_U,                 0x42    },
-    { KEY_EN_J,                 0x43    },
-    { KEY_EN_M,                 0x44    },
-    { KEY_EN_F6,                0x48    },
-    { KEY_EN_8,                 0x49    },
-    { KEY_EN_I,                 0x4A    },
-    { KEY_EN_K,                 0x4B    },
-    { KEY_EN_COMMA,             0x4C    },
-    { KEY_EN_RIGHT_ALT,         0x4D    },
-    { KEY_EN_F7,                0x50    },
-    { KEY_EN_9,                 0x51    },
-    { KEY_EN_O,                 0x52    },
-    { KEY_EN_L,                 0x53    },
-    { KEY_EN_PERIOD,            0x54    },
-    { KEY_EN_F8,                0x58    },
-    { KEY_EN_0,                 0x59    },
-    { KEY_EN_P,                 0x5A    },
-    { KEY_EN_SEMICOLON,         0x5B    },
-    { KEY_EN_FORWARD_SLASH,     0x5C    },
-    { KEY_EN_RIGHT_FUNCTION,    0x5D    },
-    { KEY_EN_F9,                0x60    },
-    { KEY_EN_MINUS,             0x61    },
-    { KEY_EN_LEFT_BRACKET,      0x62    },
-    { KEY_EN_QUOTE,             0x63    },
-    { KEY_EN_MENU,              0x65    },
-    { KEY_EN_F10,               0x68    },
-    { KEY_EN_EQUALS,            0x69    },
-    { KEY_EN_RIGHT_BRACKET,     0x6A    },
-    { KEY_EN_POUND,             0x6B    },
-    { KEY_EN_F11,               0x70    },
-    { KEY_EN_F12,               0x78    },
-    { KEY_EN_BACKSPACE,         0x79    },
-    { KEY_EN_ANSI_BACK_SLASH,   0x7A    },
-    { KEY_EN_ANSI_ENTER,        0x7B    },
-    { KEY_EN_RIGHT_SHIFT,       0x7C    },
-    { KEY_EN_RIGHT_CONTROL,     0x7D    },
-    { KEY_EN_PRINT_SCREEN,      0x80    },
-    { KEY_EN_INSERT,            0x81    },
-    { KEY_EN_DELETE,            0x82    },
-    { KEY_EN_LEFT_ARROW,        0x85    },
-    { KEY_EN_SCROLL_LOCK,       0x88    },
-    { KEY_EN_HOME,              0x89    },
-    { KEY_EN_END,               0x8A    },
-    { KEY_EN_UP_ARROW,          0x8C    },
-    { KEY_EN_DOWN_ARROW,        0x8D    },
-    { KEY_EN_PAUSE_BREAK,       0x90    },
-    { KEY_EN_PAGE_UP,           0x91    },
-    { KEY_EN_PAGE_DOWN,         0x92    },
-    { KEY_EN_RIGHT_ARROW,       0x95    },
-    { KEY_EN_NUMPAD_LOCK,       0x99    },
-    { KEY_EN_NUMPAD_7,          0x9A    },
-    { KEY_EN_NUMPAD_4,          0x9B    },
-    { KEY_EN_NUMPAD_1,          0x9C    },
-    { KEY_EN_NUMPAD_0,          0x9D    },
-    { KEY_EN_NUMPAD_DIVIDE,     0xA1    },
-    { KEY_EN_NUMPAD_8,          0xA2    },
-    { KEY_EN_NUMPAD_5,          0xA3    },
-    { KEY_EN_NUMPAD_2,          0xA4    },
-    { KEY_EN_NUMPAD_TIMES,      0xA9    },
-    { KEY_EN_NUMPAD_9,          0xAA    },
-    { KEY_EN_NUMPAD_6,          0xAB    },
-    { KEY_EN_NUMPAD_3,          0xAC    },
-    { KEY_EN_NUMPAD_PERIOD,     0xAD    },
-    { KEY_EN_NUMPAD_MINUS,      0xB1    },
-    { KEY_EN_NUMPAD_PLUS,       0xB2    },
-    { KEY_EN_NUMPAD_ENTER,      0xB4    },
-};
-
-static const std::vector<led_type> default_tkl_led_names =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0x00    },
-    { KEY_EN_BACK_TICK,         0x01    },
-    { KEY_EN_TAB,               0x02    },
-    { KEY_EN_CAPS_LOCK,         0x03    },
-    { KEY_EN_LEFT_SHIFT,        0x04    },
-    { KEY_EN_LEFT_CONTROL,      0x05    },
-    { KEY_EN_ISO_BACK_SLASH,    0x0C    },
-    { KEY_EN_1,                 0x11    },
-    { KEY_EN_Q,                 0x12    },
-    { KEY_EN_A,                 0x13    },
-    { KEY_EN_Z,                 0x14    },
-    { KEY_EN_F1,                0x18    },
-    { KEY_EN_2,                 0x19    },
-    { KEY_EN_W,                 0x1A    },
-    { KEY_EN_S,                 0x1B    },
-    { KEY_EN_X,                 0x1C    },
-    { KEY_EN_F2,                0x20    },
-    { KEY_EN_3,                 0x21    },
-    { KEY_EN_E,                 0x22    },
-    { KEY_EN_D,                 0x23    },
-    { KEY_EN_C,                 0x24    },
-    { KEY_EN_F3,                0x28    },
-    { KEY_EN_4,                 0x29    },
-    { KEY_EN_R,                 0x2A    },
-    { KEY_EN_F,                 0x2B    },
-    { KEY_EN_V,                 0x2C    },
-    { KEY_EN_F4,                0x30    },
-    { KEY_EN_5,                 0x31    },
-    { KEY_EN_T,                 0x32    },
-    { KEY_EN_G,                 0x33    },
-    { KEY_EN_B,                 0x34    },
-    { KEY_EN_SPACE,             0x35    },
-    { KEY_EN_6,                 0x39    },
-    { KEY_EN_Y,                 0x3A    },
-    { KEY_EN_H,                 0x3B    },
-    { KEY_EN_N,                 0x3C    },
-    { KEY_EN_F5,                0x40    },
-    { KEY_EN_7,                 0x41    },
-    { KEY_EN_U,                 0x42    },
-    { KEY_EN_J,                 0x43    },
-    { KEY_EN_M,                 0x44    },
-    { KEY_EN_F6,                0x48    },
-    { KEY_EN_8,                 0x49    },
-    { KEY_EN_I,                 0x4A    },
-    { KEY_EN_K,                 0x4B    },
-    { KEY_EN_COMMA,             0x4C    },
-    { KEY_EN_RIGHT_ALT,         0x4D    },
-    { KEY_EN_F7,                0x50    },
-    { KEY_EN_9,                 0x51    },
-    { KEY_EN_O,                 0x52    },
-    { KEY_EN_L,                 0x53    },
-    { KEY_EN_PERIOD,            0x54    },
-    { KEY_EN_F8,                0x58    },
-    { KEY_EN_0,                 0x59    },
-    { KEY_EN_P,                 0x5A    },
-    { KEY_EN_SEMICOLON,         0x5B    },
-    { KEY_EN_FORWARD_SLASH,     0x5C    },
-    { KEY_EN_RIGHT_FUNCTION,    0x5D    },
-    { KEY_EN_F9,                0x60    },
-    { KEY_EN_MINUS,             0x61    },
-    { KEY_EN_LEFT_BRACKET,      0x62    },
-    { KEY_EN_QUOTE,             0x63    },
-    { KEY_EN_MENU,              0x65    },
-    { KEY_EN_F10,               0x68    },
-    { KEY_EN_EQUALS,            0x69    },
-    { KEY_EN_RIGHT_BRACKET,     0x6A    },
-    { KEY_EN_POUND,             0x6B    },
-    { KEY_EN_F11,               0x70    },
-    { KEY_EN_F12,               0x78    },
-    { KEY_EN_BACKSPACE,         0x79    },
-    { KEY_EN_ANSI_BACK_SLASH,   0x7A    },
-    { KEY_EN_ANSI_ENTER,        0x7B    },
-    { KEY_EN_RIGHT_SHIFT,       0x7C    },
-    { KEY_EN_RIGHT_CONTROL,     0x7D    },
-    { KEY_EN_INSERT,            0x81    },
-    { KEY_EN_DELETE,            0x82    },
-    { KEY_EN_LEFT_ARROW,        0x85    },
-    { KEY_EN_HOME,              0x89    },
-    { KEY_EN_END,               0x8A    },
-    { KEY_EN_UP_ARROW,          0x8C    },
-    { KEY_EN_DOWN_ARROW,        0x8D    },
-    { KEY_EN_PAGE_UP,           0x91    },
-    { KEY_EN_PAGE_DOWN,         0x92    },
-    { KEY_EN_RIGHT_ARROW,       0x95    },
-    { "Logo 1",                 0x80    },
-    { "Logo 2",                 0x90    },
-    { "Underglow 1",            0x06    },
-    { "Underglow 2",            0x0E    },
-    { "Underglow 3",            0x16    },
-    { "Underglow 4",            0x1E    },
-    { "Underglow 5",            0x26    },
-    { "Underglow 6",            0x2E    },
-    { "Underglow 7",            0x36    },
-    { "Underglow 8",            0x3E    },
-    { "Underglow 9",            0x46    },
-    { "Underglow 10",           0x4E    },
-    { "Underglow 11",           0x56    },
-    { "Underglow 12",           0x5E    },
-    { "Underglow 13",           0x66    },
-    { "Underglow 14",           0x6E    },
-    { "Underglow 15",           0x76    },
-    { "Underglow 16",           0x7E    },
-    { "Underglow 17",           0x86    },
-    { "Underglow 18",           0x8E    },
-    { "Underglow 19",           0x96    },
-    { "Underglow 20",           0x9E    },
-    { "Underglow 21",           0xA6    },
-    { "Underglow 22",           0xAE    },
-    { "Underglow 23",           0xB6    },
-    { "Underglow 24",           0xBE    },
-    { "Underglow 25",           0xC6    },
-    { "Underglow 26",           0xCE    },
-};
-
-static const std::vector<led_type> default_65pct_led_names =
-{
-    /* Key Label                Index  */
-    { KEY_EN_ESCAPE,            0x00    },
-    { KEY_EN_TAB,               0x01    },
-    { KEY_EN_CAPS_LOCK,         0x02    },
-    { KEY_EN_LEFT_SHIFT,        0x03    },
-    { KEY_EN_LEFT_CONTROL,      0x04    },
-    { KEY_EN_1,                 0x08    },
-    { KEY_EN_Q,                 0x09    },
-    { KEY_EN_A,                 0x0A    },
-    { KEY_EN_LEFT_WINDOWS,      0x0C    },
-    { KEY_EN_2,                 0x10    },
-    { KEY_EN_W,                 0x11    },
-    { KEY_EN_S,                 0x12    },
-    { KEY_EN_Z,                 0x13    },
-    { KEY_EN_LEFT_ALT,          0x14    },
-    { KEY_EN_3,                 0x18    },
-    { KEY_EN_E,                 0x19    },
-    { KEY_EN_D,                 0x1A    },
-    { KEY_EN_X,                 0x1B    },
-    { KEY_EN_4,                 0x20    },
-    { KEY_EN_R,                 0x21    },
-    { KEY_EN_F,                 0x22    },
-    { KEY_EN_C,                 0x23    },
-    { KEY_EN_5,                 0x28    },
-    { KEY_EN_T,                 0x29    },
-    { KEY_EN_G,                 0x2A    },
-    { KEY_EN_V,                 0x2B    },
-    { KEY_EN_6,                 0x30    },
-    { KEY_EN_Y,                 0x31    },
-    { KEY_EN_H,                 0x32    },
-    { KEY_EN_B,                 0x33    },
-    { KEY_EN_SPACE,             0x34    },
-    { KEY_EN_7,                 0x38    },
-    { KEY_EN_U,                 0x39    },
-    { KEY_EN_J,                 0x3A    },
-    { KEY_EN_N,                 0x3B    },
-    { KEY_EN_8,                 0x40    },
-    { KEY_EN_I,                 0x41    },
-    { KEY_EN_K,                 0x42    },
-    { KEY_EN_M,                 0x43    },
-    { KEY_EN_9,                 0x48    },
-    { KEY_EN_O,                 0x49    },
-    { KEY_EN_L,                 0x4A    },
-    { KEY_EN_COMMA,             0x4B    },
-    { KEY_EN_RIGHT_ALT,         0x4C    },
-    { KEY_EN_0,                 0x50    },
-    { KEY_EN_P,                 0x51    },
-    { KEY_EN_SEMICOLON,         0x52    },
-    { KEY_EN_PERIOD,            0x53    },
-    { KEY_EN_RIGHT_FUNCTION,    0x54    },
-    { KEY_EN_MINUS,             0x58    },
-    { KEY_EN_LEFT_BRACKET,      0x59    },
-    { KEY_EN_QUOTE,             0x5A    },
-    { KEY_EN_FORWARD_SLASH,     0x5B    },
-    { KEY_EN_RIGHT_CONTROL,     0x5C    },
-    { KEY_EN_EQUALS,            0x60    },
-    { KEY_EN_RIGHT_BRACKET,     0x61    },
-    { KEY_EN_RIGHT_SHIFT,       0x63    },
-    { KEY_EN_LEFT_ARROW,        0x64    },
-    { KEY_EN_BACKSPACE,         0x68    },
-    { KEY_EN_ANSI_BACK_SLASH,   0x69    },
-    { KEY_EN_ANSI_ENTER,        0x6A    },
-    { KEY_EN_UP_ARROW,          0x6B    },
-    { KEY_EN_DOWN_ARROW,        0x6C    },
-    { KEY_EN_INSERT,            0x70    },
-    { KEY_EN_DELETE,            0x71    },
-    { KEY_EN_PAGE_UP,           0x72    },
-    { KEY_EN_PAGE_DOWN,         0x73    },
-    { KEY_EN_RIGHT_ARROW,       0x74    },
-};
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Keyboard
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAsusAuraUSBKeyboards
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout)
-{
-    controller  = controller_ptr;
-    layout      = keyboard_layout;
-
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Keyboard 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_AuraKeyboard::~RGBController_AuraKeyboard()
-{
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].type == ZONE_TYPE_MATRIX)
-        {
-            delete zones[zone_idx].matrix_map;
-        }
-    }
-
-    delete controller;
-}
-
-void RGBController_AuraKeyboard::SetupZones()
-{
-    /*---------------------------------------------------------*\
-    | Set up zones                                              |
-    \*---------------------------------------------------------*/
-    std::vector<led_zone> led_zones;
-    std::vector<led_type> led_names;
-
-    switch(layout)
-    {
-        /*-----------------------------------------------------*\
-        | On the ROG Scope keyboards Ctrl key is double sized,  |
-        | so there is a layout shift                            |
-        \*-----------------------------------------------------*/
-        case SCOPE_LAYOUT:
-            led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
-
-            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
-            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
-            break;
-
-        case SCOPE_RX_LAYOUT:
-            led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&scope_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
-
-            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
-            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
-            led_names.push_back({ "Logo", 0xB0});
-            break;
-
-        case SCOPE_TKL_LAYOUT:
-            led_names = default_tkl_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 86, new matrix_map_type{6, 18, (unsigned int *)&scope_tkl_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_LINEAR, 2});
-            led_zones.push_back({"Underglow",   ZONE_TYPE_LINEAR, 26});
-
-            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x15});
-            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x1D});
-            break;
-
-        case FLARE_LAYOUT:
-            led_names = default_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 106, new matrix_map_type{6, 22, (unsigned int *)&flare_matrix_map}});
-            led_zones.push_back({"Logo",        ZONE_TYPE_SINGLE, 1});
-            led_zones.push_back({"Underglow",   ZONE_TYPE_SINGLE, 2});
-
-            led_names.insert(led_names.begin() + 7,     {KEY_EN_LEFT_WINDOWS,   0x0D});
-            led_names.insert(led_names.begin() + 12,    {KEY_EN_LEFT_ALT,       0x15});
-
-            led_names.push_back({ "Logo", 0xB8});
-            led_names.push_back({ "Left Underglow",     0xB9});
-            led_names.push_back({ "Right Underglow",    0xBA});
-            break;
-
-        case FALCHION_LAYOUT:
-            led_names = default_65pct_led_names;
-            led_zones.push_back({"Keyboard",    ZONE_TYPE_MATRIX, 68, new matrix_map_type{5, 16, (unsigned int *)&falchion_matrix_map}});
-            break;
-    }
-
-    unsigned int total_led_count = 0;
-    for(unsigned int zone_idx = 0; zone_idx < led_zones.size(); zone_idx++)
-    {
-        zone new_zone;
-        new_zone.name                   = led_zones[zone_idx].name;
-        new_zone.type                   = led_zones[zone_idx].type;
-        new_zone.leds_min               = led_zones[zone_idx].size;
-        new_zone.leds_max               = led_zones[zone_idx].size;
-        new_zone.leds_count             = led_zones[zone_idx].size;
-
-        if(led_zones[zone_idx].type == ZONE_TYPE_MATRIX)
-        {
-            new_zone.matrix_map         = led_zones[zone_idx].matrix;
-        }
-        else
-        {
-            new_zone.matrix_map         = NULL;
-        }
-
-        zones.push_back(new_zone);
-
-        total_led_count += led_zones[zone_idx].size;
-    }
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name  = led_names[led_idx].name;
-        new_led.value = led_names[led_idx].idx;
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraKeyboard::DeviceUpdateLEDs()
-{
-    std::vector<unsigned char> frame_buf;
-
-    /*---------------------------------------------------------*\
-    | Resize the frame buffer, 4 bytes per LED                  |
-    \*---------------------------------------------------------*/
-    frame_buf.resize(leds.size() * 4);
-
-    /*---------------------------------------------------------*\
-    | TODO: Send packets with multiple LED frames               |
-    \*---------------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
-    {
-        frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
-        frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
-        frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
-        frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
-    }
-
-    controller->SendDirect(leds.size(), frame_buf.data());
-}
-
-void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraKeyboard::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraKeyboard::DeviceUpdateMode()
-{
-
-}
@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraKeyboard.h         |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/19/2021   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraKeyboardController.h"
-
-enum AuraKeyboardMappingLayoutType
-{
-    FLARE_LAYOUT,
-    SCOPE_LAYOUT,
-    SCOPE_RX_LAYOUT,
-    SCOPE_TKL_LAYOUT,
-    FALCHION_LAYOUT,
-};
-
-typedef struct
-{
-    const char*         name;
-    unsigned char       idx;
-} led_type;
-
-typedef struct
-{
-    const char*         name;
-    const zone_type     type;
-    const unsigned int  size;
-    matrix_map_type*    matrix;
-} led_zone;
-
-class RGBController_AuraKeyboard : public RGBController
-{
-public:
-    RGBController_AuraKeyboard(AuraKeyboardController* controller_ptr, AuraKeyboardMappingLayoutType keyboard_layout);
-    ~RGBController_AuraKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraKeyboardController*         controller;
-    AuraKeyboardMappingLayoutType   layout;
-};
@@ -1,128 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMonitor.cpp        |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/03/2022                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMonitor.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Monitor
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectAsusAuraUSBMonitor
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura Monitor";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_LEDSTRIP;
-    description = "ASUS Aura Monitor 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_AuraMonitor::~RGBController_AuraMonitor()
-{
-    delete controller;
-}
-
-void RGBController_AuraMonitor::SetupZones()
-{
-    zone underglow_zone;
-
-    underglow_zone.name         = "Backlight";
-    underglow_zone.type         = ZONE_TYPE_LINEAR;
-    underglow_zone.leds_min     = 3;
-    underglow_zone.leds_max     = 3;
-    underglow_zone.leds_count   = 3;
-    underglow_zone.matrix_map   = NULL;
-
-    zones.push_back(underglow_zone);
-
-    for(unsigned int i = 0; i < 3; i++)
-    {
-        led underglow_led;
-
-        underglow_led.name      = "Backlight LED " + std::to_string(i + 1);
-
-        leds.push_back(underglow_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraMonitor::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraMonitor::DeviceUpdateLEDs()
-{
-    for (int i = 0; i < 3; i++)
-    {
-        unsigned char red   = RGBGetRValue(colors[i]);
-        unsigned char green = RGBGetGValue(colors[i]);
-        unsigned char blue  = RGBGetBValue(colors[i]);
-
-        controller->UpdateLed(i, red, green, blue);
-    }
-
-    controller->ApplyChanges();
-}
-
-void RGBController_AuraMonitor::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraMonitor::UpdateSingleLED(int led)
-{
-    unsigned char red   = RGBGetRValue(colors[led]);
-    unsigned char green = RGBGetGValue(colors[led]);
-    unsigned char blue  = RGBGetBValue(colors[led]);
-
-    controller->UpdateLed(led, red, green, blue);
-
-    controller->ApplyChanges();
-}
-
-void RGBController_AuraMonitor::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-
-void RGBController_AuraMonitor::DeviceUpdateMode()
-{
-    /*---------------------------------------------------------*\
-    | This device does not support Mode changing                |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraMonitor::DeviceSaveMode()
-{
-    /*---------------------------------------------------------*\
-    | This device does not support Mode saving                  |
-    \*---------------------------------------------------------*/
-}
@@ -1,34 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMonitor.h          |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 08/03/2022                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMonitorController.h"
-
-class RGBController_AuraMonitor : public RGBController
-{
-public:
-    RGBController_AuraMonitor(AuraMonitorController* controller_ptr);
-    ~RGBController_AuraMonitor();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraMonitorController*  controller;
-};
@@ -1,255 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.cpp          |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/25/2020  |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMouse.h"
-
-static std::string aura_mouse_zone_names[3]
-{
-    "Logo",
-    "Scroll Wheel",
-    "Underglow"
-};
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Mouse
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMice
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
-{
-    controller              = controller_ptr;
-
-    uint16_t pid            = controller->device_pid;
-
-    name                    = "ASUS Aura Mouse";
-    vendor                  = "ASUS";
-    type                    = DEVICE_TYPE_MOUSE;
-    description             = "ASUS Aura Mouse Device";
-    version                 = controller->GetVersion(aura_mouse_devices[pid].wireless, aura_mouse_devices[pid].version_protocol);
-    location                = controller->GetDeviceLocation();
-    serial                  = controller->GetSerialString();
-
-    std::vector<uint8_t> mm = aura_mouse_devices[pid].mouse_modes;
-
-    int mode_value          = 0;
-
-    for(std::vector<uint8_t>::iterator it = mm.begin(); it != mm.end(); it++)
-    {
-        switch(*it)
-        {
-            case AURA_MOUSE_MODE_STATIC:
-                {
-                    mode Direct;
-                    Direct.name                 = "Direct";
-                    Direct.value                = mode_value;
-                    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Direct.brightness_min       = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Direct.brightness_max       = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Direct.brightness           = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    Direct.color_mode           = MODE_COLORS_PER_LED;
-                    modes.push_back(Direct);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_BREATHING:
-                {
-                    mode Breathing;
-                    Breathing.name              = "Breathing";
-                    Breathing.value             = mode_value;
-                    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Breathing.brightness_min    = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Breathing.brightness_max    = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Breathing.brightness        = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    Breathing.color_mode        = MODE_COLORS_PER_LED;
-                    modes.push_back(Breathing);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_SPECTRUM:
-                {
-                    mode ColorCycle;
-                    ColorCycle.name             = "Spectrum Cycle";
-                    ColorCycle.value            = mode_value;
-                    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE ;
-                    ColorCycle.brightness_min   = AURA_MOUSE_BRIGHTNESS_MIN;
-                    ColorCycle.brightness_max   = AURA_MOUSE_BRIGHTNESS_MAX;
-                    ColorCycle.brightness       = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    ColorCycle.color_mode       = MODE_COLORS_NONE;
-                    modes.push_back(ColorCycle);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_WAVE:
-                {
-                    mode Wave;
-                    Wave.name                   = "Rainbow Wave";
-                    Wave.value                  = mode_value;
-                    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Wave.direction              = 0;
-                    Wave.speed_min              = aura_mouse_devices[pid].speed_min;
-                    Wave.speed_max              = aura_mouse_devices[pid].speed_max;
-                    Wave.speed                  = (aura_mouse_devices[pid].speed_min + aura_mouse_devices[pid].speed_max) / 2;
-                    Wave.brightness_min         = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Wave.brightness_max         = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Wave.brightness             = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    Wave.color_mode             = MODE_COLORS_NONE;
-                    modes.push_back(Wave);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_REACTIVE:
-                {
-                    mode Reactive;
-                    Reactive.name               = "Reactive";
-                    Reactive.value              = mode_value;
-                    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Reactive.brightness_min     = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Reactive.brightness_max     = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Reactive.brightness         = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    Reactive.color_mode         = MODE_COLORS_PER_LED;
-                    modes.push_back(Reactive);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_COMET:
-                {
-                    mode Comet;
-                    Comet.name                  = "Comet";
-                    Comet.value                 = mode_value;
-                    Comet.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    Comet.brightness_min        = AURA_MOUSE_BRIGHTNESS_MIN;
-                    Comet.brightness_max        = AURA_MOUSE_BRIGHTNESS_MAX;
-                    Comet.brightness            = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-                    Comet.direction             = 0;
-                    Comet.colors_min            = 1;
-                    Comet.colors_max            = 1;
-                    Comet.colors.resize(1);
-                    modes.push_back(Comet);
-                }
-                break;
-
-            case AURA_MOUSE_MODE_BATTERY:
-                {
-                    mode BatteryMode;
-                    BatteryMode.name            = "Battery";
-                    BatteryMode.value           = mode_value;
-                    BatteryMode.flags           = MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-                    BatteryMode.brightness_min  = AURA_MOUSE_BRIGHTNESS_MIN;
-                    BatteryMode.brightness_max  = AURA_MOUSE_BRIGHTNESS_MAX;
-                    BatteryMode.brightness      = AURA_MOUSE_BRIGHTNESS_DEFAULT;
-                    BatteryMode.color_mode      = MODE_COLORS_NONE;
-                    modes.push_back(BatteryMode);
-                }
-                break;
-        }
-        mode_value++;
-    }
-
-    SetupZones();
-}
-
-RGBController_AuraMouse::~RGBController_AuraMouse()
-{
-    delete controller;
-}
-
-void RGBController_AuraMouse::SetupZones()
-{
-    uint16_t pid                = controller->device_pid;
-
-    for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
-    {
-        zone mouse_zone;
-
-        mouse_zone.name         = aura_mouse_zone_names[*zone_it];
-        mouse_zone.type         = ZONE_TYPE_SINGLE;
-        mouse_zone.leds_min     = 1;
-        mouse_zone.leds_max     = 1;
-        mouse_zone.leds_count   = 1;
-        mouse_zone.matrix_map   = NULL;
-
-        zones.push_back(mouse_zone);
-
-        led mouse_led;
-
-        mouse_led.name          = mouse_zone.name + " LED";
-        mouse_led.value         = *zone_it;
-
-        leds.push_back(mouse_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraMouse::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AuraMouse::DeviceUpdateLEDs()
-{
-    for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
-    {
-        UpdateSingleLED(zone_index);
-    }
-}
-
-void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
-{
-    UpdateSingleLED(zone);
-}
-
-void RGBController_AuraMouse::UpdateSingleLED(int led)
-{
-    uint8_t red = RGBGetRValue(colors[led]);
-    uint8_t grn = RGBGetGValue(colors[led]);
-    uint8_t blu = RGBGetBValue(colors[led]);
-
-    controller->SendUpdate(leds[led].value, modes[active_mode].value, red, grn, blu, 0, false, 0, modes[active_mode].brightness);
-}
-
-void RGBController_AuraMouse::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraMouse::DeviceUpdateMode()
-{
-    if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
-    {
-        DeviceUpdateLEDs();
-    }
-    else
-    {
-        unsigned char red = 0;
-        unsigned char grn = 0;
-        unsigned char blu = 0;
-
-        if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-        {
-            red = RGBGetRValue(modes[active_mode].colors[0]);
-            grn = RGBGetGValue(modes[active_mode].colors[0]);
-            blu = RGBGetBValue(modes[active_mode].colors[0]);
-        }
-
-        controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
-    }
-}
-
-void RGBController_AuraMouse::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    controller->SaveMode();
-}
@@ -1,40 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMouse.h            |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 10/25/2020  |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMouseController.h"
-
-enum {
-    AURA_MOUSE_BRIGHTNESS_MIN     = 0,
-    AURA_MOUSE_BRIGHTNESS_MAX     = 4,
-    AURA_MOUSE_BRIGHTNESS_DEFAULT = 4
-};
-
-class RGBController_AuraMouse : public RGBController
-{
-public:
-    RGBController_AuraMouse(AuraMouseController* controller_ptr);
-    ~RGBController_AuraMouse();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraMouseController*  controller;
-};
@@ -1,302 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMousemat.cpp       |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/10/2022   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraMousemat.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Mousemat
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBMousemats
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura Mousemat";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_MOUSEMAT;
-    description = "ASUS Aura Mousemat Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = AURA_MOUSEMAT_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = AURA_MOUSEMAT_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min       = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    Static.brightness_max       = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    Static.brightness           = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = AURA_MOUSEMAT_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
-    Breathing.speed_min         = AURA_MOUSEMAT_SPEED_MIN;
-    Breathing.speed_max         = AURA_MOUSEMAT_SPEED_MAX;
-    Breathing.speed             = AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING;
-    Breathing.brightness_min    = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name             = "Color Cycle";
-    ColorCycle.value            = AURA_MOUSEMAT_MODE_COLOR_CYCLE;
-    ColorCycle.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.color_mode       = MODE_COLORS_NONE;
-    ColorCycle.speed_min        = AURA_MOUSEMAT_SPEED_MIN;
-    ColorCycle.speed_max        = AURA_MOUSEMAT_SPEED_MAX;
-    ColorCycle.speed            = AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE;
-    ColorCycle.brightness_min   = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    modes.push_back(ColorCycle);
-
-    mode Wave;
-    Wave.name                   = "Wave";
-    Wave.value                  = AURA_MOUSEMAT_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
-    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Wave.speed_min              = AURA_MOUSEMAT_SPEED_MIN;
-    Wave.speed_max              = AURA_MOUSEMAT_SPEED_MAX;
-    Wave.speed                  = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE;
-    Wave.brightness_min         = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    Wave.brightness_max         = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    Wave.brightness             = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    Wave.direction              = MODE_DIRECTION_LEFT;
-    Wave.colors_min             = 7;
-    Wave.colors_max             = 7;
-    Wave.colors.resize(7);
-    modes.push_back(Wave);
-
-    mode WavePlane;
-    WavePlane.name              = "Wave Plane";
-    WavePlane.value             = AURA_MOUSEMAT_MODE_WAVE_PLANE;
-    WavePlane.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE;
-    WavePlane.color_mode        = MODE_COLORS_NONE;
-    WavePlane.speed_min         = AURA_MOUSEMAT_SPEED_MIN;
-    WavePlane.speed_max         = AURA_MOUSEMAT_SPEED_MAX;
-    WavePlane.speed             = AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE;
-    WavePlane.brightness_min    = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    WavePlane.brightness_max    = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    WavePlane.brightness        = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    WavePlane.direction         = MODE_DIRECTION_LEFT;
-    modes.push_back(WavePlane);
-
-    mode Comet;
-    Comet.name                  = "Comet";
-    Comet.value                 = AURA_MOUSEMAT_MODE_COMET;
-    Comet.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE;
-    Comet.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Comet.speed_min             = AURA_MOUSEMAT_SPEED_MIN;
-    Comet.speed_max             = AURA_MOUSEMAT_SPEED_MAX;
-    Comet.speed                 = AURA_MOUSEMAT_SPEED_DEFAULT_COMET;
-    Comet.brightness_min        = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    Comet.brightness_max        = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    Comet.brightness            = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    Comet.direction             = MODE_DIRECTION_LEFT;
-    Comet.colors_min            = 1;
-    Comet.colors_max            = 1;
-    Comet.colors.resize(1);
-    modes.push_back(Comet);
-
-    mode GlowingYoyo;
-    GlowingYoyo.name            = "Glowing Yoyo";
-    GlowingYoyo.value           = AURA_MOUSEMAT_MODE_GLOWING_YOYO;
-    GlowingYoyo.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_MANUAL_SAVE;
-    GlowingYoyo.color_mode      = MODE_COLORS_NONE;
-    GlowingYoyo.speed_min       = AURA_MOUSEMAT_SPEED_MIN;
-    GlowingYoyo.speed_max       = AURA_MOUSEMAT_SPEED_MAX;
-    GlowingYoyo.speed           = AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO;
-    GlowingYoyo.brightness_min  = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    GlowingYoyo.brightness_max  = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    GlowingYoyo.brightness      = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    GlowingYoyo.direction       = MODE_DIRECTION_LEFT;
-    modes.push_back(GlowingYoyo);
-
-    mode Cross;
-    Cross.name                  = "Cross";
-    Cross.value                 = AURA_MOUSEMAT_MODE_CROSS;
-    Cross.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    Cross.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Cross.speed_min             = AURA_MOUSEMAT_SPEED_MIN;
-    Cross.speed_max             = AURA_MOUSEMAT_SPEED_MAX;
-    Cross.speed                 = AURA_MOUSEMAT_SPEED_DEFAULT_CROSS;
-    Cross.brightness_min        = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    Cross.brightness_max        = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    Cross.brightness            = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    Cross.colors_min            = 2;
-    Cross.colors_max            = 2;
-    Cross.colors.resize(2);
-    modes.push_back(Cross);
-
-    mode StarryNight;
-    StarryNight.name            = "Starry Night";
-    StarryNight.value           = AURA_MOUSEMAT_MODE_STARRY_NIGHT;
-    StarryNight.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    StarryNight.color_mode      = MODE_COLORS_MODE_SPECIFIC | MODE_COLORS_RANDOM;
-    StarryNight.speed_min       = AURA_MOUSEMAT_SPEED_MIN;
-    StarryNight.speed_max       = AURA_MOUSEMAT_SPEED_MAX;
-    StarryNight.speed           = AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT;
-    StarryNight.brightness_min  = AURA_MOUSEMAT_BRIGHTNESS_MIN;
-    StarryNight.brightness_max  = AURA_MOUSEMAT_BRIGHTNESS_MAX;
-    StarryNight.brightness      = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
-    StarryNight.colors_min      = 2;
-    StarryNight.colors_max      = 2;
-    StarryNight.colors.resize(2);
-    modes.push_back(StarryNight);
-
-    SetupZones();
-}
-
-RGBController_AuraMousemat::~RGBController_AuraMousemat()
-{
-    delete controller;
-}
-
-void RGBController_AuraMousemat::SetupZones()
-{
-    zone mousemat_zone;
-
-    mousemat_zone.name         = "Mousemat";
-    mousemat_zone.type         = ZONE_TYPE_LINEAR;
-    mousemat_zone.leds_min     = 15;
-    mousemat_zone.leds_max     = 15;
-    mousemat_zone.leds_count   = 15;
-    mousemat_zone.matrix_map   = NULL;
-
-    zones.push_back(mousemat_zone);
-
-    for(unsigned int i = 0; i < 15; i++)
-    {
-        led mousemat_led;
-
-        mousemat_led.name      = "Mousemat LED " + std::to_string(i);
-
-        leds.push_back(mousemat_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_AuraMousemat::DeviceUpdateLEDs()
-{
-    controller->UpdateLeds(std::vector<RGBColor>(colors));
-}
-
-void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraMousemat::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraMousemat::DeviceUpdateMode()
-{
-    if(modes[active_mode].value == AURA_MOUSEMAT_MODE_DIRECT)
-    {
-        DeviceUpdateLEDs();
-    }
-    else
-    {
-        int pattern = 0;
-
-        switch(modes[active_mode].value)
-        {
-            case AURA_MOUSEMAT_MODE_BREATHING:
-                if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
-                {
-                    pattern = 2;
-                }
-                else
-                {
-                    pattern = modes[active_mode].colors.size() - 1;
-                }
-                break;
-            case AURA_MOUSEMAT_MODE_WAVE:
-                pattern = modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
-                break;
-            case AURA_MOUSEMAT_MODE_WAVE_PLANE:       
-                switch(modes[active_mode].direction)
-                {
-                    case MODE_DIRECTION_LEFT:
-                        pattern = 2;
-                        break;
-                    case MODE_DIRECTION_RIGHT:
-                        pattern = 3;
-                        break;
-                    case MODE_DIRECTION_UP:
-                        pattern = 0;
-                        break;
-                    case MODE_DIRECTION_DOWN:
-                        pattern = 1;
-                        break;
-                }
-                break;
-            case AURA_MOUSEMAT_MODE_COMET:
-                pattern = modes[active_mode].direction;
-                if(pattern == MODE_DIRECTION_HORIZONTAL || pattern == MODE_DIRECTION_VERTICAL) pattern = 2;
-                break;
-            case AURA_MOUSEMAT_MODE_GLOWING_YOYO:
-                pattern = modes[active_mode].direction;
-                break;
-            case AURA_MOUSEMAT_MODE_STARRY_NIGHT:
-                pattern = 16 + (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-                break;
-            default:
-                pattern = 255;
-                break;
-        }
-
-        controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), modes[active_mode].speed, modes[active_mode].brightness, pattern);
-    }
-}
-
-void RGBController_AuraMousemat::DeviceSaveMode()
-{
-    DeviceUpdateMode();
-    controller->SaveMode();
-}
@@ -1,52 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraMousemat.h         |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 06/04/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraMousematController.h"
-
-enum
-{
-    AURA_MOUSEMAT_BRIGHTNESS_MIN                = 0,
-    AURA_MOUSEMAT_BRIGHTNESS_MAX                = 4,
-    AURA_MOUSEMAT_BRIGHTNESS_DEFAULT            = 4,
-    AURA_MOUSEMAT_SPEED_MIN                     = 127,
-    AURA_MOUSEMAT_SPEED_MAX                     = 0,
-    AURA_MOUSEMAT_SPEED_DEFAULT_STATIC          = 0,
-    AURA_MOUSEMAT_SPEED_DEFAULT_BREATHING       = 1,
-    AURA_MOUSEMAT_SPEED_DEFAULT_COLOR_CYCLE     = 1,
-    AURA_MOUSEMAT_SPEED_DEFAULT_WAVE            = 14,
-    AURA_MOUSEMAT_SPEED_DEFAULT_WAVE_PLANE      = 2,
-    AURA_MOUSEMAT_SPEED_DEFAULT_COMET           = 2,
-    AURA_MOUSEMAT_SPEED_DEFAULT_GLOWING_YOYO    = 4,
-    AURA_MOUSEMAT_SPEED_DEFAULT_CROSS           = 12,
-    AURA_MOUSEMAT_SPEED_DEFAULT_STARRY_NIGHT    = 2,
-};
-
-class RGBController_AuraMousemat : public RGBController
-{
-public:
-    RGBController_AuraMousemat(AuraMousematController* controller_ptr);
-    ~RGBController_AuraMousemat();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraMousematController* controller;
-};
@@ -1,164 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.cpp    |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraStrixEvolve.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura Strix Evolve
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBStrixEvolve
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraStrixEvolve::RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = "ASUS ROG Strix Evolve";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_MOUSE;
-    description                 = "ASUS Aura Mouse Device";
-    version                     = controller->GetVersion();
-    location                    = controller->GetDeviceLocation();
-    serial                      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = 1;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Direct.brightness_min       = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Direct.brightness_max       = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Direct.brightness           = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = 2;
-    Breathing.flags             = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.brightness_min    = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_PER_LED;
-    modes.push_back(Breathing);
-
-    mode ColorCycle;
-    ColorCycle.name             = "Spectrum Cycle";
-    ColorCycle.value            = 3;
-    ColorCycle.flags            = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
-    ColorCycle.brightness_min   = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    ColorCycle.brightness_max   = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    ColorCycle.brightness       = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
-    ColorCycle.color_mode       = MODE_COLORS_NONE;
-    modes.push_back(ColorCycle);
-
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = 4;
-    Reactive.flags              = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.brightness_min     = AURA_STRIX_EVOLVE_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = AURA_STRIX_EVOLVE_BRIGHTNESS_MAX;
-    Reactive.brightness         = AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode         = MODE_COLORS_PER_LED;
-    modes.push_back(Reactive);
-
-    SetupZones();
-}
-
-RGBController_AuraStrixEvolve::~RGBController_AuraStrixEvolve()
-{
-    delete controller;
-}
-
-void RGBController_AuraStrixEvolve::SetupZones()
-{
-    zone mouse_zone;
-
-    mouse_zone.name         = "Underglow";
-    mouse_zone.type         = ZONE_TYPE_SINGLE;
-    mouse_zone.leds_min     = 1;
-    mouse_zone.leds_max     = 1;
-    mouse_zone.leds_count   = 1;
-    mouse_zone.matrix_map   = NULL;
-
-    zones.push_back(mouse_zone);
-
-    led mouse_led;
-
-    mouse_led.name          = "Underglow";
-    mouse_led.value         = 1;
-
-    leds.push_back(mouse_led);
-
-    SetupColors();
-}
-
-void RGBController_AuraStrixEvolve::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AuraStrixEvolve::DeviceUpdateLEDs()
-{
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
-}
-
-void RGBController_AuraStrixEvolve::UpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraStrixEvolve::UpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_AuraStrixEvolve::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraStrixEvolve::DeviceUpdateMode()
-{
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
-    controller->SendUpdate(0x19, modes[active_mode].value);
-    controller->SendUpdate(0x1A, modes[active_mode].brightness);
-    controller->SendUpdate(0x1C, red);
-    controller->SendUpdate(0x1D, grn);
-    controller->SendUpdate(0x1E, blu);
-}
-
-void RGBController_AuraStrixEvolve::DeviceSaveMode()
-{
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-
-    unsigned int profile = controller->GetActiveProfile();
-
-    controller->UpdateProfile(0x19, profile, modes[active_mode].value);
-    controller->UpdateProfile(0x1A, profile, modes[active_mode].brightness);
-    controller->UpdateProfile(0x1C, profile, red);
-    controller->UpdateProfile(0x1D, profile, grn);
-    controller->UpdateProfile(0x1E, profile, blu);
-
-    controller->SendSavePacket();
-}
@@ -1,41 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraStrixEvolve.h      |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 11/30/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraStrixEvolveController.h"
-
-enum
-{
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MIN     = 0,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_MAX     = 255,
-    AURA_STRIX_EVOLVE_BRIGHTNESS_DEFAULT = 255
-};
-
-class RGBController_AuraStrixEvolve : public RGBController
-{
-public:
-    RGBController_AuraStrixEvolve(AuraStrixEvolveController* controller_ptr);
-    ~RGBController_AuraStrixEvolve();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraStrixEvolveController*  controller;
-};
@@ -1,343 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraTUFKeyboard.cpp    |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2020                        |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraTUFKeyboard.h"
-#include <vector>
-#include <cmath>
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura TUF Keyboard
-    @type USB
-    @save :white_check_mark:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraTUFUSBKeyboard
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura Keyboard";
-    vendor      = "ASUS";
-    type        = DEVICE_TYPE_KEYBOARD;
-    description = "ASUS Aura Keyboard Device";
-    version     = controller->GetVersion();
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = AURA_KEYBOARD_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = AURA_KEYBOARD_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Static.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Static.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = AURA_KEYBOARD_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Breathing.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Breathing.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Breathing.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Breathing.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 2;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Color_Cycle;
-    Color_Cycle.name            = "Spectrum Cycle";
-    Color_Cycle.value           = AURA_KEYBOARD_MODE_COLOR_CYCLE;
-    Color_Cycle.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Color_Cycle.speed_min       = AURA_KEYBOARD_SPEED_MIN;
-    Color_Cycle.speed_max       = AURA_KEYBOARD_SPEED_MAX;
-    Color_Cycle.speed           = AURA_KEYBOARD_SPEED_DEFAULT;
-    Color_Cycle.brightness_min  = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Color_Cycle.brightness_max  = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Color_Cycle.brightness      = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Color_Cycle.color_mode      = MODE_COLORS_NONE;
-    modes.push_back(Color_Cycle);
-
-    mode Wave;
-    Wave.name                   = "Rainbow Wave";
-    Wave.value                  = AURA_KEYBOARD_MODE_WAVE;
-    Wave.flags                  = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Wave.speed_min              = AURA_KEYBOARD_SPEED_MIN;
-    Wave.speed_max              = AURA_KEYBOARD_SPEED_MAX;
-    Wave.speed                  = AURA_KEYBOARD_SPEED_DEFAULT;
-    Wave.brightness_min         = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Wave.brightness_max         = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Wave.brightness             = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Wave.direction              = MODE_DIRECTION_LEFT;
-    Wave.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Wave.colors_min             = 1;
-    Wave.colors_max             = 7;
-    Wave.colors.resize(7);
-    modes.push_back(Wave);
-
-    mode Ripple;
-    Ripple.name                 = "Ripple";
-    Ripple.value                = AURA_KEYBOARD_MODE_RIPPLE;
-    Ripple.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Ripple.speed_min            = AURA_KEYBOARD_SPEED_MIN;
-    Ripple.speed_max            = AURA_KEYBOARD_SPEED_MAX;
-    Ripple.speed                = AURA_KEYBOARD_SPEED_DEFAULT;
-    Ripple.brightness_min       = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Ripple.brightness_max       = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Ripple.brightness           = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Ripple.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    Ripple.colors_min           = 1;
-    Ripple.colors_max           = 8;
-    Ripple.colors.resize(7);
-    modes.push_back(Ripple);
-
-    mode Reactive;
-    Reactive.name               = "Reactive";
-    Reactive.value              = AURA_KEYBOARD_MODE_REACTIVE;
-    Reactive.flags              = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Reactive.speed_min          = AURA_KEYBOARD_SPEED_MIN;
-    Reactive.speed_max          = AURA_KEYBOARD_SPEED_MAX;
-    Reactive.speed              = AURA_KEYBOARD_SPEED_DEFAULT;
-    Reactive.brightness_min     = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Reactive.brightness_max     = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Reactive.brightness         = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Reactive.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Reactive.colors_min         = 1;
-    Reactive.colors_max         = 2;
-    Reactive.colors.resize(1);
-    modes.push_back(Reactive);
-
-    mode Starry_Night;
-    Starry_Night.name           = "Starry Night";
-    Starry_Night.value          = AURA_KEYBOARD_MODE_STARRY_NIGHT;
-    Starry_Night.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Starry_Night.speed_min      = AURA_KEYBOARD_SPEED_MIN;
-    Starry_Night.speed_max      = AURA_KEYBOARD_SPEED_MAX;
-    Starry_Night.speed          = AURA_KEYBOARD_SPEED_DEFAULT;
-    Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Starry_Night.brightness     = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Starry_Night.color_mode     = MODE_COLORS_MODE_SPECIFIC;
-    Starry_Night.colors_min     = 1;
-    Starry_Night.colors_max     = 3;
-    Starry_Night.colors.resize(1);
-    modes.push_back(Starry_Night);
-
-    mode Quicksand;
-    Quicksand.name              = "Quicksand";
-    Quicksand.value             = AURA_KEYBOARD_MODE_QUICKSAND;
-    Quicksand.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Quicksand.direction         = MODE_DIRECTION_DOWN;
-    Quicksand.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Quicksand.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Quicksand.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Quicksand.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Quicksand.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Quicksand.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Quicksand.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Quicksand.colors_min        = 6;
-    Quicksand.colors_max        = 6;
-    Quicksand.colors.resize(6);
-    modes.push_back(Quicksand);
-
-    mode Current;
-    Current.name                = "Current";
-    Current.value               = AURA_KEYBOARD_MODE_CURRENT;
-    Current.flags               = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Current.speed_min           = AURA_KEYBOARD_SPEED_MIN;
-    Current.speed_max           = AURA_KEYBOARD_SPEED_MAX;
-    Current.speed               = AURA_KEYBOARD_SPEED_DEFAULT;
-    Current.brightness_min      = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Current.brightness_max      = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Current.brightness          = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Current.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Current.colors_min          = 1;
-    Current.colors_max          = 3;
-    Current.colors.resize(1);
-    modes.push_back(Current);
-
-    mode Rain_Drop;
-    Rain_Drop.name              = "Rain Drop";
-    Rain_Drop.value             = AURA_KEYBOARD_MODE_RAIN_DROP;
-    Rain_Drop.flags             = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
-    Rain_Drop.speed_min         = AURA_KEYBOARD_SPEED_MIN;
-    Rain_Drop.speed_max         = AURA_KEYBOARD_SPEED_MAX;
-    Rain_Drop.speed             = AURA_KEYBOARD_SPEED_DEFAULT;
-    Rain_Drop.brightness_min    = AURA_KEYBOARD_BRIGHTNESS_MIN;
-    Rain_Drop.brightness_max    = AURA_KEYBOARD_BRIGHTNESS_MAX;
-    Rain_Drop.brightness        = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
-    Rain_Drop.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Rain_Drop.colors_min        = 1;
-    Rain_Drop.colors_max        = 3;
-    Rain_Drop.colors.resize(1);
-    modes.push_back(Rain_Drop);
-
-    SetupZones();
-}
-
-RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
-{
-    delete controller;
-}
-
-void RGBController_AuraTUFKeyboard::SetupZones()
-{
-    int layout = controller->GetLayout();
-
-    if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
-    {
-        layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
-    }
-    else
-    {
-        layout = layout % 100;
-    }
-
-    unsigned int total_led_count = 0;
-
-    int zone_size = 138;
-
-    zone keyboard;
-    keyboard.name               = "Keyboard";
-    keyboard.type               = ZONE_TYPE_MATRIX;
-    keyboard.leds_min           = zone_size;
-    keyboard.leds_max           = zone_size;
-    keyboard.leds_count         = zone_size;
-    keyboard.matrix_map         = new matrix_map_type;
-    keyboard.matrix_map->height = 6;
-    keyboard.matrix_map->width  = 23;
-    keyboard.matrix_map->map    = AsusTUFK7Layouts[layout].matrix_map;
-    zones.push_back(keyboard);
-
-    total_led_count += zone_size;
-
-
-    for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
-{
-
-}
-
-void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
-{
-    DeviceUpdateMode();
-}
-
-void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
-{
-    controller->UpdateLeds(colors);
-}
-
-void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
-{
-    unsigned char red   = RGBGetRValue(colors[led]);
-    unsigned char green = RGBGetGValue(colors[led]);
-    unsigned char blue  = RGBGetBValue(colors[led]);
-
-    controller->UpdateSingleLed(led, red, green, blue);
-}
-
-void RGBController_AuraTUFKeyboard::SetCustomMode()
-{
-    active_mode = 0;
-}
-
-void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
-{   
-    unsigned char color_mode;
-    std::vector<RGBColor> mode_colors;
-
-    if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
-    {
-        controller->UpdateLeds(colors);
-    }
-    else
-    {
-        bool mode_with_double = (modes[active_mode].value == 1 || modes[active_mode].value == 3 || modes[active_mode].value == 6 || modes[active_mode].value == 8 || modes[active_mode].value == 9);
-
-        if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && mode_with_double && modes[active_mode].colors.size() > 1)
-        {
-            if(modes[active_mode].colors[1] == 000)
-            {
-                color_mode = 0;
-            }
-            else
-            {
-                color_mode = 16;
-            }
-        }
-        else
-        {
-            color_mode = modes[active_mode].color_mode == MODE_COLORS_RANDOM ? 1 : 0;
-        }
-
-        int direction = 0;
-
-        switch (modes[active_mode].direction)
-        {
-            case MODE_DIRECTION_LEFT:
-                direction = 0;
-                break;
-            case MODE_DIRECTION_RIGHT:
-                direction = 4;
-                break;
-            case MODE_DIRECTION_UP:
-                direction = 6;
-                break;
-            case MODE_DIRECTION_DOWN:
-                direction = 2;
-                break;
-            case MODE_DIRECTION_HORIZONTAL:
-                direction = 8;
-                break;
-            case MODE_DIRECTION_VERTICAL:
-                direction = 1;
-                break;
-        }
-
-        mode_colors = modes[active_mode].color_mode == MODE_COLORS_PER_LED ? std::vector<RGBColor>(colors) : std::vector<RGBColor>(modes[active_mode].colors);
-
-        controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
-    }
-}
-
-void RGBController_AuraTUFKeyboard::DeviceSaveMode()
-{
-    controller->ClearResponses();
-    DeviceUpdateMode();
-    controller->AwaitResponse();
-    controller->SaveMode();
-}
@@ -1,44 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraTUFKeyboard.h      |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Mola19 03/03/2021                        |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraTUFKeyboardController.h"
-
-enum
-{
-    AURA_KEYBOARD_SPEED_MIN          = 0,
-    AURA_KEYBOARD_SPEED_MAX          = 15,
-    AURA_KEYBOARD_SPEED_DEFAULT      = 8,
-    AURA_KEYBOARD_BRIGHTNESS_MIN     = 0,
-    AURA_KEYBOARD_BRIGHTNESS_MAX     = 4,
-    AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
-};
-
-class RGBController_AuraTUFKeyboard : public RGBController
-{
-public:
-    RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr);
-    ~RGBController_AuraTUFKeyboard();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-    void        DeviceSaveMode();
-
-private:
-    AuraTUFKeyboardController*  controller;
-};
@@ -1,277 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.cpp            |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController_AsusAuraUSB.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus Aura USB
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
-    @comment The Asus AUra USB controller applies to most AMD and
-        Intel mainboards from the x470 and z390 chipsets onwards.
-\*-------------------------------------------------------------------*/
-
-RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
-    initializedMode(false)
-{
-    controller  = controller_ptr;
-
-    name        = "ASUS Aura USB";
-    vendor      = "ASUS";
-    version     = controller->GetDeviceName();
-    type        = DEVICE_TYPE_MOTHERBOARD;
-    description = "ASUS Aura USB Device";
-    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();
-
-    mode Direct;
-    Direct.name       = "Direct";
-    Direct.value      = AURA_MODE_DIRECT;
-    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Off;
-    Off.name       = "Off";
-    Off.value      = AURA_MODE_OFF;
-    Off.flags      = 0;
-    Off.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    mode Static;
-    Static.name       = "Static";
-    Static.value      = AURA_MODE_STATIC;
-    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min = 1;
-    Static.colors_max = 1;
-    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Static.colors.resize(1);
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name       = "Breathing";
-    Breathing.value      = AURA_MODE_BREATHING;
-    Breathing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.colors_min = 1;
-    Breathing.colors_max = 1;
-    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors.resize(1);
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name       = "Flashing";
-    Flashing.value      = AURA_MODE_FLASHING;
-    Flashing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flashing.colors_min = 1;
-    Flashing.colors_max = 1;
-    Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Flashing.colors.resize(1);
-    modes.push_back(Flashing);
-
-    mode SpectrumCycle;
-    SpectrumCycle.name       = "Spectrum Cycle";
-    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags      = 0;
-    SpectrumCycle.color_mode = MODE_COLORS_NONE;
-    modes.push_back(SpectrumCycle);
-
-    mode Rainbow;
-    Rainbow.name       = "Rainbow";
-    Rainbow.value      = AURA_MODE_RAINBOW;
-    Rainbow.flags      = 0;
-    Rainbow.color_mode = MODE_COLORS_NONE;
-    modes.push_back(Rainbow);
-
-    mode ChaseFade;
-    ChaseFade.name       = "Chase Fade";
-    ChaseFade.value      = AURA_MODE_CHASE_FADE;
-    ChaseFade.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    ChaseFade.colors_min = 1;
-    ChaseFade.colors_max = 1;
-    ChaseFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    ChaseFade.colors.resize(1);
-    modes.push_back(ChaseFade);
-
-    mode Chase;
-    Chase.name       = "Chase";
-    Chase.value      = AURA_MODE_CHASE;
-    Chase.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Chase.colors_min = 1;
-    Chase.colors_max = 1;
-    Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
-    Chase.colors.resize(1);
-    modes.push_back(Chase);
-
-    SetupZones();
-}
-
-RGBController_AuraUSB::~RGBController_AuraUSB()
-{
-    delete controller;
-}
-
-void RGBController_AuraUSB::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Only set LED count on the first run               |
-    \*-------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-    zones.resize(controller->GetChannelCount());
-
-    /*-------------------------------------------------*\
-    | Set zones and leds                                |
-    \*-------------------------------------------------*/
-    int addressableCounter = 1;
-    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
-    {
-        AuraDeviceInfo device_info  = controller->GetAuraDevices()[channel_idx];
-
-        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
-
-        if(device_info.device_type == AuraDeviceType::FIXED)
-        {
-            zones[channel_idx].name       = "Aura Mainboard";
-            zones[channel_idx].leds_min   = device_info.num_leds;
-            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds;
-        }
-        else
-        {
-            zones[channel_idx].name       = "Aura Addressable ";
-            zones[channel_idx].name.append(std::to_string(addressableCounter));
-            zones[channel_idx].leds_min   = 0;
-            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
-
-            addressableCounter++;
-
-            if(first_run)
-            {
-                zones[channel_idx].leds_count = 0;
-            }
-        }
-
-        unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
-        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
-        {
-            unsigned led_idx = led_ch_idx + 1;
-            led new_led;
-
-            new_led.name = zones[channel_idx].name;
-            if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
-            {
-                new_led.name.append(", RGB Header ");
-                led_idx -= num_mainboard_leds;
-            }
-            else
-            {
-                new_led.name.append(", LED ");
-            }
-            new_led.name.append(std::to_string(led_idx));
-
-            new_led.value = channel_idx;
-
-            leds.push_back(new_led);
-        }
-
-        zones[channel_idx].matrix_map = NULL;
-    }
-
-    SetupColors();
-}
-
-void RGBController_AuraUSB::ResizeZone(int zone, int new_size)
-{
-    if((size_t) zone >= zones.size())
-    {
-        return;
-    }
-
-    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
-    {
-        zones[zone].leds_count = new_size;
-
-        SetupZones();
-    }
-}
-
-void RGBController_AuraUSB::DeviceUpdateLEDs()
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
-    }
-}
-
-void RGBController_AuraUSB::UpdateZoneLEDs(int zone)
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-
-    controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
-}
-
-void RGBController_AuraUSB::UpdateSingleLED(int led)
-{
-    if(!initializedMode)
-    {
-        DeviceUpdateMode();
-    }
-
-    unsigned int channel = leds[led].value;
-
-    controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
-}
-
-void RGBController_AuraUSB::SetCustomMode()
-{
-
-}
-
-void RGBController_AuraUSB::DeviceUpdateMode()
-{
-    initializedMode   = true;
-    unsigned char red = 0;
-    unsigned char grn = 0;
-    unsigned char blu = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        red = RGBGetRValue(modes[active_mode].colors[0]);
-        grn = RGBGetGValue(modes[active_mode].colors[0]);
-        blu = RGBGetBValue(modes[active_mode].colors[0]);
-    }
-
-    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        if(zones[zone_idx].leds_count > 0)
-        {
-            controller->SetMode(zone_idx, modes[active_mode].value, red, grn, blu);
-        }
-    }
-}
@@ -1,38 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AsusAuraUSB.h              |
-|                                           |
-|  Generic RGB Interface for Asus Aura      |
-|  USB controller driver                    |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/18/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-#include "AsusAuraUSBController.h"
-
-#define AURA_ADDRESSABLE_MAX_LEDS       120
-
-class RGBController_AuraUSB : public RGBController
-{
-public:
-    RGBController_AuraUSB(AuraUSBController* controller_ptr);
-    ~RGBController_AuraUSB();
-
-    void        SetupZones();
-
-    void        ResizeZone(int zone, int new_size);
-
-    void        DeviceUpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
-    void        SetCustomMode();
-    void        DeviceUpdateMode();
-
-private:
-    AuraUSBController*          controller;
-    std::vector<unsigned int>   leds_channel;
-    std::vector<unsigned int>   zones_channel;
-    bool                        initializedMode;
-};
@@ -1,231 +0,0 @@
-/*-------------------------------------------------------------------*\
-|  RGBController_ROGStrixLC_Controller.cpp                            |
-|                                                                     |
-|  Driver for the ASUS Aura Liquid Cooler (LC) series                 |
-|    of lighting controllers                                          |
-|                                                                     |
-|  Chris M (Dr_No)          17 Jan 2022                               |
-|                                                                     |
-\*-------------------------------------------------------------------*/
-
-#include "RGBControllerKeyNames.h"
-#include "RGBController_ROGStrixLC_Controller.h"
-
-/**------------------------------------------------------------------*\
-    @name Asus ROG Strix Liquid Cooler
-    @type USB
-    @save :x:
-    @direct :white_check_mark:
-    @effects :white_check_mark:
-    @detectors DetectAsusAuraUSBROGStrixLC
-    @comment
-\*-------------------------------------------------------------------*/
-
-RGBController_ROGStrixLC_Controller::RGBController_ROGStrixLC_Controller(ROGStrixLC_Controller *controller_ptr)
-{
-    controller                  = controller_ptr;
-    uint8_t speed               = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
-
-    name                        = "ROG Strix LC";
-    vendor                      = "ASUS";
-    type                        = DEVICE_TYPE_COOLER;
-    description                 = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";
-    version                     = KEY_EN_UNUSED;
-    serial                      = KEY_EN_UNUSED;
-    location                    = controller->GetLocation();
-
-    mode Direct;
-    Direct.name                 = "Direct";
-    Direct.value                = ROGSTRIXLC_CONTROLLER_MODE_DIRECT;
-    Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
-
-    mode Static;
-    Static.name                 = "Static";
-    Static.value                = ROGSTRIXLC_CONTROLLER_MODE_STATIC;
-    Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Static.colors_min           = 1;
-    Static.colors_max           = 1;
-    Static.colors.resize(Static.colors_max);
-    Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
-    modes.push_back(Static);
-
-    mode Breathing;
-    Breathing.name              = "Breathing";
-    Breathing.value             = ROGSTRIXLC_CONTROLLER_MODE_BREATHING;
-    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.colors_min        = 1;
-    Breathing.colors_max        = 1;
-    Breathing.colors.resize(Breathing.colors_max);
-    Breathing.brightness_min    = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
-    Breathing.brightness_max    = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Breathing.brightness        = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Breathing.speed_min         = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
-    Breathing.speed_max         = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
-    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed             = speed;
-    modes.push_back(Breathing);
-
-    mode Flashing;
-    Flashing.name               = "Flashing";
-    Flashing.value              = ROGSTRIXLC_CONTROLLER_MODE_FLASHING;
-    Flashing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Flashing.colors_min         = 1;
-    Flashing.colors_max         = 1;
-    Flashing.colors.resize(Flashing.colors_max);
-    Flashing.brightness_min     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
-    Flashing.brightness_max     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Flashing.brightness         = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Flashing.speed_min          = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
-    Flashing.speed_max          = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
-    Flashing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    Flashing.speed              = speed;
-    modes.push_back(Flashing);
-
-    mode Spectrum;
-    Spectrum.name               = "Spectrum";
-    Spectrum.value              = ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM;
-    Spectrum.flags              = MODE_FLAG_HAS_SPEED;
-    Spectrum.brightness_min     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
-    Spectrum.brightness_max     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Spectrum.brightness         = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Spectrum.speed_min          = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
-    Spectrum.speed_max          = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
-    Spectrum.color_mode         = MODE_COLORS_NONE;
-    Spectrum.speed              = speed;
-    modes.push_back(Spectrum);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow";
-    Rainbow.value               = ROGSTRIXLC_CONTROLLER_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    Rainbow.brightness_min      = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
-    Rainbow.brightness_max      = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Rainbow.brightness          = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    Rainbow.speed_min           = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
-    Rainbow.speed_max           = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
-    Rainbow.color_mode          = MODE_COLORS_NONE;
-    Rainbow.speed               = speed;
-    modes.push_back(Rainbow);
-
-    mode FlashAndDash;
-    FlashAndDash.name           = "Flash and Dash";
-    FlashAndDash.value          = ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH;
-    FlashAndDash.flags          = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
-    FlashAndDash.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
-    FlashAndDash.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    FlashAndDash.brightness     = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
-    FlashAndDash.speed_min      = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
-    FlashAndDash.speed_max      = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
-    FlashAndDash.color_mode     = MODE_COLORS_NONE;
-    FlashAndDash.speed          = speed;
-    modes.push_back(FlashAndDash);
-
-    SetupZones();
-}
-
-RGBController_ROGStrixLC_Controller::~RGBController_ROGStrixLC_Controller()
-{
-    delete controller;
-}
-
-void RGBController_ROGStrixLC_Controller::SetupZones()
-{
-    /*-------------------------------------------------*\
-    | Set up zones                                      |
-    \*-------------------------------------------------*/
-    LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
-
-    zones.resize(controller->GetChannelCount());
-
-    LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
-        LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
-                 ((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
-                 zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
-
-        zones[zone_idx].name        = name + " Zone ";
-        zones[zone_idx].name.append(std::to_string(zone_idx));
-        zones[zone_idx].type        = ZONE_TYPE_LINEAR;
-        zones[zone_idx].leds_min    = device_info.num_leds;
-        zones[zone_idx].leds_max    = device_info.num_leds;
-        zones[zone_idx].leds_count  = device_info.num_leds;
-
-        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
-        {
-            led new_led;
-
-            new_led.name    = zones[zone_idx].name;
-            new_led.name.append(" LED " + std::to_string(lp_idx));
-            new_led.value   = lp_idx;
-
-            leds.push_back(new_led);
-        }
-    }
-
-    LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
-    SetupColors();
-}
-
-void RGBController_ROGStrixLC_Controller::ResizeZone(int zone, int new_size)
-{
-    /*---------------------------------------------------------*\
-    | This device does not support resizing zones               |
-    \*---------------------------------------------------------*/
-}
-
-void RGBController_ROGStrixLC_Controller::DeviceUpdateLEDs()
-{
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        UpdateZoneLEDs(zone_idx);
-    }
-}
-
-void RGBController_ROGStrixLC_Controller::UpdateZoneLEDs(int zone)
-{
-    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
-}
-
-void RGBController_ROGStrixLC_Controller::UpdateSingleLED(int led)
-{
-    UpdateZoneLEDs(GetLED_Zone(led));
-}
-
-void RGBController_ROGStrixLC_Controller::SetCustomMode()
-{
-    for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
-    {
-        if (modes[mode_idx].value == ROGSTRIXLC_CONTROLLER_MODE_DIRECT)
-        {
-            active_mode = mode_idx;
-            break;
-        }
-    }
-}
-
-void RGBController_ROGStrixLC_Controller::DeviceUpdateMode()
-{
-    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
-
-    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour );
-}
-
-int RGBController_ROGStrixLC_Controller::GetLED_Zone(int led_idx)
-{
-    for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        int zone_start  = zones[zone_idx].start_idx;
-        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
-
-        if( zone_start <= led_idx && zone_end >= led_idx)
-        {
-            return(zone_idx);
-        }
-    }
-
-    return -1;
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Honse	8b9c4ec68c	More poseidon z rework	2020-02-02 19:10:49 -06:00
Adam Honse	af7c185e43	Poseidon z rework in progress	2020-01-28 20:27:31 -06:00