Make i2c thread safe

Controllers/AuraController/AuraController.cpp

@@ -157,6 +157,21 @@ unsigned int AuraController::GetLEDCount()
     return(led_count);
 }
 
+unsigned char AuraController::GetLEDRed(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led )));
+}
+
+unsigned char AuraController::GetLEDGreen(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
+}
+
+unsigned char AuraController::GetLEDBlue(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
+}
+
 void AuraController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
 {
     unsigned char* colors = new unsigned char[led_count * 3];
@@ -229,30 +244,45 @@ void AuraController::AuraUpdateDeviceName()
 
 unsigned char AuraController::AuraRegisterRead(aura_register reg)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Read Aura value
     return(bus->i2c_smbus_read_byte_data(dev, 0x81));
 
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void AuraController::AuraRegisterWrite(aura_register reg, unsigned char val)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write Aura value
     bus->i2c_smbus_write_byte_data(dev, 0x01, val);
 
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void AuraController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+    
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
 
     //Write Aura block data
     bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
 
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }

Controllers/AuraController/AuraController.h

@@ -99,6 +99,9 @@ public:
     unsigned char GetChannel(unsigned int led);
     const char*   GetChannelName(unsigned int led);
     unsigned int  GetLEDCount();
+    unsigned char GetLEDRed(unsigned int led);
+    unsigned char GetLEDGreen(unsigned int led);
+    unsigned char GetLEDBlue(unsigned int led);
     void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
     void          SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
     void          SetDirect(unsigned char direct);

Controllers/CorsairController/CorsairController.cpp

@@ -44,25 +44,28 @@ unsigned int CorsairController::GetLEDCount()
     return(led_count);
 }
 
-void CorsairController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
 {
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL, green);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL, blue);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
-}
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
 
-void CorsairController::SetLEDColor(unsigned int /*led*/, unsigned char red, unsigned char green, unsigned char blue)
-{
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL, green);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL, blue);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void CorsairController::SetMode(unsigned char /*mode*/)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }

Controllers/CorsairController/CorsairController.h

@@ -44,8 +44,7 @@ public:
     unsigned int    GetLEDCount();
     void            SetMode(unsigned char mode);
 
-    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
     char                    device_name[32];

Controllers/CorsairProController/CorsairProController.cpp

@@ -81,6 +81,9 @@ void CorsairProController::SetLEDColor(unsigned int led, unsigned char red, unsi
 
 void CorsairProController::ApplyColors()
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
     Sleep(1);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
@@ -95,10 +98,16 @@ void CorsairProController::ApplyColors()
     }
 
     bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void CorsairProController::SetEffect(unsigned char mode)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+    
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
     Sleep(1);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
@@ -127,6 +136,9 @@ void CorsairProController::SetEffect(unsigned char mode)
 
     bus->i2c_smbus_write_byte_data(dev, 0x82, 0x01);
     WaitReady();
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void CorsairProController::SetCustom()

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -64,6 +64,11 @@ unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
             case 0x04: //Hue 2 strip
                 num_leds_on_channel += 10;
                 break;
+            
+            case 0x0B: //Aer 2 fan
+                num_leds_on_channel += 8;
+                break;
+
             default:
                 break;
             }
@@ -73,6 +78,60 @@ unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
     return(ret_val);
 }
 
