Add option for introducing a delay (in milliseconds) between direct mode LED packets for the QMK OpenRGB protocol

Commits squashed and amended for code style by Adam Honse <[email protected]>

60-openrgb.rules

@@ -348,6 +348,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uacces
 #       Logitech G810 #2                                        #
 #       Logitech G813                                           #
 #       Logitech G815                                           #
+#       Logitech G915                                           #
 #                                                               #
 #  Mice:                                                        #
 #       Logitech G203 Prodigy                                   #
@@ -388,6 +389,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uacces
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c232", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c335", TAG+="uaccess"          #G910
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c541", TAG+="uaccess"          #G915 Receiver
+SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33e", TAG+="uaccess"          #G915 Wired
 
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
 SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"

Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp

@@ -44,6 +44,7 @@ static const gpu_pci_device device_list[] =
     { 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_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_RTX2060S_DEV,        ASUS_SUB_VEN,       ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A,   "ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G"},

Controllers/LogitechController/LogitechControllerDetect.cpp

@@ -8,6 +8,7 @@
 #include "LogitechG810Controller.h"
 #include "LogitechG910Controller.h"
 #include "LogitechG815Controller.h"
+#include "LogitechG915Controller.h"
 #include "LogitechGLightsyncController.h"
 #include "LogitechLightspeedController.h"
 #include "LogitechX56Controller.h"
@@ -19,6 +20,7 @@
 #include "RGBController_LogitechG810.h"
 #include "RGBController_LogitechG910.h"
 #include "RGBController_LogitechG815.h"
+#include "RGBController_LogitechG915.h"
 #include "RGBController_LogitechGLightsync.h"
 #include "RGBController_LogitechGLightsync1zone.h"
 #include "RGBController_LogitechLightspeed.h"
@@ -49,6 +51,8 @@ using namespace std::chrono_literals;
 #define LOGITECH_G810_2_PID                     0xC337
 #define LOGITECH_G813_PID                       0xC232
 #define LOGITECH_G815_PID                       0xC33F
+#define LOGITECH_G915_WIRED_PID                 0xC33E
+#define LOGITECH_G915_RECEIVER_PID              0xC541
 #define LOGITECH_G910_ORION_SPARK_PID           0xC32B
 #define LOGITECH_G910_PID                       0xC335
 
@@ -314,6 +318,32 @@ void DetectLogitechKeyboardG815(hid_device_info* info, const std::string& name)
 #endif
 }
 