+void Hue2Controller::SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[] =
+    {
+        0x28, 0x03, 0x00, 0x28,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+    int             actual = 0;
+
+    /*-----------------------------------------------------*\
+    | Set channel in USB packet                             |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = 1 << channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in USB packet                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set color count in USB packet                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x08]   = colors.size();
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        usb_buf[pixel_idx + 0x0A] = RGBGetGValue(color);
+        usb_buf[pixel_idx + 0x0B] = RGBGetRValue(color);
+        usb_buf[pixel_idx + 0x0C] = RGBGetBValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}
+
 void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
 {
     unsigned char usb_buf[] =
@@ -121,8 +180,8 @@ void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor>
     /*-----------------------------------------------------*\
     | Set channel in USB packets                            |
     \*-----------------------------------------------------*/
-    usb_buf[0x02]   = channel;
-    usb_apply[0x02] = channel;
+    usb_buf[0x02]   = 1 << channel;
+    usb_apply[0x02] = 1 << channel;
 
     /*-----------------------------------------------------*\
     | Send first packet for first 20 LEDs                   |
@@ -152,7 +211,7 @@ void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor>
     }
     
     usb_buf[0x01] = 0x11;
-    pkt_max       = 20;
+    pkt_max       = 0;
 
     if (colors.size() > 20)
     {

Controllers/Hue2Controller/Hue2Controller.h

@@ -49,8 +49,9 @@ public:
     
     char*           GetLEDString();
     unsigned int    GetStripsOnChannel(unsigned int channel);
+    void            SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
     void            SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
-
+    
     unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
 
 private:

Controllers/HuePlusController/HuePlusController.cpp

@@ -48,67 +48,162 @@ char* HuePlusController::GetLEDString()
 
 unsigned int HuePlusController::GetStripsOnChannel(unsigned int channel)
 {
+    unsigned char serial_buf[] =
+    {
+        0x8D, 0x00, 0x00, 0x00, 0x00
+    };
+
     unsigned int ret_val = 0;
 
-    if (serialport != NULL)
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
+
+    serialport->serial_flush_rx();
+    serialport->serial_write((char *)serial_buf, 2);
+    serialport->serial_flush_tx();
+
+    Sleep(50);
+
+    int bytes_read = serialport->serial_read((char *)serial_buf, 5);
+
+    if(bytes_read == 5)
     {
-        unsigned char *serial_buf;
-        serial_buf = new unsigned char[5];
-
-        serial_buf[0] = 0x8D;
-        serial_buf[1] = channel;
-
-        serialport->serial_flush_rx();
-        serialport->serial_write((char *)serial_buf, 2);
-        serialport->serial_flush_tx();
-
-        Sleep(50);
-
-        int bytes_read = serialport->serial_read((char *)serial_buf, 5);
-
-        if(bytes_read == 5)
-        {
-            ret_val = serial_buf[4];
-        }
-
-        delete[] serial_buf;
+        ret_val = serial_buf[4];
     }
 
     return(ret_val);
 }
 
-void HuePlusController::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+void HuePlusController::SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors)
 {
-    if (serialport != NULL)
+    unsigned char serial_buf[] =
     {
-        unsigned char *serial_buf;
+        0x4B, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00
+    };
 
-        serial_buf = new unsigned char[HUE_PLUS_PACKET_SIZE];
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
 
-        serial_buf[0] = 0x4B;
-        serial_buf[1] = channel;
-        serial_buf[2] = HUE_PLUS_MODE_FIXED;				
-        serial_buf[3] = 0x00; 
-        serial_buf[4] = 0x00;
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = mode;
 
-        for (int i = 5; i < HUE_PLUS_PACKET_SIZE; i++)
-        {
-            serial_buf[i] = 0x00;
-        }
-
-        for (unsigned int idx = 0; idx < (colors.size() * 3); idx += 3)
-        {
-            int pixel_idx = idx / 3;
-            RGBColor color = colors[pixel_idx];
-            serial_buf[idx + 5] = RGBGetGValue(color);
-            serial_buf[idx + 6] = RGBGetRValue(color);
-            serial_buf[idx + 7] = RGBGetBValue(color);
-        }
-
-        serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
-        serialport->serial_flush_tx();
-
-        delete[] serial_buf;
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        serial_buf[pixel_idx + 0x05] = RGBGetGValue(color);
+        serial_buf[pixel_idx + 0x06] = RGBGetRValue(color);
+        serial_buf[pixel_idx + 0x07] = RGBGetBValue(color);
     }
 
+    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    Sleep(10);
+}
+
+void HuePlusController::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[] =
+    {
+        0x4B, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00
+    };
+
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = HUE_PLUS_MODE_FIXED;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (unsigned int idx = 0; idx < (colors.size() * 3); idx += 3)
+    {
+        int pixel_idx = idx / 3;
+        RGBColor color = colors[pixel_idx];
+        serial_buf[idx + 5] = RGBGetGValue(color);
+        serial_buf[idx + 6] = RGBGetRValue(color);
+        serial_buf[idx + 7] = RGBGetBValue(color);
+    }
+
+    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    Sleep(10);
 }

Controllers/HuePlusController/HuePlusController.h

@@ -56,6 +56,7 @@ public:
     void            Initialize(char* port_name);
     char*           GetLEDString();
     unsigned int    GetStripsOnChannel(unsigned int channel);
+    void            SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
     void            SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
 
     unsigned int    channel_leds[HUE_PLUS_NUM_CHANNELS];

Controllers/HuePlusController/HuePlusControllerDetect.cpp

@@ -4,6 +4,9 @@
 #include "find_usb_serial_port.h"
 #include <vector>
 
+#define NZXT_HUE_PLUS_VID 0x04D8
+#define NZXT_HUE_PLUS_PID 0x00DF
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectHuePlusControllers                                                               *
@@ -17,7 +20,7 @@ void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
     HuePlusController* new_hueplus;
     RGBController_HuePlus* new_controller;
 
-    std::string portname = find_usb_serial_port(0x04D8, 0x00DF);
+    std::string portname = find_usb_serial_port(NZXT_HUE_PLUS_VID, NZXT_HUE_PLUS_PID);
     if( portname != "" )
     {
         new_hueplus = new HuePlusController();

Controllers/HyperXController/HyperXController.cpp

@@ -78,6 +78,9 @@ unsigned int HyperXController::GetMode()
 
 void HyperXController::SetEffectColor(unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+    
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_RED,        red  );
@@ -87,10 +90,16 @@ void HyperXController::SetEffectColor(unsigned char red, unsigned char green, un
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void HyperXController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
     /*-----------------------------------------------------*\
@@ -124,6 +133,9 @@ void HyperXController::SetAllColors(unsigned char red, unsigned char green, unsi
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void HyperXController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
@@ -163,6 +175,9 @@ void HyperXController::SetLEDColor(unsigned int led, unsigned char red, unsigned
     unsigned char blue_base   = base + 0x02;
     unsigned char bright_base = base + 0x10;
 
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
     bus->i2c_smbus_write_byte_data(dev, red_base    + (3 * led), red  );
@@ -172,6 +187,9 @@ void HyperXController::SetLEDColor(unsigned int led, unsigned char red, unsigned
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 
@@ -183,6 +201,9 @@ void HyperXController::SetLEDColor(unsigned int slot, unsigned int led, unsigned
     unsigned char blue_base   = base + 0x02;
     unsigned char bright_base = base + 0x10;
 
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
     bus->i2c_smbus_write_byte_data(dev, red_base    + (3 * led), red  );
@@ -192,12 +213,18 @@ void HyperXController::SetLEDColor(unsigned int slot, unsigned int led, unsigned
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void HyperXController::SetMode(unsigned char new_mode)
 {
     mode = new_mode;
-    
+
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
     switch (mode)
@@ -241,4 +268,7 @@ void HyperXController::SetMode(unsigned char new_mode)
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }

Controllers/PatriotViperController/PatriotViperController.cpp

@@ -76,6 +76,9 @@ unsigned int PatriotViperController::GetMode()
 
 void PatriotViperController::SetEffectColor(unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+    
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
@@ -88,10 +91,16 @@ void PatriotViperController::SetEffectColor(unsigned char red, unsigned char gre
     ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, 0x0C);
     ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
@@ -102,20 +111,32 @@ void PatriotViperController::SetAllColors(unsigned char red, unsigned char green
     ViperRegisterWrite(VIPER_REG_LED4_DIRECT_COLOR, red, blue, green);
 
     ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
     ViperRegisterWrite(VIPER_REG_LED0_DIRECT_COLOR + led, red, blue, green);
 
     ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetLEDEffectColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
@@ -124,20 +145,32 @@ void PatriotViperController::SetLEDEffectColor(unsigned int led, unsigned char r
     ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, 0x0C);
     ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
     ViperRegisterWrite(VIPER_REG_LED0_DIRECT_COLOR + led, red, blue, green);
 
     ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetLEDEffectColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
 
@@ -146,6 +179,9 @@ void PatriotViperController::SetLEDEffectColor(unsigned int slot, unsigned int l
     ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, 0x0C);
     ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetMode(unsigned char new_mode)
@@ -153,19 +189,32 @@ void PatriotViperController::SetMode(unsigned char new_mode)
     direct = false;
     mode = new_mode;
 
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_MODE, new_mode, 0x00, 0x0C);
     ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::SetDirect()
 {
     direct = true;
+
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
     ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
     ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void PatriotViperController::ViperRegisterWrite(viper_register reg, unsigned char val0, unsigned char val1, unsigned char val2)

Controllers/RGBFusionController/RGBFusionController.cpp

@@ -63,6 +63,9 @@ void RGBFusionController::SetAllColors(unsigned char red, unsigned char green, u
 {
     unsigned char mode_ch_0;
     unsigned char mode_ch_1;
+
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
     
     switch_bank(1);
     set_color_ch_0(red, green, blue);
@@ -74,6 +77,8 @@ void RGBFusionController::SetAllColors(unsigned char red, unsigned char green, u
     set_mode_ch_0(mode_ch_0);
     set_mode_ch_1(mode_ch_1);
 
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void RGBFusionController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
@@ -83,30 +88,48 @@ void RGBFusionController::SetLEDColor(unsigned int led, unsigned char red, unsig
     switch (led)
     {
     case 0:
+        //Lock SMBus interface
+        bus->i2c_smbus_wait_and_lock();
+        
         switch_bank(1);
         set_color_ch_0(red, green, blue);
 
         switch_bank(0);
         mode = get_mode_ch_0();
         set_mode_ch_0(mode);
+
+        //Unlock SMBus interface
+        bus->i2c_smbus_unlock();
         break;
 
     case 1:
+        //Lock SMBus interface
+        bus->i2c_smbus_wait_and_lock();
+
         switch_bank(1);
         set_color_ch_1(red, green, blue);
 
         switch_bank(0);
         mode = get_mode_ch_1();
         set_mode_ch_1(mode);
+
+        //Unlock SMBus interface
+        bus->i2c_smbus_unlock();
         break;
     }
 }
 
 void RGBFusionController::SetMode(unsigned char mode)
 {
+    //Lock SMBus interface
+    bus->i2c_smbus_wait_and_lock();
+
     switch_bank(0);
     set_mode_ch_0(mode);
     set_mode_ch_1(mode);
+
+    //Unlock SMBus interface
+    bus->i2c_smbus_unlock();
 }
 
 void RGBFusionController::dump()

Controllers/RGBFusionController/RGBFusionControllerDetect.cpp

@@ -24,6 +24,13 @@ bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
     if (res >= 0)
     {
         pass = true;
+
+        res = bus->i2c_smbus_read_byte_data(address, 0xF2);
+
+        if (res != 0xC4)
+        {
+            pass = false;
+        }
     }
 
     return(pass);

OpenRGB.pro

@@ -26,6 +26,7 @@ INCLUDEPATH +=                                                          \
     qt/
 
 SOURCES +=                                                              \
+    RGBController/RGBController.cpp \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
     OpenRGB.cpp                                                         \

RGBController/RGBController.cpp

@@ -0,0 +1,46 @@
+#include "RGBController.h"
+
+RGBColor RGBController::GetLED(int led)
+{
+    if(led < colors.size())
+    {
+        return(colors[led]);
+    }
+    else
+    {
+        return(0x00000000);
+    }
+}
+
+void RGBController::SetLED(int led, RGBColor color)
+{
+    if(led < colors.size())
+    {
+        colors[led] = color;
+
+        UpdateSingleLED(led);
+    }
+}
+
+void RGBController::SetAllLEDs(RGBColor color)
+{
+    for(int led = 0; led < colors.size(); led++)
+    {
+        colors[led] = color;
+    }
+
+    UpdateLEDs();
+}
+
+void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
+{
+    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    {
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            colors[zones[zone].map[x][y]] = color;
+        }
+    }
+
+    UpdateZoneLEDs(zone);
+}

RGBController/RGBController.h

@@ -79,11 +79,21 @@ public:
 
     virtual ~RGBController() = default;
 
-    virtual int  GetMode()         = 0;
-    virtual void SetMode(int mode) = 0;
-    virtual void SetCustomMode()   = 0;
-    virtual void SetAllLEDs(RGBColor color) = 0;
-	virtual void SetAllZoneLEDs(int zone, RGBColor color) = 0;
-	virtual void SetLED(int led, RGBColor color) = 0;
-    virtual void UpdateLEDs() = 0;
+    /*---------------------------------------------------------*\
+    | Generic functions implemented in RGBController.cpp        |
+    \*---------------------------------------------------------*/
+    RGBColor                GetLED(int led);
+    void                    SetLED(int led, RGBColor color);
+    void                    SetAllLEDs(RGBColor color);
+    void                    SetAllZoneLEDs(int zone, RGBColor color);
+
+    /*---------------------------------------------------------*\
+    | Functions to be implemented in device implementation      |
+    \*---------------------------------------------------------*/
+    virtual int             GetMode()                                   = 0;
+    virtual void            SetMode(int mode)                           = 0;
+    virtual void            SetCustomMode()                             = 0;
+    virtual void            UpdateLEDs()                                = 0;
+    virtual void            UpdateZoneLEDs(int zone)                    = 0;
+    virtual void            UpdateSingleLED(int led)                    = 0;
 };

RGBController/RGBController_AMDWraithPrism.cpp

@@ -24,6 +24,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     led logo_led;
     logo_led.name = "Logo";
     leds.push_back(logo_led);
+    colors.push_back(0x00000000);
 
     zone logo_zone;
     logo_zone.name = "Logo";
@@ -36,6 +37,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     led fan_led;
     fan_led.name = "Fan";
     leds.push_back(fan_led);
+    colors.push_back(0x00000000);
 
     zone fan_zone;
     fan_zone.name = "Fan";
@@ -48,6 +50,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
     led ring_led;
     ring_led.name = "Ring";
     leds.push_back(ring_led);
+    colors.push_back(0x00000000);
 
     zone ring_zone;
     ring_zone.name = "Ring";
@@ -78,22 +81,30 @@ void RGBController_AMDWraithPrism::SetCustomMode()
 
 }
 
-void RGBController_AMDWraithPrism::SetAllLEDs(RGBColor color)
+void RGBController_AMDWraithPrism::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    wraith->SetFanColor(red, grn, blu);
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
     wraith->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    wraith->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
     wraith->SetRingColor(red, grn, blu);
 }
 
-void RGBController_AMDWraithPrism::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     if(zone == 0)
     {
@@ -109,27 +120,7 @@ void RGBController_AMDWraithPrism::SetAllZoneLEDs(int zone, RGBColor color)
     }
 }
 
-void RGBController_AMDWraithPrism::SetLED(int led, RGBColor color)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if(led == 0)
-    {
-        wraith->SetLogoColor(red, grn, blu);
-    }
-    else if(led == 1)
-    {
-        wraith->SetFanColor(red, grn, blu);
-    }
-    else if(led == 2)
-    {
-        wraith->SetRingColor(red, grn, blu);
-    }
-}
-
-void RGBController_AMDWraithPrism::UpdateLEDs()
-{
-
+    UpdateZoneLEDs(led);
 }

RGBController/RGBController_AMDWraithPrism.h

@@ -16,14 +16,13 @@ class RGBController_AMDWraithPrism : public RGBController
 public:
     RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr);
     ~RGBController_AMDWraithPrism();
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     AMDWraithPrismController*   wraith;
-};
+};