+void DetectLogitechKeyboardG915(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LogitechG915Controller*     controller     = new LogitechG915Controller(dev, false);
+        RGBController_LogitechG915* rgb_controller = new RGBController_LogitechG915(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+void DetectLogitechKeyboardG915Wired(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        LogitechG915Controller*     controller     = new LogitechG915Controller(dev, true);
+        RGBController_LogitechG915* rgb_controller = new RGBController_LogitechG915(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 /*-----------------------------------------------------*\
 | Logitech Mice                                         |
 \*-----------------------------------------------------*/
@@ -525,44 +555,46 @@ void DetectLogitechX56(hid_device_info* info, const std::string& name)
     }
 }
 
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Keyboards                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G213",                                  DetectLogitechKeyboardG213, LOGITECH_VID, LOGITECH_G213_PID,                    1, 0xFF43, 0x0602);
-REGISTER_HID_DETECTOR_IP ("Logitech G512",                                  DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                              DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G512_RGB_PID,                1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_1_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                            DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G610_2_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_1_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                   DetectLogitechKeyboardG810, LOGITECH_VID, LOGITECH_G810_2_PID,                  1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G813_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",   DetectLogitechKeyboardG815, LOGITECH_VID, LOGITECH_G815_PID,                    1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spark",                      DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_ORION_SPARK_PID,        1, 0xFF43);
-REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                   DetectLogitechKeyboardG910, LOGITECH_VID, LOGITECH_G910_PID,                    1, 0xFF43);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Mice                                                                                                                                              |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                          DetectLogitechMouseG203,    LOGITECH_VID, LOGITECH_G203_PID,                    1, 0xFF00);
-REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                        DetectLogitechMouseG203L,   LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
-REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                    DetectLogitechMouseG303,    LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                             DetectLogitechMouseG403,    LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G502 Proteus Spectrum Gaming Mouse",    DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G502 Hero Gaming Mouse",                DetectLogitechMouseG502PS,  LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                    DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
-REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",             DetectLogitechMouseGPRO,    LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Speakers                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                DetectLogitechG560,         LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Headsets                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                DetectLogitechG933,         LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
-/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
-| Joysticks                                                                                                                                         |
-\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
-REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Joystick",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00);
-REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Throttle",               DetectLogitechX56,          LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Keyboards                                                                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G213",                                                  DetectLogitechKeyboardG213,      LOGITECH_VID, LOGITECH_G213_PID,                    1, 0xFF43, 0x0602);
+REGISTER_HID_DETECTOR_IP ("Logitech G512",                                                  DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G512_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G512 RGB",                                              DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G512_RGB_PID,                1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                                            DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G610_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G610 Orion",                                            DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G610_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                                   DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G810_1_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G810 Orion Spectrum",                                   DetectLogitechKeyboardG810,      LOGITECH_VID, LOGITECH_G810_2_PID,                  1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G813 RGB Mechanical Gaming Keyboard",                   DetectLogitechKeyboardG815,      LOGITECH_VID, LOGITECH_G813_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G815 RGB Mechanical Gaming Keyboard",                   DetectLogitechKeyboardG815,      LOGITECH_VID, LOGITECH_G815_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spark",                                      DetectLogitechKeyboardG910,      LOGITECH_VID, LOGITECH_G910_ORION_SPARK_PID,        1, 0xFF43);
+REGISTER_HID_DETECTOR_IP ("Logitech G910 Orion Spectrum",                                   DetectLogitechKeyboardG910,      LOGITECH_VID, LOGITECH_G910_PID,                    1, 0xFF43);
+REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard",          DetectLogitechKeyboardG915,      LOGITECH_VID, LOGITECH_G915_RECEIVER_PID,           2, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IPU("Logitech G915 Wireless RGB Mechanical Gaming Keyboard (Wired)",  DetectLogitechKeyboardG915Wired, LOGITECH_VID, LOGITECH_G915_WIRED_PID,              2, 0xFF00, 2);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Mice                                                                                                                                                                                              |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP ("Logitech G203 Prodigy",                                          DetectLogitechMouseG203,         LOGITECH_VID, LOGITECH_G203_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IPU("Logitech G203 Lightsync",                                        DetectLogitechMouseG203L,        LOGITECH_VID, LOGITECH_G203_LIGHTSYNC_PID,          1, 0xFF00, 2);
+REGISTER_HID_DETECTOR_IP ("Logitech G303 Daedalus Apex",                                    DetectLogitechMouseG303,         LOGITECH_VID, LOGITECH_G303_PID,                    1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G403 Hero",                                             DetectLogitechMouseG403,         LOGITECH_VID, LOGITECH_G403_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Proteus Spectrum Gaming Mouse",                    DetectLogitechMouseG502PS,       LOGITECH_VID, LOGITECH_G502_PROTEUS_SPECTRUM_PID,   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G502 Hero Gaming Mouse",                                DetectLogitechMouseG502PS,       LOGITECH_VID, LOGITECH_G502_HERO_PID,               1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro Gaming Mouse",                                    DetectLogitechMouseGPRO,         LOGITECH_VID, LOGITECH_G_PRO_PID,                   1, 0xFF00);
+REGISTER_HID_DETECTOR_IP ("Logitech G Pro (HERO) Gaming Mouse",                             DetectLogitechMouseGPRO,         LOGITECH_VID, LOGITECH_G_PRO_HERO_PID,              1, 0xFF00);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Speakers                                                                                                                                                                                          |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G560 Lightsync Speaker",                                DetectLogitechG560,              LOGITECH_VID, LOGITECH_G560_PID,                    2, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Headsets                                                                                                                                                                                          |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IPU("Logitech G933 Lightsync Headset",                                DetectLogitechG933,              LOGITECH_VID, LOGITECH_G933_PID,                    3, 0xFF43, 514);
+/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
+| Joysticks                                                                                                                                                                                         |
+\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Joystick",                               DetectLogitechX56,               LOGITECH_X56_VID, LOGITECH_X56_JOYSTICK_PID,        2, 0xFF00);
+REGISTER_HID_DETECTOR_IP("Logitech X56 Rhino Hotas Throttle",                               DetectLogitechX56,               LOGITECH_X56_VID, LOGITECH_X56_THROTTLE_PID,        2, 0xFF00);
 
 /*---------------------------------------------------------------------------------------------------------*\
 | Windows and MacOS Lightspeed Detection                                                                    |

Controllers/LogitechController/LogitechG915Controller.cpp

@@ -0,0 +1,320 @@
+/*-----------------------------------------*\
+|  LogitechG915Controller.cpp               |
+|                                           |
+|  Generic RGB Interface for Logitech G915  |
+|  RGB Mechanical Gaming Keyboard           |
+|                                           |
+|  Cheerpipe      3/20/2021                 |
+\*-----------------------------------------*/
+
+#include "LogitechG915Controller.h"
+#include <cstring>
+
+LogitechG915Controller::LogitechG915Controller(hid_device* dev_handle, bool wired)
+{
+    this->dev_handle = dev_handle;
+
+    if(wired)
+    {
+        feature_4522_idx = 0x0E;
+        feature_8040_idx = 0x13;
+        feature_8071_idx = 0x09;
+        feature_8081_idx = 0x0A;
+    }
+    else
+    {
+        feature_4522_idx = 0x0F;
+        feature_8040_idx = 0x14;
+        feature_8071_idx = 0x0A;
+        feature_8081_idx = 0x0B;
+    }
+}
+
+LogitechG915Controller::~LogitechG915Controller()
+{
+
+}
+
+std::string LogitechG915Controller::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev_handle, 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 LogitechG915Controller::Commit()
+{
+    SendCommit();
+}
+
+void LogitechG915Controller::SetDirect
+    (
+    unsigned char       frame_type,
+    unsigned char *     frame_data
+    )
+{
+    SendDirectFrame(frame_type, frame_data);
+}
+
+void LogitechG915Controller::SetMode
+    (
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    SendMode(LOGITECH_G915_ZONE_MODE_KEYBOARD, mode, speed, red, green, blue);
+    SendMode(LOGITECH_G915_ZONE_MODE_LOGO,     mode, speed, red, green, blue);
+    SendCommit();
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void LogitechG915Controller::SendCommit()
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8081_idx;
+    usb_buf[0x03]           = LOGITECH_G915_COMMIT_BYTE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read_timeout(dev_handle,  (unsigned char *)usb_buf, 20, LOGITECH_READ_TIMEOUT);
+}
+
+void LogitechG915Controller::InitializeDirect()
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_4522_idx;
+    usb_buf[0x03]           = 0x3E;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle,  (unsigned char *)usb_buf, 20);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_4522_idx;
+    usb_buf[0x03]           = 0x1E;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle,  (unsigned char *)usb_buf, 20);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8071_idx;
+    usb_buf[0x03]           = 0x1E;
+    usb_buf[0x10]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle,  (unsigned char *)usb_buf, 20);
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8071_idx;
+    usb_buf[0x03]           = 0x1E;
+    usb_buf[0x04]           = 0x01;
+    usb_buf[0x10]           = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle,  (unsigned char *)usb_buf, 20);
+}
+
+void LogitechG915Controller::SendSingleLed
+    (
+    unsigned char       keyCode,
+    unsigned char       r,
+    unsigned char       g,
+    unsigned char       b
+    )
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up a 6F packet with a single color                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8081_idx;
+    usb_buf[0x03]           = LOGITECH_G915_ZONE_FRAME_TYPE_LITTLE;
+
+    usb_buf[0x04]           = keyCode;
+
+    usb_buf[0x05]           = r;
+    usb_buf[0x06]           = g;
+    usb_buf[0x07]           = b;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle, (unsigned char *)usb_buf, 20);
+}
+
+void LogitechG915Controller::SendDirectFrame
+    (
+    unsigned char       frame_type,
+    unsigned char *     frame_data
+    )
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8081_idx;
+    usb_buf[0x03]           = frame_type;
+
+    /*-----------------------------------------------------*\
+    | Copy in frame data                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x04], frame_data, 16);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read_timeout(dev_handle,  (unsigned char *)usb_buf, 20, LOGITECH_READ_TIMEOUT);
+}
+
+void LogitechG915Controller::SendMode
+    (
+    unsigned char       zone,
+    unsigned char       mode,
+    unsigned short      speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    char usb_buf[20];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+
+    usb_buf[0x00]           = 0x11;
+    usb_buf[0x01]           = 0x01;
+    usb_buf[0x02]           = feature_8040_idx;
+    usb_buf[0x03]           = 0x3D; //TODO: Check if it is the correct value for G915
+    usb_buf[0x04]           = zone;
+
+    usb_buf[0x05]           = mode;
+
+    usb_buf[0x06]           = red;
+    usb_buf[0x07]           = green;
+    usb_buf[0x08]           = blue;
+
+    speed = 100 * speed;
+
+    if(mode == LOGITECH_G915_MODE_CYCLE)
+    {
+        usb_buf[0x0B]       = speed >> 8;
+        usb_buf[0x0C]       = speed & 0xFF;
+        usb_buf[0x0D]       = 0x64;
+    }
+    else if(mode == LOGITECH_G915_MODE_BREATHING)
+    {
+        usb_buf[0x09]       = speed >> 8;
+        usb_buf[0x0A]       = speed & 0xFF;
+        usb_buf[0x0C]       = 0x64;
+    }
+    else
+    {
+        return;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev_handle, (unsigned char *)usb_buf, 20);
+    hid_read(dev_handle, (unsigned char *)usb_buf, 20);
+}

Controllers/LogitechController/LogitechG915Controller.h

@@ -0,0 +1,117 @@
+/*-----------------------------------------*\
+|  LogitechG915Controller.h                 |
+|                                           |
+|  Generic RGB Interface for Logitech G915  |
+|  RGB Mechanical Gaming Keyboard           |
+|                                           |
+|  Cheerpipe      3/20/2021                 |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#define LOGITECH_G915_COMMIT_BYTE       0x7F
+#define LOGITECH_READ_TIMEOUT           300     //Timeout in ms
+
+#pragma once
+
+enum
+{
+    LOGITECH_G915_ZONE_MODE_KEYBOARD        = 0x00,
+    LOGITECH_G915_ZONE_MODE_LOGO            = 0x01,
+    LOGITECH_G915_ZONE_MODE_MULTIMEDIA      = 0X02,
+    LOGITECH_G915_ZONE_MODE_GKEYS           = 0x03,
+    LOGITECH_G915_ZONE_MODE_MODIFIERS       = 0x04
+};
+
+enum
+{
+    LOGITECH_G915_ZONE_FRAME_TYPE_LITTLE    = 0x1F,
+    LOGITECH_G915_ZONE_FRAME_TYPE_BIG       = 0x6F
+};
+
+enum
+{
+    LOGITECH_G915_ZONE_DIRECT_KEYBOARD      = 0x01,
+    LOGITECH_G915_ZONE_DIRECT_MEDIA         = 0x02,
+    LOGITECH_G915_ZONE_DIRECT_LOGO          = 0x10,
+    LOGITECH_G915_ZONE_DIRECT_INDICATORS    = 0x40,
+};
+
+enum
+{
+    LOGITECH_G915_MODE_OFF                  = 0x00,
+    LOGITECH_G915_MODE_STATIC               = 0x01,
+    LOGITECH_G915_MODE_BREATHING            = 0x02,
+    LOGITECH_G915_MODE_CYCLE                = 0x03,
+    LOGITECH_G915_MODE_WAVE                 = 0x04,
+    LOGITECH_G915_MODE_DIRECT               = 0x05,
+};
+
+/*---------------------------------------------------------------------------------------------*\
+| Speed is 1000 for fast and 20000 for slow.                                                    |
+| Values are multiplied by 100 later to give lots of GUI steps.                                 |
+\*---------------------------------------------------------------------------------------------*/
+enum
+{
+    LOGITECH_G915_SPEED_SLOWEST             = 0xC8,     /* Slowest speed                       */
+    LOGITECH_G915_SPEED_NORMAL              = 0x32,     /* Normal speed                        */
+    LOGITECH_G915_SPEED_FASTEST             = 0x0A,     /* Fastest speed                       */
+};
+
+class LogitechG915Controller
+{
+public:
+    LogitechG915Controller(hid_device* dev_handle, bool wired);
+    ~LogitechG915Controller();
+
+    std::string GetSerialString();
+    void        Commit();
+    void        InitializeDirect();
+    void        SetDirect
+                    (
+                    unsigned char       frame_type,
+                    unsigned char *     frame_data
+                    );
+    void        SendSingleLed
+                    (
+                     unsigned char       keyCode,
+                     unsigned char       r,
+                     unsigned char       g,
+                     unsigned char       b
+                    );
+    void        SetMode
+                    (
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
+private:
+    hid_device* dev_handle;
+    char feature_4522_idx;
+    char feature_8040_idx;
+    char feature_8071_idx;
+    char feature_8081_idx;
+
+    void        SendDirectFrame
+                    (
+                    unsigned char       frame_type,
+                    unsigned char *     frame_data
+                    );
+
+    void        SendMode
+                    (
+                    unsigned char       zone,
+                    unsigned char       mode,
+                    unsigned short      speed,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+    void        SendCommit();
+};

Controllers/LogitechController/RGBController_LogitechG915.cpp

@@ -0,0 +1,526 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechG915.cpp           |
+|                                           |
+|  Generic RGB Interface for Logitech G915  |
+|  RGB Mechanical Gaming Keyboard           |
+|                                           |
+|  Cheerpipe      3/20/2021                 |
+\*-----------------------------------------*/
+
+#include "RGBController_LogitechG915.h"
+#include <cstring>
+#include <iterator>
+#include <map>
+
+#define NA  0xFFFFFFFF
+const size_t max_key_per_color  = 13;
+const size_t data_size          = 16;
+
+static unsigned int matrix_map[7][27] =
+    { { 110, NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  111, NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA,  NA  },
+      { NA,  NA,  37,  NA,  54,  55,  56,  57,  NA,  58,  59,  60,  61,  NA,  62,  63,  64,  65,  NA,  66,  67,  68,  NA,  106, 107, 108, 109 },
+      { 112, NA,  49,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  NA,  41,  42,  38,  NA,  NA,  69,  70,  71,  NA,  79,  80,  81,  82  },
+      { 113, NA,  39,  NA,  16,  22,  4,   17,  NA,  19,  24,  20,  8,   14,  15,  43,  44,  45,  NA,  72,  73,  74,  NA,  91,  92,  93,  83  },
+      { 114, NA,  53,  NA,  0,   18,  3,   5,   NA,  6,   7,   9,   10,  11,  47,  48,  46,  36,  NA,  NA,  NA,  NA,  NA,  88,  89,  90,  NA  },
+      { 115, NA,  99,  NA,  25,  23,  2,   21,  NA,  1,   NA,  13,  12,  50,  51,  52,  103, NA,  NA,  NA,  78,  NA,  NA,  85,  86,  87,  84  },
+      { 116, NA,  98,  101, 100, NA,  NA,  NA,  NA,  40,  NA,  NA,  NA,  NA,  104, 105, 97,  102, NA,  76,  77,  75,  NA,  94,  NA,  95,  NA  }  };
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+};
+
+static zone_type zone_types[] =
+{
+    ZONE_TYPE_MATRIX,
+};
+
+static const unsigned int zone_sizes[] =
+{
+    117,
+};
+
+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: A",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x04    },
+    { "Key: B",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x05    },
+    { "Key: C",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x06    },
+    { "Key: D",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x07    },
+    { "Key: E",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x08    },
+    { "Key: F",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x09    },
+    { "Key: G",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0A    },
+    { "Key: H",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0B    },
+    { "Key: I",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0C    },
+    { "Key: J",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0D    },
+    { "Key: K",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0E    },
+    { "Key: L",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x0F    },
+    { "Key: M",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x10    },
+    { "Key: N",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x11    },
+    { "Key: O",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x12    },
+    { "Key: P",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x13    },
+    { "Key: Q",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x14    },
+    { "Key: R",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x15    },
+    { "Key: S",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x16    },
+    { "Key: T",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x17    },
+    { "Key: U",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x18    },
+    { "Key: V",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x19    },
+    { "Key: W",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1A    },
+    { "Key: X",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1B    },
+    { "Key: Y",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1C    },
+    { "Key: Z",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1D    },
+    { "Key: 1",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1E    },
+    { "Key: 2",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x1F    },
+    { "Key: 3",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x20    },
+    { "Key: 4",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x21    },
+    { "Key: 5",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x22    },
+    { "Key: 6",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x23    },
+    { "Key: 7",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x24    },
+    { "Key: 8",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x25    },
+    { "Key: 9",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x26    },
+    { "Key: 0",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x27    },
+    { "Key: Enter",             LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x28    },
+    { "Key: Escape",            LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x29    },
+    { "Key: Backspace",         LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2A    },
+    { "Key: Tab",               LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2B    },
+    { "Key: Space",             LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2C    },
+    { "Key: -",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2D    },
+    { "Key: =",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2E    },
+    { "Key: [",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x2F    },
+    { "Key: ]",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x30    },
+    { "Key: \\ (ANSI)",         LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x31    },//ANSI only
+    { "Key: #",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x32    },//ISO only
+    { "Key: ;",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x33    },
+    { "Key: '",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x34    },
+    { "Key: `",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x35    },
+    { "Key: ,",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x36    },
+    { "Key: .",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x37    },
+    { "Key: /",                 LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x38    },
+    { "Key: Caps Lock",         LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x39    },
+    { "Key: F1",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3A    },
+    { "Key: F2",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3B    },
+    { "Key: F3",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3C    },
+    { "Key: F4",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3D    },
+    { "Key: F5",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3E    },
+    { "Key: F6",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x3F    },
+    { "Key: F7",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x40    },
+    { "Key: F8",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x41    },
+    { "Key: F9",                LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x42    },
+    { "Key: F10",               LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x43    },
+    { "Key: F11",               LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x44    },
+    { "Key: F12",               LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x45    },
+    { "Key: Print Screen",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x46    },
+    { "Key: Scroll Lock",       LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x47    },
+    { "Key: Pause/Break",       LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x48    },
+    { "Key: Insert",            LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x49    },
+    { "Key: Home",              LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4A    },
+    { "Key: Page Up",           LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4B    },
+    { "Key: Delete",            LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4C    },
+    { "Key: End",               LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4D    },
+    { "Key: Page Down",         LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4E    },
+    { "Key: Right Arrow",       LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x4F    },
+    { "Key: Left Arrow",        LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x50    },
+    { "Key: Down Arrow",        LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x51    },
+    { "Key: Up Arrow",          LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x52    },
+    { "Key: Num Lock",          LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x53    },
+    { "Key: Number Pad /",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x54    },
+    { "Key: Number Pad *",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x55    },
+    { "Key: Number Pad -",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x56    },
+    { "Key: Number Pad +",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x57    },
+    { "Key: Number Pad Enter",  LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x58    },
+    { "Key: Number Pad 1",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x59    },
+    { "Key: Number Pad 2",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5A    },
+    { "Key: Number Pad 3",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5B    },
+    { "Key: Number Pad 4",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5C    },
+    { "Key: Number Pad 5",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5D    },
+    { "Key: Number Pad 6",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5E    },
+    { "Key: Number Pad 7",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x5F    },
+    { "Key: Number Pad 8",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x60    },
+    { "Key: Number Pad 9",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x61    },
+    { "Key: Number Pad 0",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x62    },
+    { "Key: Number Pad .",      LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x63    },
+    { "Key: \\ (ISO)",          LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x64    },//ISO only
+    { "Key: Menu",              LOGITECH_G915_ZONE_DIRECT_KEYBOARD,     0x65    },
+    { "Key: Left Control",      LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE0    },
+    { "Key: Left Shift",        LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE1    },
+    { "Key: Left Alt",          LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE2    },
+    { "Key: Left Windows",      LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE3    },
+    { "Key: Right Control",     LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE4    },
+    { "Key: Right Shift",       LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE5    },
+    { "Key: Right Alt",         LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE6    },
+    { "Key: Right Windows",     LOGITECH_G915_ZONE_MODE_MODIFIERS,      0xE7    },
+    { "Key: Media Previous",    LOGITECH_G915_ZONE_DIRECT_MEDIA,        0x9E    },
+    { "Key: Media Play/Pause",  LOGITECH_G915_ZONE_DIRECT_MEDIA,        0x9B    },
+    { "Key: Media Next",        LOGITECH_G915_ZONE_DIRECT_MEDIA,        0x9D    },
+    { "Key: Media Mute",        LOGITECH_G915_ZONE_DIRECT_MEDIA,        0x9C    },
+    { "Logo",                   LOGITECH_G915_ZONE_DIRECT_LOGO,         0x01    },
+    { "Lighting",               LOGITECH_G915_ZONE_DIRECT_INDICATORS,   0x99    },
+    { "Key: G1",                LOGITECH_G915_ZONE_MODE_GKEYS,          0x01    },
+    { "Key: G2",                LOGITECH_G915_ZONE_MODE_GKEYS,          0x02    },
+    { "Key: G3",                LOGITECH_G915_ZONE_MODE_GKEYS,          0x03    },
+    { "Key: G4",                LOGITECH_G915_ZONE_MODE_GKEYS,          0x04    },
+    { "Key: G5",                LOGITECH_G915_ZONE_MODE_GKEYS,          0x05    },
+};
+
+RGBController_LogitechG915::RGBController_LogitechG915(LogitechG915Controller* logitech_ptr)
+{
+    logitech    = logitech_ptr;
+
+    name        = "Logitech G915 Keyboard Device";
+    vendor      = "Logitech";
+    type        = DEVICE_TYPE_KEYBOARD;
+    description = "Logitech G915 Keyboard Device";
+    serial      = logitech->GetSerialString();
+
+    mode Direct;
+    Direct.name                     = "Direct";
+    Direct.value                    = LOGITECH_G915_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                    = LOGITECH_G915_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 Off;
+    Off.name                        = "Off";
+    Off.value                       = LOGITECH_G915_MODE_OFF;
+    Off.flags                       = 0;
+    Off.color_mode                  = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Cycle;
+    Cycle.name                      = "Cycle";
+    Cycle.value                     = LOGITECH_G915_MODE_CYCLE;
+    Cycle.flags                     = MODE_FLAG_HAS_SPEED;
+    Cycle.color_mode                = MODE_COLORS_NONE;
+    Cycle.speed_min                 = LOGITECH_G915_SPEED_SLOWEST;
+    Cycle.speed_max                 = LOGITECH_G915_SPEED_FASTEST;
+    Cycle.speed                     = LOGITECH_G915_SPEED_NORMAL;
+    modes.push_back(Cycle);
+
+    mode Breathing;
+    Breathing.name                  = "Breathing";
+    Breathing.value                 = LOGITECH_G915_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             = LOGITECH_G915_SPEED_SLOWEST;
+    Breathing.speed_max             = LOGITECH_G915_SPEED_FASTEST;
+    Breathing.speed                 = LOGITECH_G915_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    SetupZones();
+    std::copy(colors.begin(), colors.end(),std::back_inserter(current_colors));
+}
+
+RGBController_LogitechG915::~RGBController_LogitechG915()
+{
+    /*---------------------------------------------------------*\
+    | 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;
+        }
+    }
+}
+
+void RGBController_LogitechG915::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  = 27;
+            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].zone << 8 ) + led_names[led_idx].idx;
+        leds.push_back(new_led);
+    }
+    SetupColors();
+}
+
+void RGBController_LogitechG915::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_LogitechG915::DeviceUpdateLEDs()
+{
+    std::map<RGBColor, std::vector<char>> ledsByColors;
+    std::vector<RGBColor>   new_colors;
+    unsigned char zone      = 0;
+    unsigned char idx       = 0;
+    unsigned char frame_buffer_big_mode[data_size];
+    unsigned char frame_buffer_little_mode[data_size];
+    RGBColor colorkey;
+
+    /*---------------------------------------------------------*\
+    | Freeze colors array because prepare framebuffers          |
+    | may take some time.                                       |
+    \*---------------------------------------------------------*/
+    std::copy(colors.begin(), colors.end(),std::back_inserter(new_colors));
+
+    /*---------------------------------------------------------*\
+    | Get unique colors to create mode 1F and 6F frame_buffers  |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
+    {
+        zone = ( leds[led_idx].value >> 8 );
+        idx  = ( leds[led_idx].value );
+
+        if (current_colors[led_idx]==new_colors[led_idx])
+        {
+            /*-------------------------------------------------*\
+            | Don't send if key color is not changed            |
+            \*-------------------------------------------------*/
+            continue;
+        }
+
+        switch (zone)
+        {
+            case LOGITECH_G915_ZONE_MODE_GKEYS:
+                idx = ((idx & 0x00ff) + 0xb3);
+                break;
+
+            case LOGITECH_G915_ZONE_MODE_MODIFIERS:
+                idx = ((idx & 0x00ff) - 0x78);
+                break;
+
+            case LOGITECH_G915_ZONE_DIRECT_KEYBOARD:
+                idx = ((idx & 0x00ff) - 0x03);
+                break;
+
+            case LOGITECH_G915_ZONE_DIRECT_LOGO:
+                idx = ((idx & 0x00ff) +  0xd1);
+                break;
+
+            default:
+                idx = (idx & 0x00ff);
+                break;
+        }
+
+        colorkey = new_colors[led_idx];
+
+        if (ledsByColors.count(colorkey) == 0)
+        {
+            ledsByColors.insert(std::pair<RGBColor, std::vector<char>>(colorkey, {}));
+        }
+
+        ledsByColors[colorkey].push_back(idx);
+    }
+
+    uint8_t led_in_little_frame = 0;
+    uint8_t bi                  = 0;
+    size_t frame_pos            = 3;
+    uint8_t li                  = 0;
+
+    /*---------------------------------------------------------*\
+    | Create frame_buffers of type 1F (Little, up to 4 leds     |
+    | per packet) and 6F (big, up to 13 leds per packet).       |
+    \*---------------------------------------------------------*/
+    for(std::pair<const RGBColor, std::vector<char>>& x: ledsByColors)
+    {
+        /*-----------------------------------------------------*\
+        | For colors with more than 4 keys. Better to use big   |
+        | (6F) packets to save USB transfers.                   |
+        \*-----------------------------------------------------*/
+        if(x.second.size() > 4)
+        {
+            bi = 0;
+
+            while(bi < x.second.size())
+            {
+                frame_buffer_big_mode[0] = RGBGetRValue(x.first);
+                frame_buffer_big_mode[1] = RGBGetGValue(x.first);
+                frame_buffer_big_mode[2] = RGBGetBValue(x.first);
+                frame_pos                = 3;
+
+                for(uint8_t i = 0; i < max_key_per_color; i++)
+                {
+                    if(bi + i < x.second.size())
+                    {
+                        frame_buffer_big_mode[frame_pos] = x.second[bi+i];
+                        frame_pos++;
+                    }
+                }
+
+                if (frame_pos < data_size)
+                {
+                    /*-----------------------------------------*\
+                    | Zeroing just what is needed and if needed |
+                    \*-----------------------------------------*/
+                    memset(frame_buffer_big_mode + frame_pos, 0x00, sizeof(frame_buffer_big_mode) - frame_pos);
+
+                    /*-----------------------------------------*\
+                    | End of Data byte                          |
+                    \*-----------------------------------------*/
+                    frame_buffer_big_mode[frame_pos] = 0xFF;
+                }
+
+                /*-----------------------------------------------------*\
+                | Zeroing just what is needed                           |
+                \*-----------------------------------------------------*/
+                logitech->SetDirect(LOGITECH_G915_ZONE_FRAME_TYPE_BIG, frame_buffer_big_mode);
+                bi = bi + max_key_per_color;
+            }
+        }
+        /*-----------------------------------------------------*\
+        | For colors with up to 4 keys. Use 1F packet to send   |
+        | up to 4 colors-keys combinations per packet.          |
+        \*-----------------------------------------------------*/
+        else
+        {
+            li = 0;
+
+            while(li < x.second.size())
+            {
+                frame_buffer_little_mode[led_in_little_frame*4 + 0] = x.second[li];
+                frame_buffer_little_mode[led_in_little_frame*4 + 1] = RGBGetRValue(x.first);
+                frame_buffer_little_mode[led_in_little_frame*4 + 2] = RGBGetGValue(x.first);
+                frame_buffer_little_mode[led_in_little_frame*4 + 3] = RGBGetBValue(x.first);
+                li++;
+                led_in_little_frame++;
+
+                if (led_in_little_frame == 4)
+                {
+                    /*-----------------------------------------*\
+                    | No End of Data byte if the packet is full |
+                    \*-----------------------------------------*/
+                    logitech->SetDirect(LOGITECH_G915_ZONE_FRAME_TYPE_LITTLE, frame_buffer_little_mode);
+                    led_in_little_frame=0;
+                }
+            }
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | If there is a left 1F packet with less than 4 keys, send  |
+    | it and add an End of Data byte.                           |
+    \*---------------------------------------------------------*/
+    if(led_in_little_frame > 0)
+    {
+        /*-----------------------------------------------------*\
+        | Zeroing just what is needed                           |
+        \*-----------------------------------------------------*/
+        memset(frame_buffer_little_mode + (led_in_little_frame * 4 + 1), 0x00, sizeof(frame_buffer_little_mode) - led_in_little_frame * 4);
+
+        /*-----------------------------------------------------*\
+        | Data byte                                             |
+        \*-----------------------------------------------------*/
+        frame_buffer_little_mode[led_in_little_frame*4 + 0] = 0xFF;
+
+        /*-----------------------------------------------------*\
+        | Send little frame and clear little frame buffer       |
+        \*-----------------------------------------------------*/
+        logitech->SetDirect(LOGITECH_G915_ZONE_FRAME_TYPE_LITTLE, frame_buffer_little_mode);
+    }
+    if(ledsByColors.size() > 0)
+    {
+        /*-----------------------------------------------------*\
+        | Copy the current color vector to avoid set keys that  |
+        | has not being                                         |
+        \*-----------------------------------------------------*/
+        logitech->Commit();
+        std::copy(new_colors.begin(), new_colors.end(),current_colors.begin());
+    }
+}
+
+void RGBController_LogitechG915::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechG915::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_LogitechG915::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_LogitechG915::DeviceUpdateMode()
+{
+    /*---------------------------------------------------------*\
+    | Direct mode does not send a mode packet                   |
+    | Call UpdateLEDs to send direct packet                     |
+    \*---------------------------------------------------------*/
+    if(modes[active_mode].value == LOGITECH_G915_MODE_DIRECT)
+    {
+        /*-----------------------------------------------------*\
+        | Send real direct mode initialization. I used same     |
+        | sequence as GHUB for screen capture.                  |
+        \*-----------------------------------------------------*/
+        logitech->InitializeDirect();
+
+        /*-----------------------------------------------------*\
+        | Set one key to get direct mode engaged.               |
+        \*-----------------------------------------------------*/
+        logitech->SendSingleLed(0x29,0,0,0);
+        logitech->Commit();
+        return;
+    }
+
+    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]);
+    }
+
+    logitech->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu);
+}

Controllers/LogitechController/RGBController_LogitechG915.h

@@ -0,0 +1,34 @@
+/*-----------------------------------------*\
+|  RGBController_LogitechG915.h             |
+|                                           |
+|  Generic RGB Interface for Logitech G915  |
+|  RGB Mechanical Gaming Keyboard           |
+|                                           |
+|  Cheerpipe      3/20/2021                 |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "LogitechG915Controller.h"
+
+class RGBController_LogitechG915 : public RGBController
+{
+public:
+    RGBController_LogitechG915(LogitechG915Controller* logitech_ptr);
+    ~RGBController_LogitechG915();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+    
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    LogitechG915Controller* logitech;
+    std::vector<RGBColor>   current_colors;
+};

Controllers/QMKOpenRGBController/QMKOpenRGBControllerDetect.cpp

@@ -16,6 +16,7 @@
 #include "RGBController.h"
 #include "RGBController_QMKOpenRGBRev9.h"
 #include "RGBController_QMKOpenRGBRevB.h"
+#include "LogManager.h"
 #include <hidapi/hidapi.h>
 
 /*-----------------------------------------------------*\
@@ -23,6 +24,7 @@
 \*-----------------------------------------------------*/
 #define QMK_OPENRGB_PROTOCOL_VERSION_9          0x09
 #define QMK_OPENRGB_PROTOCOL_VERSION_B          0x0B