RGBController/RGBController_AorusGPU.cpp

@@ -35,36 +35,24 @@ void RGBController_AorusGPU::SetCustomMode()
 
 }
 
-void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
-void RGBController_AorusGPU::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
-void RGBController_AorusGPU::SetLED(int led, RGBColor color)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
 void RGBController_AorusGPU::UpdateLEDs()
 {
+    RGBColor color = colors[0];
+    data[9] = RGBGetRValue(color);
+    data[10] = RGBGetGValue(color);
+    data[11] = RGBGetBValue(color);
 
+    GvWriteI2C(0x00000000, data, 0x00000000);
+}
+
+void RGBController_AorusGPU::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_AorusGPU::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
 }
 
 RGBController_AorusGPU::RGBController_AorusGPU()
@@ -81,6 +69,8 @@ RGBController_AorusGPU::RGBController_AorusGPU()
     GvFreeDispLib();
     GvInitDispLib();
 
+    colors.push_back(0x00000000);
+
     mode aorus_mode;
     aorus_mode.name = "Static";
     modes.push_back(aorus_mode);

RGBController/RGBController_AorusGPU.h

@@ -19,13 +19,12 @@ class RGBController_AorusGPU : public RGBController
 {
 public:
     RGBController_AorusGPU();
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     _GvWriteI2C GvWriteI2C;

RGBController/RGBController_Aura.cpp

@@ -39,60 +39,6 @@ void RGBController_Aura::SetCustomMode()
     aura->SetDirect(true);
 }
 
-void RGBController_Aura::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetAllColorsDirect(red, grn, blu);
-    }
-    else
-    {
-        aura->SetAllColorsEffect(red, grn, blu);
-    }
-}
-
-void RGBController_Aura::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            if (GetMode() == 0)
-            {
-                aura->SetLEDColorDirect(zones[zone].map[x][y], red, grn, blu);
-            }
-            else
-            {
-                aura->SetLEDColorEffect(zones[zone].map[x][y], red, grn, blu);
-            }
-        }
-    }
-}
-
-void RGBController_Aura::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetLEDColorDirect(led, red, grn, blu);
-    }
-    else
-    {
-        aura->SetLEDColorEffect(led, red, grn, blu);
-    }
-}
-
 void RGBController_Aura::UpdateLEDs()
 {
     for(std::size_t led = 0; led < colors.size(); led++)
@@ -112,6 +58,47 @@ void RGBController_Aura::UpdateLEDs()
     }
 }
 
+void RGBController_Aura::UpdateZoneLEDs(int zone)
+{
+    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    {
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            int           led   = zones[zone].map[x][y];
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+
+            if (GetMode() == 0)
+            {
+                aura->SetLEDColorDirect(led, red, grn, blu);
+            }
+            else
+            {
+                aura->SetLEDColorEffect(led, red, grn, blu);
+            }
+        }
+    }
+}
+
+void RGBController_Aura::UpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    if (GetMode() == 0)
+    {
+        aura->SetLEDColorDirect(led, red, grn, blu);
+    }
+    else
+    {
+        aura->SetLEDColorEffect(led, red, grn, blu);
+    }
+}
+
 RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
 {
     std::vector<unsigned char> aura_channels;
@@ -154,6 +141,8 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         modes.push_back(aura_modes[i]);
     }
 
+    colors.resize(aura->GetLEDCount());
+
     for (std::size_t i = 0; i < aura->GetLEDCount(); i++)
     {
         aura_channels.push_back(aura->GetChannel(i));
@@ -163,7 +152,12 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         new_led->name = aura->GetChannelName(i);
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
+
+        unsigned char red = aura->GetLEDRed(i);
+        unsigned char grn = aura->GetLEDGreen(i);
+        unsigned char blu = aura->GetLEDBlue(i);
+
+        colors[i] = ToRGBColor(red, grn, blu);
     }
 
     std::vector<unsigned char> aura_zones;

RGBController/RGBController_Aura.h

@@ -16,14 +16,13 @@ class RGBController_Aura : public RGBController
 {
 public:
     RGBController_Aura(AuraController* aura_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     AuraController* aura;
-};
+};

RGBController/RGBController_Corsair.cpp

@@ -24,42 +24,24 @@ void RGBController_Corsair::SetCustomMode()
 
 }
 
-void RGBController_Corsair::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-}
-
-void RGBController_Corsair::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
-    }
-}
-
-void RGBController_Corsair::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_Corsair::UpdateLEDs()
 {
+    RGBColor      color = colors[0];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
+    corsair->SetLEDColor(red, grn, blu);
+}
+
+void RGBController_Corsair::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Corsair::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
 }
 
 RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)

RGBController/RGBController_Corsair.h

@@ -16,13 +16,12 @@ class RGBController_Corsair : public RGBController
 {
 public:
     RGBController_Corsair(CorsairController* corsair_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     CorsairController* corsair;

RGBController/RGBController_CorsairPro.cpp

@@ -56,48 +56,36 @@ void RGBController_CorsairPro::SetCustomMode()
     corsair->SetCustom();
 }
 
-void RGBController_CorsairPro::SetAllLEDs(RGBColor color)
+void RGBController_CorsairPro::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-    corsair->ApplyColors();
-}
-
-void RGBController_CorsairPro::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+        corsair->SetLEDColor(led, red, grn, blu);
     }
 
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::SetLED(int led, RGBColor color)
+void RGBController_CorsairPro::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    UpdateLEDs();
+}
+
+void RGBController_CorsairPro::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     corsair->SetLEDColor(led, red, grn, blu);
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::UpdateLEDs()
-{
-
-}
-
 RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair_ptr)
 {
     corsair = corsair_ptr;
@@ -125,6 +113,8 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
         modes.push_back(corsair_modes[i]);
     }
 
+    colors.resize(corsair->GetLEDCount());
+
     for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
@@ -132,7 +122,6 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
         new_led->name = "Corsair Pro LED";
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
     }
 
     zone new_zone;

RGBController/RGBController_CorsairPro.h

@@ -16,14 +16,13 @@ class RGBController_CorsairPro : public RGBController
 {
 public:
     RGBController_CorsairPro(CorsairProController* corsair_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     CorsairProController* corsair;
-};
+};

RGBController/RGBController_E131.cpp

@@ -101,36 +101,6 @@ void RGBController_E131::SetCustomMode()
 
 }
 