+#define QMK_OPENRGB_PROTOCOL_VERSION_C          0x0C
 
 /*-----------------------------------------------------*\
 | Usage and Usage Page                                  |
@@ -77,14 +79,36 @@ void DetectQMKOpenRGBControllers(hid_device_info *info, const std::string&)
                 ResourceManager::get()->RegisterRGBController(rgb_controller);
                 }
                 break;
-
             case QMK_OPENRGB_PROTOCOL_VERSION_B:
                 {
                 QMKOpenRGBRevBController*     controller     = new QMKOpenRGBRevBController(dev, info->path);
-                RGBController_QMKOpenRGBRevB* rgb_controller = new RGBController_QMKOpenRGBRevB(controller);
+                RGBController_QMKOpenRGBRevB* rgb_controller = new RGBController_QMKOpenRGBRevB(controller, false);
                 ResourceManager::get()->RegisterRGBController(rgb_controller);
                 }
                 break;
+            case QMK_OPENRGB_PROTOCOL_VERSION_C:
+                {
+                QMKOpenRGBRevBController*     controller     = new QMKOpenRGBRevBController(dev, info->path);
+                RGBController_QMKOpenRGBRevB* rgb_controller = new RGBController_QMKOpenRGBRevB(controller, true);
+                ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+                break;
+            default:
+                if (version == 0)
+                {
+                    LOG_WARNING("[QMK OpenRGB] Detection failed - the detected keyboard does not have the OpenRGB protocol feature enabled! \n"
+                    "Please make sure your keyboard supports RGB Matrix, add OPENRGB_ENABLE = yes to the rules.mk inside your keymap folder, compile and flash again!");
+                }
+                else if (version < QMK_OPENRGB_PROTOCOL_VERSION_9)
+                {
+                    LOG_WARNING("[QMK OpenRGB] Detection failed - the detected keyboard is using an outdated protocol version %i. Please update to to the update to the latest version of QMK-OpenRGB! \n"
+                    "For officaly supported QMK boards grab <a href=\"https://github.com/Kasper24/QMK-OpenRGB\">url</a> \n"
+                    "For Sonix boards grab <a href=\"https://github.com/SonixQMK/qmk_firmware/tree/sn32_openrgb\">url</a>", version);
+                }
+                else if (version > QMK_OPENRGB_PROTOCOL_VERSION_C)
+                {
+                    LOG_WARNING("[QMK OpenRGB] Detection failed - the detected keyboard is using version protocol %i which is not supported by this OpenRGB build. Please update OpenRGB!", version);
+                }
         }
     }
 }

Controllers/QMKOpenRGBController/QMKOpenRGBRev9Controller.cpp

@@ -11,6 +11,8 @@
 
 #include "QMKOpenRGBRev9Controller.h"
 
+using namespace std::chrono_literals;
+
 static std::map<uint8_t, std::string> QMKKeycodeToKeynameMap
 {
     { 0, "" },                  { 1, "Right Fn" },      { 2, "" },                  { 3, "" },
@@ -85,6 +87,15 @@ QMKOpenRGBRev9Controller::QMKOpenRGBRev9Controller(hid_device *dev_handle, const
         leds_per_update = 20;
     }
 
+    if(qmk_settings.contains("delay"))
+    {
+        delay = (unsigned int)qmk_settings["delay"] * 1ms;
+    }
+    else
+    {
+        delay = 0ms;
+    }
+
     dev         = dev_handle;
     location    = path;
 
@@ -451,6 +462,11 @@ void QMKOpenRGBRev9Controller::DirectModeSetLEDs(std::vector<RGBColor> colors, u
 
         hid_write(dev, usb_buf, 65);
 
+        if(delay > 0ms)
+        {
+            std::this_thread::sleep_for(delay);
+        }
+
         leds_sent += tmp_leds_per_update;
     }
 }

Controllers/QMKOpenRGBController/QMKOpenRGBRev9Controller.h

@@ -56,6 +56,8 @@ private:
     std::string     device_name;
     std::string     device_vendor;
 
+    std::chrono::milliseconds   delay;
+
     unsigned int    total_number_of_leds;
     unsigned int    total_number_of_leds_with_empty_space;
     unsigned int    mode;

Controllers/QMKOpenRGBController/QMKOpenRGBRevBController.cpp

@@ -9,6 +9,8 @@
 
 #include "QMKOpenRGBRevBController.h"
 
+using namespace std::chrono_literals;
+
 static std::map<uint8_t, std::string> QMKKeycodeToKeynameMap
 {
     { 0, "" },                  { 1, "Right Fn" },      { 2, "" },                  { 3, "" },
@@ -83,6 +85,15 @@ QMKOpenRGBRevBController::QMKOpenRGBRevBController(hid_device *dev_handle, const
         leds_per_update = 20;
     }
 
+    if(qmk_settings.contains("delay"))
+    {
+        delay = (unsigned int)qmk_settings["delay"] * 1ms;
+    }
+    else
+    {
+        delay = 0ms;
+    }
+
     dev         = dev_handle;
     location    = path;
 
@@ -382,7 +393,7 @@ std::vector<unsigned int> QMKOpenRGBRevBController::GetEnabledModes()
     return enabled_modes;
 }
 
-void QMKOpenRGBRevBController::SetMode(hsv_t hsv_color, unsigned char mode, unsigned char speed)
+void QMKOpenRGBRevBController::SetMode(hsv_t hsv_color, unsigned char mode, unsigned char speed, bool save)
 {
     unsigned char usb_buf[QMK_OPENRGB_PACKET_SIZE];
 
@@ -401,6 +412,7 @@ void QMKOpenRGBRevBController::SetMode(hsv_t hsv_color, unsigned char mode, unsi
     usb_buf[0x04] = hsv_color.value;
     usb_buf[0x05] = mode;
     usb_buf[0x06] = speed;
+    usb_buf[0x07] = save;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
@@ -472,6 +484,11 @@ void QMKOpenRGBRevBController::DirectModeSetLEDs(std::vector<RGBColor> colors, u
 
         hid_write(dev, usb_buf, 65);
 
+        if(delay > 0ms)
+        {
+            std::this_thread::sleep_for(delay);
+        }
+
         leds_sent += tmp_leds_per_update;
     }
-}
+}

Controllers/QMKOpenRGBController/QMKOpenRGBRevBController.h

@@ -39,7 +39,7 @@ public:
     void                        GetLEDInfo(unsigned int leds_count);
     std::vector<unsigned int>   GetEnabledModes();
 
-    void            SetMode(hsv_t hsv_color, unsigned char mode, unsigned char speed);
+    void            SetMode(hsv_t hsv_color, unsigned char mode, unsigned char speed, bool save);
     void            DirectModeSetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
     void            DirectModeSetLEDs(std::vector<RGBColor> colors, unsigned int num_colors);
 
@@ -54,6 +54,8 @@ private:
     std::string     device_name;
     std::string     device_vendor;
 
+    std::chrono::milliseconds   delay;
+
     unsigned int    total_number_of_leds;
     unsigned int    total_number_of_leds_with_empty_space;
     unsigned int    mode;

Controllers/QMKOpenRGBController/RGBController_QMKOpenRGBRevB.cpp

@@ -8,9 +8,10 @@
 \*-------------------------------------------------------------------*/
 
 #include "hsv.h"
+#include "LogManager.h"
 #include "RGBController_QMKOpenRGBRevB.h"
 