-void RGBController_E131::SetAllLEDs(RGBColor color)
-{
-    for (std::size_t i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-	UpdateLEDs();
-}
-
-void RGBController_E131::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-	UpdateLEDs();
-}
-
-void RGBController_E131::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-	UpdateLEDs();
-}
-
 void RGBController_E131::UpdateLEDs()
 {
     int color_idx = 0;
@@ -187,7 +157,17 @@ void RGBController_E131::UpdateLEDs()
 
     for(std::size_t packet_idx = 0; packet_idx < packets.size(); packet_idx++)
     {
-	    e131_send(sockfd, &packets[packet_idx], &dest_addrs[packet_idx]);
+        e131_send(sockfd, &packets[packet_idx], &dest_addrs[packet_idx]);
         packets[packet_idx].frame.seq_number++;
     }
 }
+
+void RGBController_E131::UpdateZoneLEDs(int zone)
+{
+	UpdateLEDs();
+}
+
+void RGBController_E131::UpdateSingleLED(int led)
+{
+	UpdateLEDs();
+}

RGBController/RGBController_E131.h

@@ -37,13 +37,12 @@ class RGBController_E131 : public RGBController
 {
 public:
     RGBController_E131(std::vector<E131Device> device_list);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
 	std::vector<E131Device> 	devices;
@@ -51,4 +50,4 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-};
+};

RGBController/RGBController_Hue2.cpp

@@ -21,8 +21,20 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
-    unsigned int led_idx = 0;
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += hue2->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
 
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
     for (unsigned int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
     {
         if(hue2->channel_leds[channel_idx] > 0)
@@ -40,8 +52,6 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
 
             for (unsigned int led_ch_idx = 0; led_ch_idx < hue2->channel_leds[channel_idx]; led_ch_idx++)
             {
-                colors.push_back(0x00000000);
-
                 char led_idx_string[3];
                 sprintf(led_idx_string, "%d", led_ch_idx + 1);
 
@@ -52,7 +62,7 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
                 new_led.name.append(led_idx_string);
 
                 leds.push_back(new_led);
-                leds_channel.push_back(channel_idx + 1);
+                leds_channel.push_back(channel_idx);
 
                 new_zone_map->push_back(led_idx);
                 led_idx++;
@@ -60,7 +70,7 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
 
             new_zone->map.push_back(*new_zone_map);
             zones.push_back(*new_zone);
-            zones_channel.push_back(channel_idx + 1);
+            zones_channel.push_back(channel_idx);
         }
     }
 }
@@ -80,64 +90,14 @@ void RGBController_Hue2::SetCustomMode()
 
 }
 
-void RGBController_Hue2::SetAllLEDs(RGBColor color)
-{
-    for (std::size_t i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_Hue2::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned int channel = zones_channel[zone];
-
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    std::vector<RGBColor> channel_colors;
-
-    for(std::size_t color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-
-    hue2->SetChannelLEDs(channel, channel_colors);
-}
-
-void RGBController_Hue2::SetLED(int led, RGBColor color)
-{
-    unsigned int channel = leds_channel[led];
-    colors[led] = color;
-
-    std::vector<RGBColor> channel_colors;
-
-    for(std::size_t color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-    hue2->SetChannelLEDs(channel, channel_colors);
-}
-
 void RGBController_Hue2::UpdateLEDs()
 {
-    std::vector<RGBColor> channel_colors;
-
-    for(unsigned int channel = 0; channel < HUE_2_NUM_CHANNELS; channel++)
+    for(std::size_t zone_idx = 0; zone_idx <= zones.size(); zone_idx++)
     {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
         for(std::size_t color = 0; color < colors.size(); color++)
         {
             if(leds_channel[color] == channel)
@@ -150,7 +110,45 @@ void RGBController_Hue2::UpdateLEDs()
         {
             hue2->SetChannelLEDs(channel, channel_colors);
         }
+    }
+}
 
-        channel_colors.clear();
+void RGBController_Hue2::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hue2->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_Hue2::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hue2->SetChannelLEDs(channel, channel_colors);
     }
 }

RGBController/RGBController_Hue2.h

@@ -15,16 +15,15 @@ class RGBController_Hue2 : public RGBController
 {
 public:
     RGBController_Hue2(Hue2Controller* hue2_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     Hue2Controller*             hue2;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
-};
+};

RGBController/RGBController_HuePlus.cpp

@@ -23,8 +23,20 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
-    unsigned int led_idx = 0;
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += hueplus->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
 
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
     for (int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
     {
         if(hueplus->channel_leds[channel_idx] > 0)
@@ -42,8 +54,6 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
 
             for (unsigned led_ch_idx = 0; led_ch_idx < hueplus->channel_leds[channel_idx]; led_ch_idx++)
             {
-                colors.push_back(0x00000000);
-
                 char led_idx_string[3];
                 sprintf(led_idx_string, "%d", led_ch_idx + 1);
 
@@ -82,28 +92,33 @@ void RGBController_HuePlus::SetCustomMode()
 
 }
 
-void RGBController_HuePlus::SetAllLEDs(RGBColor color)
+void RGBController_HuePlus::UpdateLEDs()
 {
-    for (std::size_t i = 0; i < colors.size(); i++)
+    for(std::size_t zone_idx = 0; zone_idx <= zones.size(); zone_idx++)
     {
-        colors[i] = color;
-    }
+        unsigned int channel = zones_channel[zone_idx];
 
-    hueplus->SetChannelLEDs(0, colors);
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            hueplus->SetChannelLEDs(channel, channel_colors);
+        }
+    }
 }
 
-void RGBController_HuePlus::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_HuePlus::UpdateZoneLEDs(int zone)
 {
     unsigned int channel = zones_channel[zone];
 
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
     std::vector<RGBColor> channel_colors;
 
     for(std::size_t color = 0; color < colors.size(); color++)
@@ -114,13 +129,15 @@ void RGBController_HuePlus::SetAllZoneLEDs(int zone, RGBColor color)
         }
     }
 
-    hueplus->SetChannelLEDs(channel, channel_colors);
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
 }
 
-void RGBController_HuePlus::SetLED(int led, RGBColor color)
+void RGBController_HuePlus::UpdateSingleLED(int led)
 {
     unsigned int channel = leds_channel[led];
-    colors[led] = color;
 
     std::vector<RGBColor> channel_colors;
 
@@ -131,10 +148,9 @@ void RGBController_HuePlus::SetLED(int led, RGBColor color)
             channel_colors.push_back(colors[color]);
         }
     }
-    hueplus->SetChannelLEDs(channel, channel_colors);
-}
 
-void RGBController_HuePlus::UpdateLEDs()
-{
-    hueplus->SetChannelLEDs(0, colors);
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
 }

RGBController/RGBController_HuePlus.h

@@ -15,16 +15,15 @@ class RGBController_HuePlus : public RGBController
 {
 public:
     RGBController_HuePlus(HuePlusController* hueplus_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     HuePlusController*          hueplus;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
-};
+};

RGBController/RGBController_HyperX.cpp

@@ -24,50 +24,67 @@ void RGBController_HyperX::SetCustomMode()
     hyperx->SetMode(HYPERX_MODE_DIRECT);
 }
 
-void RGBController_HyperX::SetAllLEDs(RGBColor color)
+void RGBController_HyperX::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
     if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
     {
-        hyperx->SetAllColors(red, grn, blu);
+        for (std::size_t zone = 0; zone < zones.size(); zone++ )
+        {
+            for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+            {
+                for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+                {
+                    int           led   = zones[zone].map[x][y];
+                    RGBColor      color = colors[led];
+                    unsigned char red = RGBGetRValue(color);
+                    unsigned char grn = RGBGetGValue(color);
+                    unsigned char blu = RGBGetBValue(color);
+                    hyperx->SetLEDColor(led, red, grn, blu);
+                }
+            }
+        }
     }
     else
     {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
         hyperx->SetEffectColor(red, grn, blu);
     }
-    
 }
 
-void RGBController_HyperX::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_HyperX::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
     if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
     {
         for (std::size_t x = 0; x < zones[zone].map.size(); x++)
         {
             for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
             {
-                hyperx->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
+                int           led   = zones[zone].map[x][y];
+                RGBColor      color = colors[led];
+                unsigned char red = RGBGetRValue(color);
+                unsigned char grn = RGBGetGValue(color);
+                unsigned char blu = RGBGetBValue(color);
+                hyperx->SetLEDColor(led, red, grn, blu);
             }
         }
     }
     else
     {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
         hyperx->SetEffectColor(red, grn, blu);
     }
 }
 
-void RGBController_HyperX::SetLED(int led, RGBColor color)
+void RGBController_HyperX::UpdateSingleLED(int led)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
     {
@@ -79,11 +96,6 @@ void RGBController_HyperX::SetLED(int led, RGBColor color)
     }
 }
 
-void RGBController_HyperX::UpdateLEDs()
-{
-    
-}
-
 RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
 {
     hyperx = hyperx_ptr;

RGBController/RGBController_HyperX.h

@@ -16,14 +16,13 @@ class RGBController_HyperX : public RGBController
 {
 public:
     RGBController_HyperX(HyperXController* hyperx_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     HyperXController* hyperx;
-};
+};

RGBController/RGBController_LEDStrip.cpp

@@ -56,34 +56,17 @@ void RGBController_LEDStrip::SetCustomMode()
 
 }
 
-void RGBController_LEDStrip::SetAllLEDs(RGBColor color)
-{
-    for (std::size_t i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetAllZoneLEDs(int /*zone*/, RGBColor color)
-{
-    for (std::size_t i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    strip->SetLEDs(colors);
-}
-
 void RGBController_LEDStrip::UpdateLEDs()
 {
     strip->SetLEDs(colors);
 }
+
+void RGBController_LEDStrip::UpdateZoneLEDs(int zone)
+{
+    strip->SetLEDs(colors);
+}
+
+void RGBController_LEDStrip::UpdateSingleLED(int led)
+{
+    strip->SetLEDs(colors);
+}

RGBController/RGBController_LEDStrip.h

@@ -16,14 +16,14 @@ class RGBController_LEDStrip : public RGBController
 {
 public:
     RGBController_LEDStrip(LEDStripController* ledstrip_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
 
 private:
     LEDStripController* strip;
-};
+};

RGBController/RGBController_OpenRazer.cpp

@@ -187,33 +187,13 @@ void RGBController_OpenRazer::UpdateLEDs()
     }
 }
 
-void RGBController_OpenRazer::SetAllLEDs(RGBColor color)
+void RGBController_OpenRazer::UpdateZoneLEDs(int zone)
 {
-    for(std::size_t i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
     UpdateLEDs();
 }
 
-void RGBController_OpenRazer::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_OpenRazer::UpdateSingleLED(int led)
 {
-    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_OpenRazer::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
     UpdateLEDs();
 }
 

RGBController/RGBController_OpenRazer.h

@@ -920,13 +920,12 @@ public:
 
 public:
     RGBController_OpenRazer(std::string dev_path);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     int device;
 
@@ -953,4 +952,4 @@ private:
     std::ofstream logo_led_rgb;
     std::ofstream scroll_led_effect;
     std::ofstream scroll_led_rgb;
-};
+};

RGBController/RGBController_PatriotViper.cpp

@@ -31,56 +31,43 @@ void RGBController_PatriotViper::SetCustomMode()
     viper->SetDirect();
 }
 
-void RGBController_PatriotViper::SetAllLEDs(RGBColor color)
+void RGBController_PatriotViper::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
     if(viper->direct == true)
     {
-        viper->SetAllColors(red, grn, blu);
-    }
-    else
-    {
-        viper->SetEffectColor(red, grn, blu);
-    }
-    
-}
-
-void RGBController_PatriotViper::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if(viper->direct == true)
-    {
-        for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+        for(int led = 0; led < 5; led++)
         {
-            for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-            {
-                viper->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-            }
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDColor(led, red, grn, blu);
         }
     }
     else
     {
-        for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+        for(int led = 0; led < 5; led++)
         {
-            for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
-            {
-                viper->SetLEDEffectColor(zones[zone].map[x][y], red, grn, blu);
-            }
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDEffectColor(led, red, grn, blu);
         }
     }
 }
 
-void RGBController_PatriotViper::SetLED(int led, RGBColor color)
+void RGBController_PatriotViper::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    UpdateLEDs();
+}
+
+void RGBController_PatriotViper::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     if(viper->direct == true)
     {
@@ -92,11 +79,6 @@ void RGBController_PatriotViper::SetLED(int led, RGBColor color)
     }
 }
 
-void RGBController_PatriotViper::UpdateLEDs()
-{
-    
-}
-
 RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* viper_ptr)
 {
     viper = viper_ptr;

RGBController/RGBController_PatriotViper.h

@@ -16,14 +16,13 @@ class RGBController_PatriotViper : public RGBController
 {
 public:
     RGBController_PatriotViper(PatriotViperController* viper_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     PatriotViperController* viper;
-};
+};

RGBController/RGBController_Polychrome.cpp

@@ -24,33 +24,6 @@ void RGBController_Polychrome::SetCustomMode()
     polychrome->SetMode(POLYCHROME_MODE_STATIC);
 }
 