-RGBController_QMKOpenRGBRevB::RGBController_QMKOpenRGBRevB(QMKOpenRGBRevBController* controller_ptr)
+RGBController_QMKOpenRGBRevB::RGBController_QMKOpenRGBRevB(QMKOpenRGBRevBController* controller_ptr, bool save)
 {
     controller  = controller_ptr;
 
@@ -26,212 +27,212 @@ RGBController_QMKOpenRGBRevB::RGBController_QMKOpenRGBRevB(QMKOpenRGBRevBControl
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_COLOR) != enabled_modes.end())
     {
-        InitializeMode("Static", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Static", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_ALPHA_MOD) != enabled_modes.end())
     {
-        InitializeMode("Alpha Mod", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Alpha Mod", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_GRADIENT_UP_DOWN) != enabled_modes.end())
     {
-        InitializeMode("Gradient Up Down", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Gradient Up Down", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_GRADIENT_LEFT_RIGHT) != enabled_modes.end())
     {
-        InitializeMode("Gradient Left Right", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Gradient Left Right", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BREATHING) != enabled_modes.end())
     {
-        InitializeMode("Breathing", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Breathing", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_SAT) != enabled_modes.end())
     {
-        InitializeMode("Band Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_VAL) != enabled_modes.end())
     {
-        InitializeMode("Band Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_PINWHEEL_SAT) != enabled_modes.end())
     {
-        InitializeMode("Band Pinwheel Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Pinwheel Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_PINWHEEL_VAL) != enabled_modes.end())
     {
-        InitializeMode("Band Pinwheel Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Pinwheel Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_SPIRAL_SAT) != enabled_modes.end())
     {
-        InitializeMode("Band Spiral Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Spiral Saturation", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_BAND_SPIRAL_VAL) != enabled_modes.end())
     {
-        InitializeMode("Band Spiral Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Band Spiral Value", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_ALL) != enabled_modes.end())
     {
-        InitializeMode("Cycle All", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle All", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_LEFT_RIGHT) != enabled_modes.end())
     {
-        InitializeMode("Cycle Left Right", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Left Right", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_UP_DOWN) != enabled_modes.end())
     {
-        InitializeMode("Cycle Up Down", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Up Down", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_OUT_IN) != enabled_modes.end())
     {
-        InitializeMode("Cycle Out In", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Out In", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_OUT_IN_DUAL) != enabled_modes.end())
     {
-        InitializeMode("Cycle Out In Dual", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Out In Dual", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_RAINBOW_MOVING_CHEVRON) != enabled_modes.end())
     {
-        InitializeMode("Rainbow Moving Chevron", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Rainbow Moving Chevron", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_PINWHEEL) != enabled_modes.end())
     {
-        InitializeMode("Cycle Pinwheel", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Pinwheel", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_CYCLE_SPIRAL) != enabled_modes.end())
     {
-        InitializeMode("Cycle Spiral", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Cycle Spiral", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_DUAL_BEACON) != enabled_modes.end())
     {
-        InitializeMode("Dual Beacon", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Dual Beacon", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_RAINBOW_BEACON) != enabled_modes.end())
     {
-        InitializeMode("Rainbow Beacon", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Rainbow Beacon", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_RAINBOW_PINWHEELS) != enabled_modes.end())
     {
-        InitializeMode("Rainbow Pinwheels", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Rainbow Pinwheels", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_RAINDROPS) != enabled_modes.end())
     {
-        InitializeMode("Raindrops", current_mode, 0, MODE_COLORS_NONE);
+        InitializeMode("Raindrops", current_mode, 0, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_JELLYBEAN_RAINDROPS) != enabled_modes.end())
     {
-        InitializeMode("Jellybean Raindrops", current_mode, 0, MODE_COLORS_NONE);
+        InitializeMode("Jellybean Raindrops", current_mode, 0, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_HUE_BREATHING) != enabled_modes.end())
     {
-        InitializeMode("Hue Breathing", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Hue Breathing", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_HUE_PENDULUM) != enabled_modes.end())
     {
-        InitializeMode("Hue Pendulum", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Hue Pendulum", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_HUE_WAVE) != enabled_modes.end())
     {
-        InitializeMode("Hue Wave", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Hue Wave", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_TYPING_HEATMAP) != enabled_modes.end())
     {
-        InitializeMode("Typing Heatmap", current_mode, 0, MODE_COLORS_NONE);
+        InitializeMode("Typing Heatmap", current_mode, 0, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_DIGITAL_RAIN) != enabled_modes.end())
     {
-        InitializeMode("Digital Rain", current_mode, 0, MODE_COLORS_NONE);
+        InitializeMode("Digital Rain", current_mode, 0, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_SIMPLE) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Simple", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Simple", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_WIDE) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Wide", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Wide", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_MULTIWIDE) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Multi Wide", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Multi Wide", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_CROSS) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Cross", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Cross", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_MULTICROSS) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Multi Cross", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Multi Cross", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_NEXUS) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Nexus", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Nexus", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_REACTIVE_MULTINEXUS) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Multi Nexus", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Multi Nexus", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SPLASH) != enabled_modes.end())
     {
-        InitializeMode("Rainbow Reactive Splash", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Rainbow Reactive Splash", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_MULTISPLASH) != enabled_modes.end())
     {
-        InitializeMode("Rainbow Reactive Multi Splash", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE);
+        InitializeMode("Rainbow Reactive Multi Splash", current_mode, MODE_FLAG_HAS_SPEED, MODE_COLORS_NONE, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_SPLASH) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Splash", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Splash", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_SOLID_MULTISPLASH) != enabled_modes.end())
     {
-        InitializeMode("Solid Reactive Multi Splash", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC);
+        InitializeMode("Solid Reactive Multi Splash", current_mode, MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED, MODE_COLORS_MODE_SPECIFIC, save);
     }
 
     if(std::find(enabled_modes.begin(), enabled_modes.end(), QMK_OPENRGB_MODE_OPENRGB_DIRECT) != enabled_modes.end())
     {
-        InitializeMode("Direct", current_mode, MODE_FLAG_HAS_PER_LED_COLOR, MODE_COLORS_PER_LED);
+        InitializeMode("Direct", current_mode, MODE_FLAG_HAS_PER_LED_COLOR, MODE_COLORS_PER_LED, save);
     }
 
     /*-----------------------------------------------------*\
@@ -430,11 +431,11 @@ void RGBController_QMKOpenRGBRevB::DeviceUpdateMode()
 {
     if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
     {
-        controller->SetMode({ 0, 255, 255 }, modes[active_mode].value, 127);
+        controller->SetMode({ 0, 255, 255 }, modes[active_mode].value, 127, false);
     }
     else if(modes[active_mode].color_mode == MODE_COLORS_NONE)
     {
-        controller->SetMode({ 0, 255, 255 }, modes[active_mode].value, modes[active_mode].speed);
+        controller->SetMode({ 0, 255, 255 }, modes[active_mode].value, modes[active_mode].speed, false);
     }
     else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
     {
@@ -444,11 +445,34 @@ void RGBController_QMKOpenRGBRevB::DeviceUpdateMode()
 
         if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
         {
-            controller->SetMode(hsv_color, modes[active_mode].value, modes[active_mode].speed);
+            controller->SetMode(hsv_color, modes[active_mode].value, modes[active_mode].speed, false);
         }
         else
         {
-            controller->SetMode(hsv_color, modes[active_mode].value, 127);
+            controller->SetMode(hsv_color, modes[active_mode].value, 127, false);
+        }
+    }
+}
+
+void RGBController_QMKOpenRGBRevB::DeviceSaveMode()
+{
+    if(modes[active_mode].color_mode == MODE_COLORS_NONE)
+    {
+        controller->SetMode({ 0, 255, 255 }, modes[active_mode].value, modes[active_mode].speed, true);
+    }
+    else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        RGBColor rgb_color = modes[active_mode].colors[0];
+        hsv_t hsv_color;
+        rgb2hsv(rgb_color, &hsv_color);
+
+        if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+        {
+            controller->SetMode(hsv_color, modes[active_mode].value, modes[active_mode].speed, true);
+        }
+        else
+        {
+            controller->SetMode(hsv_color, modes[active_mode].value, 127, true);
         }
     }
 }
@@ -458,7 +482,8 @@ void RGBController_QMKOpenRGBRevB::InitializeMode
     std::string name,
     unsigned int &current_mode,
     unsigned int flags,
-    unsigned int color_mode
+    unsigned int color_mode,
+    bool save
     )
 {
     mode qmk_mode;
@@ -491,6 +516,13 @@ void RGBController_QMKOpenRGBRevB::InitializeMode
     }
     else
     {
+        /*-----------------------------------------------------*\
+        | Every mode apart from direct is save-able             |
+        \*-----------------------------------------------------*/
+        if(save == true)
+        {
+            qmk_mode.flags = flags | MODE_FLAG_MANUAL_SAVE;
+        }
         modes.push_back(qmk_mode);
     }
 }

Controllers/QMKOpenRGBController/RGBController_QMKOpenRGBRevB.h

@@ -23,7 +23,7 @@ typedef std::vector<std::vector<unsigned int>> VectorMatrix;
 class RGBController_QMKOpenRGBRevB : public RGBController
 {
 public:
-    RGBController_QMKOpenRGBRevB(QMKOpenRGBRevBController* controller_ptr);
+    RGBController_QMKOpenRGBRevB(QMKOpenRGBRevBController* controller_ptr, bool save);
     ~RGBController_QMKOpenRGBRevB();
 
     void                                    SetupZones();
@@ -35,6 +35,7 @@ public:
 
     void                                    SetCustomMode();
     void                                    DeviceUpdateMode();
+    void                                    DeviceSaveMode();
 
 private:
     QMKOpenRGBRevBController*   controller;
@@ -46,7 +47,8 @@ private:
                                             std::string name,
                                             unsigned int &current_mode,
                                             unsigned int flags,
-                                            unsigned int color_mode
+                                            unsigned int color_mode,
+                                            bool save
                                             );
 
     unsigned int                            CalculateDivisor

Controllers/RazerController/RazerControllerDetect.cpp

@@ -93,14 +93,20 @@ void DetectRazerARGBControllers(hid_device_info* info, const std::string& name)
     /*-------------------------------------------------------------------------------------------------*\
     | Razer's ARGB controller uses two different interfaces, one for 90-byte Razer report packets and   |
     | one for 320-byte ARGB packets.  Interface 0 for 90-byte and interface 1 for 320-byte.             |
+    |                                                                                                   |
+    | Create a local copy of the HID enumerations for the Razer ARGB controller VID/PID and iterate     |
+    | through it.  This prevents detection from failing if interface 1 comes before interface 0 in the  |
+    | main info list.                                                                                   |
     \*-------------------------------------------------------------------------------------------------*/
      hid_device* dev_interface_0 = nullptr;
      hid_device* dev_interface_1 = nullptr;
-     hid_device_info* info_temp = info;
+     hid_device_info* info_full = hid_enumerate(RAZER_VID, RAZER_CHROMA_ADDRESSABLE_RGB_CONTROLLER_PID);
+     hid_device_info* info_temp = info_full;
+
      while(info_temp)
      {
-         if(info_temp->vendor_id        == info->vendor_id        // constant LOGITECH_VID
-         && info_temp->product_id       == info->product_id )     // NON-constant
+         if(info_temp->vendor_id        == info->vendor_id
+         && info_temp->product_id       == info->product_id )
          {
              if(info_temp->interface_number == 0)
              {
@@ -117,6 +123,9 @@ void DetectRazerARGBControllers(hid_device_info* info, const std::string& name)
          }
          info_temp = info_temp->next;
      }
+     
+     hid_free_enumeration(info_full);
+
      if(dev_interface_0 && dev_interface_1)
      {
          RazerController* controller                    = new RazerController(dev_interface_0, dev_interface_1, info->path, info->product_id, name);

OpenRGB.pro

@@ -20,6 +20,15 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
 greaterThan(QT_MAJOR_VERSION, 5): DEFINES += _QT6
 
+#-----------------------------------------------------------------------------------------------#
+# pkg-config Configuration                                                                      #
+#-----------------------------------------------------------------------------------------------#
+greaterThan(QT_MAJOR_VERSION, 4) {
+    PKG_CONFIG = $$pkgConfigExecutable()
+} else {
+    PKG_CONFIG = "pkgconf"
+}
+
 #-----------------------------------------------------------------------------------------------#
 # Application Configuration                                                                     #
 #-----------------------------------------------------------------------------------------------#
@@ -166,7 +175,8 @@ HEADERS +=
     qt/DeviceView.h                                                                             \
     qt/OpenRGBDialog2.h                                                                         \
     qt/OpenRGBPluginContainer.h                                                                 \
-    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.h \
+    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.h                                                 \
+    qt/OpenRGBPluginsPage/OpenRGBPluginsList.h                                                  \
     qt/OpenRGBPluginsPage/OpenRGBPluginsPage.h                                                  \
     qt/OpenRGBProfileSaveDialog.h                                                               \
     qt/OpenRGBServerInfoPage.h                                                                  \
@@ -177,10 +187,14 @@ HEADERS +=
     qt/OpenRGBZoneResizeDialog.h                                                                \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsEntry.h                                       \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsPage.h                                        \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.h                           \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.h                            \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsEntry.h                                 \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsPage.h                                  \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsEntry.h                                   \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsPage.h                                    \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.h                               \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.h                                \
     qt/OpenRGBZonesBulkResizer.h                                                                \
     qt/TabLabel.h                                                                               \
     serial_port/find_usb_serial_port.h                                                          \
@@ -333,6 +347,7 @@ HEADERS +=
     Controllers/LogitechController/LogitechG810Controller.h                                     \
     Controllers/LogitechController/LogitechG910Controller.h                                     \
     Controllers/LogitechController/LogitechG815Controller.h                                     \
+    Controllers/LogitechController/LogitechG915Controller.h                                     \
     Controllers/LogitechController/LogitechGLightsyncController.h                               \
     Controllers/LogitechController/LogitechLightspeedController.h                               \
     Controllers/LogitechController/LogitechX56Controller.h                                      \
@@ -343,6 +358,7 @@ HEADERS +=
     Controllers/LogitechController/RGBController_LogitechG810.h                                 \
     Controllers/LogitechController/RGBController_LogitechG910.h                                 \
     Controllers/LogitechController/RGBController_LogitechG815.h                                 \
+    Controllers/LogitechController/RGBController_LogitechG915.h                                 \
     Controllers/LogitechController/RGBController_LogitechGLightsync.h                           \
     Controllers/LogitechController/RGBController_LogitechGLightsync1zone.h                      \
     Controllers/LogitechController/RGBController_LogitechGPowerPlay.h                           \
@@ -492,7 +508,8 @@ SOURCES +=
     qt/DeviceView.cpp                                                                           \
     qt/OpenRGBDialog2.cpp                                                                       \
     qt/OpenRGBPluginContainer.cpp                                                               \
-    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.cpp \
+    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.cpp                                               \
+    qt/OpenRGBPluginsPage/OpenRGBPluginsList.cpp                                                \
     qt/OpenRGBPluginsPage/OpenRGBPluginsPage.cpp                                                \
     qt/OpenRGBProfileSaveDialog.cpp                                                             \
     qt/OpenRGBServerInfoPage.cpp                                                                \
@@ -506,10 +523,14 @@ SOURCES +=
     qt/hsv.cpp                                                                                  \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsEntry.cpp                                     \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsPage.cpp                                      \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.cpp                         \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.cpp                          \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsEntry.cpp                               \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsPage.cpp                                \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsEntry.cpp                                 \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsPage.cpp                                  \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.cpp                             \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.cpp                              \
     serial_port/serial_port.cpp                                                                 \
     super_io/super_io.cpp                                                                       \
     AutoStart/AutoStart.cpp                                                                     \
@@ -707,6 +728,7 @@ SOURCES +=
     Controllers/LogitechController/LogitechG810Controller.cpp                                   \
     Controllers/LogitechController/LogitechG910Controller.cpp                                   \
     Controllers/LogitechController/LogitechG815Controller.cpp                                   \
+    Controllers/LogitechController/LogitechG915Controller.cpp                                   \
     Controllers/LogitechController/LogitechGLightsyncController.cpp                             \
     Controllers/LogitechController/LogitechLightspeedController.cpp                             \
     Controllers/LogitechController/LogitechX56Controller.cpp                                    \
@@ -717,6 +739,7 @@ SOURCES +=
     Controllers/LogitechController/RGBController_LogitechG810.cpp                               \
     Controllers/LogitechController/RGBController_LogitechG910.cpp                               \
     Controllers/LogitechController/RGBController_LogitechG815.cpp                               \
+    Controllers/LogitechController/RGBController_LogitechG915.cpp                               \
     Controllers/LogitechController/RGBController_LogitechGLightsync.cpp                         \
     Controllers/LogitechController/RGBController_LogitechGLightsync1zone.cpp                    \
     Controllers/LogitechController/RGBController_LogitechGPowerPlay.cpp                         \
@@ -840,7 +863,7 @@ FORMS +=
     qt/OpenRGBDialog.ui                                                                         \
     qt/OpenRGBDialog2.ui                                                                        \
     qt/OpenRGBPluginContainer.ui                                                                \
-    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.ui \
+    qt/OpenRGBPluginsPage/OpenRGBPluginsEntry.ui                                                \
     qt/OpenRGBPluginsPage/OpenRGBPluginsPage.ui                                                 \
     qt/OpenRGBProfileSaveDialog.ui                                                              \
     qt/OpenRGBServerInfoPage.ui                                                                 \
@@ -851,10 +874,14 @@ FORMS +=
     qt/OpenRGBZoneResizeDialog.ui                                                               \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsEntry.ui                                      \
     qt/OpenRGBE131SettingsPage/OpenRGBE131SettingsPage.ui                                       \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.ui                          \
+    qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.ui                           \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsEntry.ui                                \
     qt/OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsPage.ui                                 \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsEntry.ui                                  \
     qt/OpenRGBSerialSettingsPage/OpenRGBSerialSettingsPage.ui                                   \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.ui                              \
+    qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.ui                               \
     qt/OpenRGBZonesBulkResizer.ui                                                               \
     qt/TabLabel.ui                                                                              \
 
@@ -1099,7 +1126,7 @@ unix:!macx {
         # hidapi-hidraw >= 0.10.1 supports USAGE/USAGE_PAGE                                     #
         # Define USE_HID_USAGE if hidapi-hidraw supports it                                     #
         #---------------------------------------------------------------------------------------#
-        HIDAPI_HIDRAW_VERSION = $$system(pkgconf --modversion hidapi-hidraw)
+        HIDAPI_HIDRAW_VERSION = $$system($$PKG_CONFIG --modversion hidapi-hidraw)
         if(versionAtLeast(HIDAPI_HIDRAW_VERSION, "0.10.1")) {
             DEFINES += USE_HID_USAGE
         }

pci_ids/pci_ids.h

@@ -102,6 +102,7 @@
 #define ASUS_ROG_STRIX_GTX1080TI_11G_GAMING             0x85F1
 #define ASUS_ROG_STRIX_GTX1080TI_GAMING                 0x85EA
 #define ASUS_ROG_STRIX_GTX1650S_OC                      0x874F
+#define ASUS_ROG_STRIX_GTX1660S_O6G_GAMING              0x8752
 #define ASUS_ROG_GTX1660TI_OC                           0x86A5
 #define ASUS_ROG_STRIX_RTX2060_EVO_GAMING               0x86D3
 #define ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING          0x8703

qt/OpenRGBDialog2.cpp

@@ -453,6 +453,16 @@ OpenRGBDialog2::OpenRGBDialog2(QWidget *parent) : QMainWindow(parent), ui(new Op
     \*-----------------------------------------------------*/
     AddQMKORGBSettingsPage();
 
+    /*-----------------------------------------------------*\
+    | Add the Philips Wiz settings page                     |
+    \*-----------------------------------------------------*/
+    AddPhilipsWizSettingsPage();
+
+    /*-----------------------------------------------------*\
+    | Add the Yeelight settings page                        |
+    \*-----------------------------------------------------*/
+    AddYeelightSettingsPage();
+
     /*-----------------------------------------------------*\
     | Add the SMBus Tools page if enabled                   |
     \*-----------------------------------------------------*/
@@ -651,6 +661,34 @@ void OpenRGBDialog2::AddE131SettingsPage()
     ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
 }
 
+void OpenRGBDialog2::AddPhilipsWizSettingsPage()
+{
+    /*-----------------------------------------------------*\
+    | Create the Settings page                              |
+    \*-----------------------------------------------------*/
+    PhilipsWizSettingsPage = new OpenRGBPhilipsWizSettingsPage();
+
+    ui->SettingsTabBar->addTab(PhilipsWizSettingsPage, "");
+
+    QString SettingsLabelString;
+
+    if(IsDarkTheme())
+    {
+        SettingsLabelString = "light_dark.png";
+    }
+    else
+    {
+        SettingsLabelString = "light.png";
+    }
+
+    /*-----------------------------------------------------*\
+    | Create the tab label                                  |
+    \*-----------------------------------------------------*/
+    TabLabel* SettingsTabLabel = new TabLabel(SettingsLabelString, "Philips Wiz Devices");
+
+    ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
+}
+
 void OpenRGBDialog2::AddQMKORGBSettingsPage()
 {
     /*-----------------------------------------------------*\
@@ -707,6 +745,34 @@ void OpenRGBDialog2::AddSerialSettingsPage()
     ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
 }
 
+void OpenRGBDialog2::AddYeelightSettingsPage()
+{
+    /*-----------------------------------------------------*\
+    | Create the Settings page                              |
+    \*-----------------------------------------------------*/
+    YeelightSettingsPage = new OpenRGBYeelightSettingsPage();
+
+    ui->SettingsTabBar->addTab(YeelightSettingsPage, "");
+
+    QString SettingsLabelString;
+
+    if(IsDarkTheme())
+    {
+        SettingsLabelString = "light_dark.png";
+    }
+    else
+    {
+        SettingsLabelString = "light.png";
+    }
+
+    /*-----------------------------------------------------*\
+    | Create the tab label                                  |
+    \*-----------------------------------------------------*/
+    TabLabel* SettingsTabLabel = new TabLabel(SettingsLabelString, "Yeelight Devices");
+
+    ui->SettingsTabBar->tabBar()->setTabButton(ui->SettingsTabBar->tabBar()->count() - 1, QTabBar::LeftSide, SettingsTabLabel);
+}
+
 void OpenRGBDialog2::AddPlugin(OpenRGBPluginEntry* plugin)
 {
     /*-----------------------------------------------------*\

qt/OpenRGBDialog2.h

@@ -10,8 +10,10 @@
 #include "OpenRGBSupportedDevicesPage.h"
 #include "OpenRGBSettingsPage.h"
 #include "OpenRGBE131SettingsPage/OpenRGBE131SettingsPage.h"
+#include "OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.h"
 #include "OpenRGBQMKORGBSettingsPage/OpenRGBQMKORGBSettingsPage.h"
 #include "OpenRGBSerialSettingsPage/OpenRGBSerialSettingsPage.h"
+#include "OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.h"
 #include "PluginManager.h"
 
 #include <vector>
@@ -64,8 +66,10 @@ private:
     OpenRGBSupportedDevicesPage *SupportedPage;
     OpenRGBSettingsPage *SettingsPage;
     OpenRGBE131SettingsPage *E131SettingsPage;
+    OpenRGBPhilipsWizSettingsPage *PhilipsWizSettingsPage;
     OpenRGBQMKORGBSettingsPage *QMKORGBSettingsPage;
     OpenRGBSerialSettingsPage *SerialSettingsPage;
+    OpenRGBYeelightSettingsPage *YeelightSettingsPage;
 
     bool ShowI2CTools = false;
 
@@ -85,8 +89,10 @@ private:
     void AddSupportedDevicesPage();
     void AddSettingsPage();
     void AddE131SettingsPage();
+    void AddPhilipsWizSettingsPage();
     void AddQMKORGBSettingsPage();
     void AddSerialSettingsPage();
+    void AddYeelightSettingsPage();
     void AddPluginsPage(PluginManager* plugin_manager);
 
     void ClearDevicesList();

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.cpp

@@ -0,0 +1,16 @@
+#include "OpenRGBPhilipsWizSettingsEntry.h"
+#include "ui_OpenRGBPhilipsWizSettingsEntry.h"
+
+using namespace Ui;
+
+OpenRGBPhilipsWizSettingsEntry::OpenRGBPhilipsWizSettingsEntry(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::OpenRGBPhilipsWizSettingsEntryUi)
+{
+    ui->setupUi(this);
+}
+
+OpenRGBPhilipsWizSettingsEntry::~OpenRGBPhilipsWizSettingsEntry()
+{
+    delete ui;
+}

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.h

@@ -0,0 +1,21 @@
+#ifndef OPENRGBPHILIPSWIZSETTINGSENTRY_H
+#define OPENRGBPHILIPSWIZSETTINGSENTRY_H
+
+#include "ui_OpenRGBPhilipsWizSettingsEntry.h"
+#include <QWidget>
+
+namespace Ui {
+class OpenRGBPhilipsWizSettingsEntry;
+}
+
+class Ui::OpenRGBPhilipsWizSettingsEntry : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit OpenRGBPhilipsWizSettingsEntry(QWidget *parent = nullptr);
+    ~OpenRGBPhilipsWizSettingsEntry();
+    Ui::OpenRGBPhilipsWizSettingsEntryUi *ui;
+};
+
+#endif // OPENRGBPHILIPSWIZSETTINGSENTRY_H

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsEntry.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>OpenRGBPhilipsWizSettingsEntryUi</class>
+ <widget class="QWidget" name="OpenRGBPhilipsWizSettingsEntryUi">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>190</width>
+    <height>59</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0" colspan="2">
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="1" column="3">
+       <widget class="QLineEdit" name="IPEdit"/>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="IPLabel">
+        <property name="text">
+         <string>IP:</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>IPEdit</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.cpp

@@ -0,0 +1,105 @@
+#include "OpenRGBPhilipsWizSettingsPage.h"
+#include "ui_OpenRGBPhilipsWizSettingsPage.h"
+#include "ResourceManager.h"
+
+using namespace Ui;
+
+OpenRGBPhilipsWizSettingsPage::OpenRGBPhilipsWizSettingsPage(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::OpenRGBPhilipsWizSettingsPageUi)
+{
+    ui->setupUi(this);
+
+    json                wiz_settings;
+
+    /*-------------------------------------------------*\
+    | Get Philips Wiz settings                          |
+    \*-------------------------------------------------*/
+    wiz_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("PhilipsWizDevices");
+
+    /*-------------------------------------------------*\
+    | If the Wiz settings contains devices, process     |
+    \*-------------------------------------------------*/
+    if(wiz_settings.contains("devices"))
+    {
+        for(unsigned int device_idx = 0; device_idx < wiz_settings["devices"].size(); device_idx++)
+        {
+            OpenRGBPhilipsWizSettingsEntry* entry = new OpenRGBPhilipsWizSettingsEntry;
+
+            if(wiz_settings["devices"][device_idx].contains("ip"))
+            {
+                entry->ui->IPEdit->setText(QString::fromStdString(wiz_settings["devices"][device_idx]["ip"]));
+            }
+
+            entries.push_back(entry);
+
+            QListWidgetItem* item = new QListWidgetItem;
+
+            item->setSizeHint(entry->sizeHint());
+
+            ui->PhilipsWizDeviceList->addItem(item);
+            ui->PhilipsWizDeviceList->setItemWidget(item, entry);
+            ui->PhilipsWizDeviceList->show();
+        }
+    }
+}
+
+OpenRGBPhilipsWizSettingsPage::~OpenRGBPhilipsWizSettingsPage()
+{
+    delete ui;
+}
+
+void Ui::OpenRGBPhilipsWizSettingsPage::on_AddPhilipsWizDeviceButton_clicked()
+{
+    OpenRGBPhilipsWizSettingsEntry* entry = new OpenRGBPhilipsWizSettingsEntry;
+    entries.push_back(entry);
+
+    QListWidgetItem* item = new QListWidgetItem;
+
+    item->setSizeHint(entry->sizeHint());
+
+    ui->PhilipsWizDeviceList->addItem(item);
+    ui->PhilipsWizDeviceList->setItemWidget(item, entry);
+    ui->PhilipsWizDeviceList->show();
+}
+
+void Ui::OpenRGBPhilipsWizSettingsPage::on_RemovePhilipsWizDeviceButton_clicked()
+{
+    int cur_row = ui->PhilipsWizDeviceList->currentRow();
+
+    if(cur_row < 0)
+    {
+        return;
+    }
+
+    QListWidgetItem* item = ui->PhilipsWizDeviceList->takeItem(cur_row);
+
+    ui->PhilipsWizDeviceList->removeItemWidget(item);
+    delete item;
+
+    delete entries[cur_row];
+    entries.erase(entries.begin() + cur_row);
+}
+
+void Ui::OpenRGBPhilipsWizSettingsPage::on_SavePhilipsWizConfigurationButton_clicked()
+{
+    json                wiz_settings;
+
+    /*-------------------------------------------------*\
+    | Get Philips Wiz settings                          |
+    \*-------------------------------------------------*/
+    wiz_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("PhilipsWizDevices");
+
+    wiz_settings["devices"].clear();
+
+    for(unsigned int device_idx = 0; device_idx < entries.size(); device_idx++)
+    {
+        /*-------------------------------------------------*\
+        | Required parameters                               |
+        \*-------------------------------------------------*/
+        wiz_settings["devices"][device_idx]["ip"]       = entries[device_idx]->ui->IPEdit->text().toStdString();
+    }
+
+    ResourceManager::get()->GetSettingsManager()->SetSettings("PhilipsWizDevices", wiz_settings);
+    ResourceManager::get()->GetSettingsManager()->SaveSettings();
+}

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.h

@@ -0,0 +1,34 @@
+#ifndef OPENRGBPHILIPSWIZSETTINGSPAGE_H
+#define OPENRGBPHILIPSWIZSETTINGSPAGE_H
+
+#include "ui_OpenRGBPhilipsWizSettingsPage.h"
+#include <QWidget>
+
+#include "OpenRGBPhilipsWizSettingsEntry.h"
+
+namespace Ui {
+class OpenRGBPhilipsWizSettingsPage;
+}
+
+class Ui::OpenRGBPhilipsWizSettingsPage : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit OpenRGBPhilipsWizSettingsPage(QWidget *parent = nullptr);
+    ~OpenRGBPhilipsWizSettingsPage();
+
+private slots:
+    void on_AddPhilipsWizDeviceButton_clicked();
+
+    void on_RemovePhilipsWizDeviceButton_clicked();
+
+    void on_SavePhilipsWizConfigurationButton_clicked();
+
+private:
+    Ui::OpenRGBPhilipsWizSettingsPageUi *ui;
+    std::vector<OpenRGBPhilipsWizSettingsEntry*> entries;
+
+};
+
+#endif // OPENRGBPHILIPSWIZSETTINGSPAGE_H

qt/OpenRGBPhilipsWizSettingsPage/OpenRGBPhilipsWizSettingsPage.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>OpenRGBPhilipsWizSettingsPageUi</class>
+ <widget class="QWidget" name="OpenRGBPhilipsWizSettingsPageUi">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QPushButton" name="AddPhilipsWizDeviceButton">
+     <property name="text">
+      <string>Add</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QPushButton" name="RemovePhilipsWizDeviceButton">
+     <property name="text">
+      <string>Remove</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2">
+    <widget class="QPushButton" name="SavePhilipsWizConfigurationButton">
+     <property name="text">
+      <string>Save</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="3">
+    <widget class="QListWidget" name="PhilipsWizDeviceList">
+     <property name="verticalScrollMode">
+      <enum>QAbstractItemView::ScrollPerPixel</enum>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

qt/OpenRGBPluginsPage/OpenRGBPluginsList.cpp

@@ -0,0 +1,45 @@
+#include "OpenRGBPluginsList.h"
+#include <QMimeData>
+#include <QUrl>
+
+OpenRGBPluginsList::OpenRGBPluginsList(QWidget *parent) : QListWidget (parent)
+{
+    setAcceptDrops(true);
+}
+
+void OpenRGBPluginsList::dropEvent(QDropEvent *event)
+{
+    const QMimeData* mimeData = event->mimeData();
+
+    if (mimeData->hasUrls())
+    {
+        std::vector<std::string> path_list;
+
+        QList<QUrl> urls = mimeData->urls();
+
+        for(const QUrl& url: urls)
+        {
+            path_list.push_back(url.toLocalFile().toStdString());
+        }
+
+        emit PluginsDropped(path_list);
+    }
+
+}
+
+void OpenRGBPluginsList::dragEnterEvent(QDragEnterEvent *event)
+{
+    if (event->mimeData()->hasUrls())
+    {
+        event->acceptProposedAction();
+    }
+    else
+    {
+        event->ignore();
+    }
+}
+
+void OpenRGBPluginsList::dragMoveEvent(QDragMoveEvent *event)
+{
+    event->acceptProposedAction();
+}

qt/OpenRGBPluginsPage/OpenRGBPluginsList.h

@@ -0,0 +1,24 @@
+#ifndef OPENRGBPLUGINSLIST_H
+#define OPENRGBPLUGINSLIST_H
+
+#include <QListWidget>
+#include <QDropEvent>
+#include <QDragEnterEvent>
+
+class OpenRGBPluginsList : public QListWidget
+{
+    Q_OBJECT
+
+public:
+    OpenRGBPluginsList(QWidget *parent = nullptr);
+
+signals:
+    void PluginsDropped(std::vector<std::string>);
+
+protected:
+    void dropEvent(QDropEvent *event) override;
+    void dragEnterEvent(QDragEnterEvent *event) override;
+    void dragMoveEvent(QDragMoveEvent *event) override;
+};
+
+#endif // OPENRGBPLUGINSLIST_H

qt/OpenRGBPluginsPage/OpenRGBPluginsPage.cpp

@@ -88,7 +88,17 @@ void Ui::OpenRGBPluginsPage::on_InstallPluginButton_clicked()
     \*-----------------------------------------------------*/
     QString     install_file    = QFileDialog::getOpenFileName(this, "Install OpenRGB Plugin", "", "DLL Files (*.dll; *.dylib; *.so; *.so.*)");
 
-    std::string from_path       = install_file.toStdString();
+    bool installed = InstallPlugin(install_file.toStdString());
+
+    if(installed)
+    {
+        RefreshList();
+    }
+}
+
+bool Ui::OpenRGBPluginsPage::InstallPlugin(std::string install_file)
+{
+    std::string from_path       = install_file;
     std::string to_path         = ResourceManager::get()->GetConfigurationDirectory() + "plugins/";
     std::string to_file         = to_path + filesystem::path(from_path).filename().string();
     bool        match           = false;
@@ -116,7 +126,7 @@ void Ui::OpenRGBPluginsPage::on_InstallPluginButton_clicked()
 
         if(reply != QMessageBox::Yes)
         {
-            return;
+            return false;
         }
     }
 
@@ -132,12 +142,14 @@ void Ui::OpenRGBPluginsPage::on_InstallPluginButton_clicked()
 
         plugin_manager->AddPlugin(to_file);
 
-        RefreshList();
+        return true;
     }
     catch(std::exception& e)
     {
 
     }
+
+    return false;
 }
 
 void Ui::OpenRGBPluginsPage::on_RemovePluginButton_clicked()
@@ -298,3 +310,27 @@ void Ui::OpenRGBPluginsPage::on_EnableButton_clicked(OpenRGBPluginsEntry* entry)
         plugin_manager->UnloadPlugin(entry_path);
     }
 }
+
+void Ui::OpenRGBPluginsPage::on_PluginsList_itemSelectionChanged()
+{
+    /*-----------------------------------------------------*\
+    | Enable the remove button when there's a selected item |
+    \*-----------------------------------------------------*/
+    ui->RemovePluginButton->setEnabled(!ui->PluginsList->selectedItems().empty());
+}
+
+void Ui::OpenRGBPluginsPage::on_PluginsList_PluginsDropped(std::vector<std::string> path_list)
+{
+    bool installed = false;
+
+    for(const std::string& file_path: path_list)
+    {
+        installed |= InstallPlugin(file_path);
+    }
+
+    if(installed)
+    {
+        RefreshList();
+    }
+}
+

qt/OpenRGBPluginsPage/OpenRGBPluginsPage.h

@@ -26,11 +26,16 @@ private slots:
 
     void on_RemovePluginButton_clicked();
 
+    void on_PluginsList_itemSelectionChanged();
+    
+    void on_PluginsList_PluginsDropped(std::vector<std::string>);
+
 private:
     Ui::OpenRGBPluginsPageUi*   ui;
     PluginManager*              plugin_manager;
     std::vector<OpenRGBPluginsEntry*> entries;
 
+    bool InstallPlugin(std::string path);
     void RefreshList();
 };
 

qt/OpenRGBPluginsPage/OpenRGBPluginsPage.ui

@@ -23,13 +23,16 @@
    </item>
    <item row="1" column="1">
     <widget class="QPushButton" name="RemovePluginButton">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
      <property name="text">
       <string>Remove Plugin</string>
      </property>
     </widget>
    </item>
    <item row="0" column="0" colspan="2">
-    <widget class="QListWidget" name="PluginsList">
+    <widget class="OpenRGBPluginsList" name="PluginsList">
      <property name="verticalScrollMode">
       <enum>QAbstractItemView::ScrollPerPixel</enum>
      </property>
@@ -37,6 +40,13 @@
    </item>
   </layout>
  </widget>
+ <customwidgets>
+  <customwidget>
+   <class>OpenRGBPluginsList</class>
+   <extends>QListWidget</extends>
+   <header>qt/OpenRGBPluginsPage/OpenRGBPluginsList.h</header>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.cpp

@@ -0,0 +1,16 @@
+#include "OpenRGBYeelightSettingsEntry.h"
+#include "ui_OpenRGBYeelightSettingsEntry.h"
+
+using namespace Ui;
+
+OpenRGBYeelightSettingsEntry::OpenRGBYeelightSettingsEntry(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::OpenRGBYeelightSettingsEntryUi)
+{
+    ui->setupUi(this);
+}
+
+OpenRGBYeelightSettingsEntry::~OpenRGBYeelightSettingsEntry()
+{
+    delete ui;
+}

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.h

@@ -0,0 +1,21 @@
+#ifndef OPENRGBYEELIGHTSETTINGSENTRY_H
+#define OPENRGBYEELIGHTSETTINGSENTRY_H
+
+#include "ui_OpenRGBYeelightSettingsEntry.h"
+#include <QWidget>
+
+namespace Ui {
+class OpenRGBYeelightSettingsEntry;
+}
+
+class Ui::OpenRGBYeelightSettingsEntry : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit OpenRGBYeelightSettingsEntry(QWidget *parent = nullptr);
+    ~OpenRGBYeelightSettingsEntry();
+    Ui::OpenRGBYeelightSettingsEntryUi *ui;
+};
+
+#endif // OPENRGBYeelightSETTINGSENTRY_H

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsEntry.ui

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>OpenRGBYeelightSettingsEntryUi</class>
+ <widget class="QWidget" name="OpenRGBYeelightSettingsEntryUi">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>225</width>
+    <height>85</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0" colspan="2">
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="1" column="3">
+       <widget class="QLineEdit" name="IPEdit"/>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="IPLabel">
+        <property name="text">
+         <string>IP:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="3">
+       <widget class="QCheckBox" name="MusicModeCheckBox">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="MusicModeLabel">
+        <property name="text">
+         <string>Music Mode:</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>IPEdit</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.cpp

@@ -0,0 +1,111 @@
+#include "OpenRGBYeelightSettingsPage.h"
+#include "ui_OpenRGBYeelightSettingsPage.h"
+#include "ResourceManager.h"
+
+using namespace Ui;
+
+OpenRGBYeelightSettingsPage::OpenRGBYeelightSettingsPage(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::OpenRGBYeelightSettingsPageUi)
+{
+    ui->setupUi(this);
+
+    json                yeelight_settings;
+
+    /*-------------------------------------------------*\
+    | Get Philips Wiz settings                          |
+    \*-------------------------------------------------*/
+    yeelight_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("YeelightDevices");
+
+    /*-------------------------------------------------*\
+    | If the Wiz settings contains devices, process     |
+    \*-------------------------------------------------*/
+    if(yeelight_settings.contains("devices"))
+    {
+        for(unsigned int device_idx = 0; device_idx < yeelight_settings["devices"].size(); device_idx++)
+        {
+            OpenRGBYeelightSettingsEntry* entry = new OpenRGBYeelightSettingsEntry;
+
+            if(yeelight_settings["devices"][device_idx].contains("ip"))
+            {
+                entry->ui->IPEdit->setText(QString::fromStdString(yeelight_settings["devices"][device_idx]["ip"]));
+            }
+
+            if(yeelight_settings["devices"][device_idx].contains("music_mode"))
+            {
+                entry->ui->MusicModeCheckBox->setChecked(yeelight_settings["devices"][device_idx]["music_mode"]);
+            }
+
+            entries.push_back(entry);
+
+            QListWidgetItem* item = new QListWidgetItem;
+
+            item->setSizeHint(entry->sizeHint());
+
+            ui->YeelightDeviceList->addItem(item);
+            ui->YeelightDeviceList->setItemWidget(item, entry);
+            ui->YeelightDeviceList->show();
+        }
+    }
+}
+
+OpenRGBYeelightSettingsPage::~OpenRGBYeelightSettingsPage()
+{
+    delete ui;
+}
+
+void Ui::OpenRGBYeelightSettingsPage::on_AddYeelightDeviceButton_clicked()
+{
+    OpenRGBYeelightSettingsEntry* entry = new OpenRGBYeelightSettingsEntry;
+    entries.push_back(entry);
+
+    QListWidgetItem* item = new QListWidgetItem;
+
+    item->setSizeHint(entry->sizeHint());
+
+    ui->YeelightDeviceList->addItem(item);
+    ui->YeelightDeviceList->setItemWidget(item, entry);
+    ui->YeelightDeviceList->show();
+}
+
+void Ui::OpenRGBYeelightSettingsPage::on_RemoveYeelightDeviceButton_clicked()
+{
+    int cur_row = ui->YeelightDeviceList->currentRow();
+
+    if(cur_row < 0)
+    {
+        return;
+    }
+
+    QListWidgetItem* item = ui->YeelightDeviceList->takeItem(cur_row);
+
+    ui->YeelightDeviceList->removeItemWidget(item);
+    delete item;
+
+    delete entries[cur_row];
+    entries.erase(entries.begin() + cur_row);
+}
+
+void Ui::OpenRGBYeelightSettingsPage::on_SaveYeelightConfigurationButton_clicked()
+{
+    json                yeelight_settings;
+
+    /*-------------------------------------------------*\
+    | Get Philips Wiz settings                          |
+    \*-------------------------------------------------*/
+    yeelight_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("YeelightDevices");
+
+    yeelight_settings["devices"].clear();
+
+    for(unsigned int device_idx = 0; device_idx < entries.size(); device_idx++)
+    {
+        /*-------------------------------------------------*\
+        | Required parameters                               |
+        \*-------------------------------------------------*/
+        yeelight_settings["devices"][device_idx]["ip"]          = entries[device_idx]->ui->IPEdit->text().toStdString();
+        yeelight_settings["devices"][device_idx]["music_mode"]  = entries[device_idx]->ui->MusicModeCheckBox->isChecked();
+    }
+
+    ResourceManager::get()->GetSettingsManager()->SetSettings("YeelightDevices", yeelight_settings);
+    ResourceManager::get()->GetSettingsManager()->SaveSettings();
+}

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.h

@@ -0,0 +1,34 @@
+#ifndef OPENRGBYEELIGHTSETTINGSPAGE_H
+#define OPENRGBYEELIGHTSETTINGSPAGE_H
+
+#include "ui_OpenRGBYeelightSettingsPage.h"
+#include <QWidget>
+
+#include "OpenRGBYeelightSettingsEntry.h"
+
+namespace Ui {
+class OpenRGBYeelightSettingsPage;
+}
+
+class Ui::OpenRGBYeelightSettingsPage : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit OpenRGBYeelightSettingsPage(QWidget *parent = nullptr);
+    ~OpenRGBYeelightSettingsPage();
+
+private slots:
+    void on_AddYeelightDeviceButton_clicked();
+
+    void on_RemoveYeelightDeviceButton_clicked();
+
+    void on_SaveYeelightConfigurationButton_clicked();
+
+private:
+    Ui::OpenRGBYeelightSettingsPageUi *ui;
+    std::vector<OpenRGBYeelightSettingsEntry*> entries;
+
+};
+
+#endif // OPENRGBYEELIGHTSETTINGSPAGE_H

qt/OpenRGBYeelightSettingsPage/OpenRGBYeelightSettingsPage.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>OpenRGBYeelightSettingsPageUi</class>
+ <widget class="QWidget" name="OpenRGBYeelightSettingsPageUi">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="0">
+    <widget class="QPushButton" name="AddYeelightDeviceButton">
+     <property name="text">
+      <string>Add</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QPushButton" name="RemoveYeelightDeviceButton">
+     <property name="text">
+      <string>Remove</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2">
+    <widget class="QPushButton" name="SaveYeelightConfigurationButton">
+     <property name="text">
+      <string>Save</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="3">
+    <widget class="QListWidget" name="YeelightDeviceList">
+     <property name="verticalScrollMode">
+      <enum>QAbstractItemView::ScrollPerPixel</enum>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>