-void RGBController_Polychrome::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetAllColors(red, grn, blu);
-}
-
-void RGBController_Polychrome::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetLEDColor(zone, red, grn, blu);
-}
-
-void RGBController_Polychrome::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_Polychrome::UpdateLEDs()
 {
     for (std::size_t led = 0; led < colors.size(); led++)
@@ -63,6 +36,16 @@ void RGBController_Polychrome::UpdateLEDs()
     }
 }
 
+void RGBController_Polychrome::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Polychrome::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
 static const char* polychrome_zone_names[] =
 {
     "Motherboard"
@@ -105,6 +88,7 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
 
         // Push new LED to LEDs vector
         leds.push_back(*new_led);
+        colors.push_back(0x00000000);
 
         // Push new zone to zones vector
         zones.push_back(*new_zone);

RGBController/RGBController_Polychrome.h

@@ -16,14 +16,13 @@ class RGBController_Polychrome : public RGBController
 {
 public:
     RGBController_Polychrome(PolychromeController* polychrome_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     PolychromeController* polychrome;
-};
+};

RGBController/RGBController_RGBFusion.cpp

@@ -24,45 +24,34 @@ void RGBController_RGBFusion::SetCustomMode()
     rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC);
 }
 
-void RGBController_RGBFusion::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-    
-    rgb_fusion->SetAllColors(red, grn, blu);
-}
-
-void RGBController_RGBFusion::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    rgb_fusion->SetLEDColor(zone, red, grn, blu);
-}
-
-void RGBController_RGBFusion::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-    
-    rgb_fusion->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_RGBFusion::UpdateLEDs()
 {
     for (std::size_t led = 0; led < colors.size(); led++)
     {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
 
         rgb_fusion->SetLEDColor(led, red, grn, blu);
     }
 }
 
+void RGBController_RGBFusion::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    rgb_fusion->SetLEDColor(zone, red, grn, blu);
+}
+
+void RGBController_RGBFusion::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
 static const char* rgb_fusion_zone_names[] =
 {
     "Motherboard",
@@ -110,6 +99,7 @@ RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* rgb_fusion
 
         // Push new LED to LEDs vector
         leds.push_back(*new_led);
+        colors.push_back(0x00000000);
 
         // Push new zone to zones vector
         zones.push_back(*new_zone);

RGBController/RGBController_RGBFusion.h

@@ -16,14 +16,13 @@ class RGBController_RGBFusion : public RGBController
 {
 public:
     RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     RGBFusionController* rgb_fusion;
-};
+};

RGBController/RGBController_RazerChromaSDK.cpp

@@ -85,36 +85,6 @@ void RGBController_RazerChromaSDK::SetCustomMode()
 
 }
 
-void RGBController_RazerChromaSDK::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    UpdateLEDs();
-}
-
 void RGBController_RazerChromaSDK::UpdateLEDs()
 {
     switch (device->razer_type)
@@ -189,3 +159,13 @@ void RGBController_RazerChromaSDK::UpdateLEDs()
         break;
     }
 }
+
+void RGBController_RazerChromaSDK::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}

RGBController/RGBController_RazerChromaSDK.h

@@ -229,13 +229,12 @@ class RGBController_RazerChromaSDK : public RGBController
 {
 public:
     RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     const razer_device* device;

i2c_smbus/i2c_smbus.cpp

@@ -9,6 +9,17 @@
 #include "i2c_smbus.h"
 #include <string.h>
 
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
 s32 i2c_smbus_interface::i2c_smbus_write_quick(u8 addr, u8 value)
 {
     return i2c_smbus_xfer(addr, value, 0, I2C_SMBUS_QUICK, NULL);
@@ -128,3 +139,18 @@ s32 i2c_smbus_interface::i2c_smbus_write_i2c_block_data(u8 addr, u8 command, u8
     memcpy(&data.block[1], values, length);
     return i2c_smbus_xfer(addr, I2C_SMBUS_WRITE, command, I2C_SMBUS_I2C_BLOCK_DATA, &data);
 }
+
+void i2c_smbus_interface::i2c_smbus_wait_and_lock()
+{
+    while(lock == true)
+    {
+        Sleep(1);
+    }
+
+    lock = true;
+}
+
+void i2c_smbus_interface::i2c_smbus_unlock()
+{
+    lock = false;
+}

i2c_smbus/i2c_smbus.h

@@ -69,8 +69,14 @@ public:
     s32 i2c_smbus_read_i2c_block_data(u8 addr, u8 command, u8 length, u8 *values);
     s32 i2c_smbus_write_i2c_block_data(u8 addr, u8 command, u8 length, const u8 *values);
 
+    void i2c_smbus_wait_and_lock();
+    void i2c_smbus_unlock();
+
     //Virtual function to be implemented by the driver
     virtual s32 i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data) = 0;
+
+private:
+    bool lock = false;
 };
 
 #endif /* I2C_SMBUS_H */

qt/OpenRGBDevicePage.cpp

@@ -90,6 +90,11 @@ OpenRGBDevicePage::OpenRGBDevicePage(RGBController *dev, QWidget *parent) :
     }
 
     ui->LEDBox->setCurrentIndex(0);
+
+    /*-----------------------------------------------------*\
+    | Update color picker with color of first LED           |
+    \*-----------------------------------------------------*/
+    on_LEDBox_currentIndexChanged(0);
 }
 
 OpenRGBDevicePage::~OpenRGBDevicePage()
@@ -102,9 +107,18 @@ void Ui::OpenRGBDevicePage::on_ZoneBox_currentIndexChanged(int /*index*/)
 
 }
 
-void Ui::OpenRGBDevicePage::on_LEDBox_currentIndexChanged(int /*index*/)
+void Ui::OpenRGBDevicePage::on_LEDBox_currentIndexChanged(int index)
 {
-
+    /*-----------------------------------------------------*\
+    | Update color picker with color of selected LED        |
+    \*-----------------------------------------------------*/
+    RGBColor color = device->GetLED(index);
+    UpdatingColor = true;
+    ui->RedSpinBox->setValue(RGBGetRValue(color));
+    ui->GreenSpinBox->setValue(RGBGetGValue(color));
+    ui->BlueSpinBox->setValue(RGBGetBValue(color));
+    UpdatingColor = false;
+    updateHSV();
 }
 
 void Ui::OpenRGBDevicePage::on_ModeBox_currentIndexChanged(int /*index*/)

qt/OpenRGBDialog2.cpp

@@ -14,6 +14,62 @@ OpenRGBDialog2::OpenRGBDialog2(std::vector<i2c_smbus_interface *>& bus, std::vec
     QIcon logo(":OpenRGB.png");
     setWindowIcon(logo);
 
+    /*-----------------------------------------------------*\
+    | Set up tray icon menu                                 |
+    \*-----------------------------------------------------*/
+    QMenu* trayIconMenu = new QMenu( this );
+
+    trayIcon = new QSystemTrayIcon(this);
+
+    QAction* actionShowHide = new QAction("Show/Hide", this);
+    connect(actionShowHide, SIGNAL(triggered()), this, SLOT(on_ShowHide()));
+    trayIconMenu->addAction(actionShowHide);
+
+    QMenu* quickColorsMenu = new QMenu("Quick Colors", this);
+
+    QAction* actionQuickRed = new QAction("Red", this);
+    connect(actionQuickRed, SIGNAL(triggered()), this, SLOT(on_QuickRed()));
+    quickColorsMenu->addAction(actionQuickRed);
+
+    QAction* actionQuickYellow = new QAction("Yellow", this);
+    connect(actionQuickYellow, SIGNAL(triggered()), this, SLOT(on_QuickYellow()));
+    quickColorsMenu->addAction(actionQuickYellow);
+
+    QAction* actionQuickGreen = new QAction("Green", this);
+    connect(actionQuickGreen, SIGNAL(triggered()), this, SLOT(on_QuickGreen()));
+    quickColorsMenu->addAction(actionQuickGreen);
+
+    QAction* actionQuickCyan = new QAction("Cyan", this);
+    connect(actionQuickCyan, SIGNAL(triggered()), this, SLOT(on_QuickCyan()));
+    quickColorsMenu->addAction(actionQuickCyan);
+
+    QAction* actionQuickBlue = new QAction("Blue", this);
+    connect(actionQuickBlue, SIGNAL(triggered()), this, SLOT(on_QuickBlue()));
+    quickColorsMenu->addAction(actionQuickBlue);
+    
+    QAction* actionQuickMagenta = new QAction("Magenta", this);
+    connect(actionQuickMagenta, SIGNAL(triggered()), this, SLOT(on_QuickMagenta()));
+    quickColorsMenu->addAction(actionQuickMagenta);
+
+    QAction* actionQuickWhite = new QAction("White", this);
+    connect(actionQuickWhite, SIGNAL(triggered()), this, SLOT(on_QuickWhite()));
+    quickColorsMenu->addAction(actionQuickWhite);
+
+    trayIconMenu->addMenu(quickColorsMenu);
+
+    QAction* actionLightsOff = new QAction("Lights Off", this);
+    connect(actionLightsOff, SIGNAL(triggered()), this, SLOT(on_LightsOff()));
+    trayIconMenu->addAction(actionLightsOff);
+
+    QAction* actionExit = new QAction( "Exit", this );
+    connect( actionExit, SIGNAL( triggered() ), this, SLOT( on_Exit() ));
+    trayIconMenu->addAction(actionExit);
+
+    trayIcon->setIcon(logo);
+    trayIcon->setToolTip("OpenRGB");
+    trayIcon->setContextMenu(trayIconMenu);
+    trayIcon->show();
+
     /*-----------------------------------------------------*\
     | Set up list of devices                                |
     \*-----------------------------------------------------*/
@@ -156,6 +212,51 @@ void OpenRGBDialog2::show()
     QMainWindow::show();
 }
 
+void OpenRGBDialog2::on_Exit()
+{
+    close();
+}
+
+void OpenRGBDialog2::on_LightsOff()
+{
+    on_SetAllDevices(0x00, 0x00, 0x00);
+}
+
+void OpenRGBDialog2::on_QuickRed()
+{
+    on_SetAllDevices(0xFF, 0x00, 0x00);
+}
+
+void OpenRGBDialog2::on_QuickYellow()
+{
+    on_SetAllDevices(0xFF, 0xFF, 0x00);
+}
+
+void OpenRGBDialog2::on_QuickGreen()
+{
+    on_SetAllDevices(0x00, 0xFF, 0x00);
+}
+
+void OpenRGBDialog2::on_QuickCyan()
+{
+    on_SetAllDevices(0x00, 0xFF, 0xFF);
+}
+
+void OpenRGBDialog2::on_QuickBlue()
+{
+    on_SetAllDevices(0x00, 0x00, 0xFF);
+}
+
+void OpenRGBDialog2::on_QuickMagenta()
+{
+    on_SetAllDevices(0xFF, 0x00, 0xFF);
+}
+
+void OpenRGBDialog2::on_QuickWhite()
+{
+    on_SetAllDevices(0xFF, 0xFF, 0xFF);
+}
+
 void OpenRGBDialog2::on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue)
 {
     for(int device = 0; device < ui->DevicesTabBar->count(); device++)
@@ -163,3 +264,15 @@ void OpenRGBDialog2::on_SetAllDevices(unsigned char red, unsigned char green, un
         qobject_cast<OpenRGBDevicePage *>(ui->DevicesTabBar->widget(device))->SetDevice(red, green, blue);
     }
 }
+
+void OpenRGBDialog2::on_ShowHide()
+{
+    if(isHidden())
+    {
+        show();
+    }
+    else
+    {
+        hide();
+    }
+}

qt/OpenRGBDialog2.h

@@ -34,9 +34,20 @@ protected:
 
 private:
     Ui::OpenRGBDialog2Ui *ui;
+    QSystemTrayIcon* trayIcon;
 
 private slots:
+    void on_Exit();
+    void on_LightsOff();
+    void on_QuickRed();
+    void on_QuickYellow();
+    void on_QuickGreen();
+    void on_QuickCyan();
+    void on_QuickBlue();
+    void on_QuickMagenta();
+    void on_QuickWhite();
     void on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue);
+    void on_ShowHide();
 };
 
 #endif // OPENRGBDIALOG2_H

serial_port/find_usb_serial_port_linux.cpp

@@ -1,5 +1,8 @@
 #include "find_usb_serial_port.h"
 
+#include <unistd.h>
+#include <dirent.h>
+
 /*---------------------------------------------------------------------*\
 |                                                                       |
 |   find_usb_serial_port                                                |
@@ -30,7 +33,7 @@ std::string find_usb_serial_port(unsigned short vid, unsigned short pid)
     if(dir == NULL)
     {
         closedir(dir);
-        return false;
+        return ret_string;
     }
 
     /*-----------------------------------------------------------------*\
@@ -85,7 +88,7 @@ std::string find_usb_serial_port(unsigned short vid, unsigned short pid)
 
                 snprintf(vid_pid, 10, "%04x", vid);
 
-                if((strcmp(vid_pid, vendor_string.c_str()) == 0)
+                if(strcmp(vid_pid, vendor_string.c_str()) == 0)
                 {
                     snprintf(vid_pid, 10, "%04x", pid);
                     if(strcmp(vid_pid, product_string.c_str()) == 0)