Add functions to get serial port path from USB VID/PID for both Windows and Linux

Controllers/AuraController/AuraController.cpp

@@ -157,21 +157,6 @@ 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];
@@ -244,45 +229,30 @@ 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,9 +99,6 @@ 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,28 +44,25 @@ unsigned int CorsairController::GetLEDCount()
     return(led_count);
 }
 
-void CorsairController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::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, 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::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);
 }
 
 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,7 +44,8 @@ public:
     unsigned int    GetLEDCount();
     void            SetMode(unsigned char mode);
 
-    void            SetLEDColor(unsigned char red, unsigned char green, unsigned char blue);
+    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);
 
 private:
     char                    device_name[32];

Controllers/CorsairProController/CorsairProController.cpp

@@ -81,9 +81,6 @@ 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);
@@ -98,16 +95,10 @@ 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);
@@ -136,9 +127,6 @@ 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,11 +64,6 @@ 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;
             }
@@ -78,60 +73,6 @@ 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[] =
@@ -180,8 +121,8 @@ void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor>
     /*-----------------------------------------------------*\
     | Set channel in USB packets                            |
     \*-----------------------------------------------------*/
-    usb_buf[0x02]   = 1 << channel;
-    usb_apply[0x02] = 1 << channel;
+    usb_buf[0x02]   = channel;
+    usb_apply[0x02] = channel;
 
     /*-----------------------------------------------------*\
     | Send first packet for first 20 LEDs                   |
@@ -211,7 +152,7 @@ void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor>
     }
     
     usb_buf[0x01] = 0x11;
-    pkt_max       = 0;
+    pkt_max       = 20;
 
     if (colors.size() > 20)
     {

Controllers/Hue2Controller/Hue2Controller.h

@@ -49,9 +49,8 @@ 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,162 +48,67 @@ char* HuePlusController::GetLEDString()
 
 unsigned int HuePlusController::GetStripsOnChannel(unsigned int channel)
 {
-    unsigned char serial_buf[] =
-    {
-        0x8D, 0x00, 0x00, 0x00, 0x00
-    };
-
     unsigned int ret_val = 0;
 
-    /*-----------------------------------------------------*\
-    | 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)
+    if (serialport != NULL)
     {
-        ret_val = serial_buf[4];
+        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;
     }
 
     return(ret_val);
 }
 
-void HuePlusController::SetChannelEffect(unsigned int channel, unsigned int mode, 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]   = mode;
-
-    /*-----------------------------------------------------*\
-    | 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[] =
+    if (serialport != NULL)
     {
-        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
-    };
+        unsigned char *serial_buf;
 
-    /*-----------------------------------------------------*\
-    | Set channel in serial packet                          |
-    \*-----------------------------------------------------*/
-    serial_buf[0x01]   = channel;
+        serial_buf = new unsigned char[HUE_PLUS_PACKET_SIZE];
 
-    /*-----------------------------------------------------*\
-    | Set mode in serial packet                             |
-    \*-----------------------------------------------------*/
-    serial_buf[0x02]   = HUE_PLUS_MODE_FIXED;
+        serial_buf[0] = 0x4B;
+        serial_buf[1] = channel;
+        serial_buf[2] = HUE_PLUS_MODE_FIXED;				
+        serial_buf[3] = 0x00; 
+        serial_buf[4] = 0x00;
 
-    /*-----------------------------------------------------*\
-    | 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);
+        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;
     }
 
-    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
-    serialport->serial_flush_tx();
-
-    Sleep(10);
 }

Controllers/HuePlusController/HuePlusController.h

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

Controllers/HyperXController/HyperXController.cpp

@@ -78,9 +78,6 @@ 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  );
@@ -90,16 +87,10 @@ 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);
 
     /*-----------------------------------------------------*\
@@ -133,9 +124,6 @@ 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)
@@ -175,9 +163,6 @@ 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  );
@@ -187,9 +172,6 @@ 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();
 }
 
 
@@ -201,9 +183,6 @@ 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  );
@@ -213,18 +192,12 @@ 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)
@@ -268,7 +241,4 @@ 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,9 +76,6 @@ 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);
 
@@ -91,16 +88,10 @@ 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);
 
@@ -111,32 +102,20 @@ 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);
 
@@ -145,32 +124,20 @@ 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);
 
@@ -179,9 +146,6 @@ 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)
@@ -189,32 +153,19 @@ 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,9 +63,6 @@ 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);
@@ -77,8 +74,6 @@ 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)
@@ -88,48 +83,30 @@ 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,13 +24,6 @@ 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,7 +26,6 @@ INCLUDEPATH +=                                                          \
     qt/
 
 SOURCES +=                                                              \
-    RGBController/RGBController.cpp \
     dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
     OpenRGB.cpp                                                         \

RGBController/RGBController.cpp

@@ -1,46 +0,0 @@
-#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,21 +79,11 @@ public:
 
     virtual ~RGBController() = default;
 
-    /*---------------------------------------------------------*\
-    | 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;
+    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;
 };

RGBController/RGBController_AMDWraithPrism.cpp

@@ -24,7 +24,6 @@ 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";
@@ -37,7 +36,6 @@ 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";
@@ -50,7 +48,6 @@ 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";
@@ -81,30 +78,22 @@ void RGBController_AMDWraithPrism::SetCustomMode()
 
 }
 
-void RGBController_AMDWraithPrism::UpdateLEDs()
+void RGBController_AMDWraithPrism::SetAllLEDs(RGBColor color)
 {
-    unsigned char red = RGBGetRValue(colors[0]);
-    unsigned char grn = RGBGetGValue(colors[0]);
-    unsigned char blu = RGBGetBValue(colors[0]);
-    wraith->SetLogoColor(red, grn, blu);
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
 
-    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->SetLogoColor(red, grn, blu);
     wraith->SetRingColor(red, grn, blu);
 }
 
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+void RGBController_AMDWraithPrism::SetAllZoneLEDs(int zone, RGBColor color)
 {
-    RGBColor      color = colors[zone];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(color);
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
 
     if(zone == 0)
     {
@@ -120,7 +109,27 @@ void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
     }
 }
 
-void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
+void RGBController_AMDWraithPrism::SetLED(int led, RGBColor color)
 {
-    UpdateZoneLEDs(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()
+{
+
 }

RGBController/RGBController_AMDWraithPrism.h

@@ -16,13 +16,14 @@ class RGBController_AMDWraithPrism : public RGBController
 public:
     RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr);
     ~RGBController_AMDWraithPrism();
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     AMDWraithPrismController*   wraith;
-};
+};

RGBController/RGBController_AorusGPU.cpp

@@ -35,9 +35,8 @@ void RGBController_AorusGPU::SetCustomMode()
 
 }
 
-void RGBController_AorusGPU::UpdateLEDs()
+void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
 {
-    RGBColor color = colors[0];
     data[9] = RGBGetRValue(color);
     data[10] = RGBGetGValue(color);
     data[11] = RGBGetBValue(color);
@@ -45,14 +44,27 @@ void RGBController_AorusGPU::UpdateLEDs()
     GvWriteI2C(0x00000000, data, 0x00000000);
 }
 
-void RGBController_AorusGPU::UpdateZoneLEDs(int zone)
+void RGBController_AorusGPU::SetAllZoneLEDs(int zone, RGBColor color)
 {
-    UpdateLEDs();
+    data[9] = RGBGetRValue(color);
+    data[10] = RGBGetGValue(color);
+    data[11] = RGBGetBValue(color);
+
+    GvWriteI2C(0x00000000, data, 0x00000000);
 }
 
-void RGBController_AorusGPU::UpdateSingleLED(int led)
+void RGBController_AorusGPU::SetLED(int led, RGBColor color)
 {
-    UpdateLEDs();
+    data[9] = RGBGetRValue(color);
+    data[10] = RGBGetGValue(color);
+    data[11] = RGBGetBValue(color);
+
+    GvWriteI2C(0x00000000, data, 0x00000000);
+}
+
+void RGBController_AorusGPU::UpdateLEDs()
+{
+
 }
 
 RGBController_AorusGPU::RGBController_AorusGPU()
@@ -69,8 +81,6 @@ 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,12 +19,13 @@ class RGBController_AorusGPU : public RGBController
 {
 public:
     RGBController_AorusGPU();
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     _GvWriteI2C GvWriteI2C;

RGBController/RGBController_Aura.cpp

@@ -39,6 +39,60 @@ 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++)
@@ -58,47 +112,6 @@ 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;
@@ -141,8 +154,6 @@ 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));
@@ -152,12 +163,7 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         new_led->name = aura->GetChannelName(i);
 
         leds.push_back(*new_led);
-
-        unsigned char red = aura->GetLEDRed(i);
-        unsigned char grn = aura->GetLEDGreen(i);
-        unsigned char blu = aura->GetLEDBlue(i);
-
-        colors[i] = ToRGBColor(red, grn, blu);
+        colors.push_back(0x00000000);
     }
 
     std::vector<unsigned char> aura_zones;

RGBController/RGBController_Aura.h

@@ -16,13 +16,14 @@ class RGBController_Aura : public RGBController
 {
 public:
     RGBController_Aura(AuraController* aura_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     AuraController* aura;
-};
+};

RGBController/RGBController_Corsair.cpp

@@ -24,24 +24,42 @@ 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,12 +16,13 @@ class RGBController_Corsair : public RGBController
 {
 public:
     RGBController_Corsair(CorsairController* corsair_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     CorsairController* corsair;

RGBController/RGBController_CorsairPro.cpp

@@ -56,36 +56,48 @@ void RGBController_CorsairPro::SetCustomMode()
     corsair->SetCustom();
 }
 
-void RGBController_CorsairPro::UpdateLEDs()
+void RGBController_CorsairPro::SetAllLEDs(RGBColor color)
 {
-    for (std::size_t led = 0; led < colors.size(); led++)
+    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++)
     {
-        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);
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
+        }
     }
 
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::UpdateZoneLEDs(int zone)
+void RGBController_CorsairPro::SetLED(int led, RGBColor 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);
+    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;
@@ -113,8 +125,6 @@ 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();
@@ -122,6 +132,7 @@ 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,13 +16,14 @@ class RGBController_CorsairPro : public RGBController
 {
 public:
     RGBController_CorsairPro(CorsairProController* corsair_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     CorsairProController* corsair;
-};
+};

RGBController/RGBController_E131.cpp

@@ -101,6 +101,36 @@ 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;
@@ -157,17 +187,7 @@ 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,12 +37,13 @@ class RGBController_E131 : public RGBController
 {
 public:
     RGBController_E131(std::vector<E131Device> device_list);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
 	std::vector<E131Device> 	devices;
@@ -50,4 +51,4 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-};
+};

RGBController/RGBController_Hue2.cpp

@@ -21,20 +21,8 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
-    /*-------------------------------------------------*\
-    | 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)
@@ -52,6 +40,8 @@ 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);
 
@@ -62,7 +52,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);
+                leds_channel.push_back(channel_idx + 1);
 
                 new_zone_map->push_back(led_idx);
                 led_idx++;
@@ -70,7 +60,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);
+            zones_channel.push_back(channel_idx + 1);
         }
     }
 }
@@ -90,14 +80,64 @@ 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()
 {
-    for(std::size_t zone_idx = 0; zone_idx <= zones.size(); zone_idx++)
+    std::vector<RGBColor> channel_colors;
+
+    for(unsigned int channel = 0; channel < HUE_2_NUM_CHANNELS; channel++)
     {
-        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)
@@ -110,45 +150,7 @@ void RGBController_Hue2::UpdateLEDs()
         {
             hue2->SetChannelLEDs(channel, channel_colors);
         }
-    }
-}
 
-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);
+        channel_colors.clear();
     }
 }

RGBController/RGBController_Hue2.h

@@ -15,15 +15,16 @@ class RGBController_Hue2 : public RGBController
 {
 public:
     RGBController_Hue2(Hue2Controller* hue2_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     Hue2Controller*             hue2;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
-};
+};

RGBController/RGBController_HuePlus.cpp

@@ -23,20 +23,8 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
-    /*-------------------------------------------------*\
-    | 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)
@@ -54,6 +42,8 @@ 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);
 
@@ -92,33 +82,28 @@ void RGBController_HuePlus::SetCustomMode()
 
 }
 
-void RGBController_HuePlus::UpdateLEDs()
+void RGBController_HuePlus::SetAllLEDs(RGBColor color)
 {
-    for(std::size_t zone_idx = 0; zone_idx <= zones.size(); zone_idx++)
+    for (std::size_t i = 0; i < colors.size(); i++)
     {
-        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)
-            {
-                channel_colors.push_back(colors[color]);
-            }
-        }
-
-        if(channel_colors.size() > 0)
-        {
-            hueplus->SetChannelLEDs(channel, channel_colors);
-        }
+        colors[i] = color;
     }
+
+    hueplus->SetChannelLEDs(0, colors);
 }
 
-void RGBController_HuePlus::UpdateZoneLEDs(int zone)
+void RGBController_HuePlus::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++)
@@ -129,15 +114,13 @@ void RGBController_HuePlus::UpdateZoneLEDs(int zone)
         }
     }
 
-    if(channel_colors.size() > 0)
-    {
-        hueplus->SetChannelLEDs(channel, channel_colors);
-    }
+    hueplus->SetChannelLEDs(channel, channel_colors);
 }
 
-void RGBController_HuePlus::UpdateSingleLED(int led)
+void RGBController_HuePlus::SetLED(int led, RGBColor color)
 {
     unsigned int channel = leds_channel[led];
+    colors[led] = color;
 
     std::vector<RGBColor> channel_colors;
 
@@ -148,9 +131,10 @@ void RGBController_HuePlus::UpdateSingleLED(int led)
             channel_colors.push_back(colors[color]);
         }
     }
+    hueplus->SetChannelLEDs(channel, channel_colors);
+}
 
-    if(channel_colors.size() > 0)
-    {
-        hueplus->SetChannelLEDs(channel, channel_colors);
-    }
+void RGBController_HuePlus::UpdateLEDs()
+{
+    hueplus->SetChannelLEDs(0, colors);
 }

RGBController/RGBController_HuePlus.h

@@ -15,15 +15,16 @@ class RGBController_HuePlus : public RGBController
 {
 public:
     RGBController_HuePlus(HuePlusController* hueplus_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     HuePlusController*          hueplus;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
-};
+};

RGBController/RGBController_HyperX.cpp

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

RGBController/RGBController_HyperX.h

@@ -16,13 +16,14 @@ class RGBController_HyperX : public RGBController
 {
 public:
     RGBController_HyperX(HyperXController* hyperx_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     HyperXController* hyperx;
-};
+};

RGBController/RGBController_LEDStrip.cpp

@@ -56,17 +56,34 @@ 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        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
-
+    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();
 
 private:
     LEDStripController* strip;
-};
+};

RGBController/RGBController_OpenRazer.cpp

@@ -187,13 +187,33 @@ void RGBController_OpenRazer::UpdateLEDs()
     }
 }
 
-void RGBController_OpenRazer::UpdateZoneLEDs(int zone)
+void RGBController_OpenRazer::SetAllLEDs(RGBColor color)
 {
+    for(std::size_t i = 0; i < colors.size(); i++)
+    {
+        colors[i] = color;
+    }
+
     UpdateLEDs();
 }
 
-void RGBController_OpenRazer::UpdateSingleLED(int led)
+void RGBController_OpenRazer::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_OpenRazer::SetLED(int led, RGBColor color)
+{
+    colors[led] = color;
+
     UpdateLEDs();
 }
 

RGBController/RGBController_OpenRazer.h

@@ -920,12 +920,13 @@ public:
 
 public:
     RGBController_OpenRazer(std::string dev_path);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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 device;
 
@@ -952,4 +953,4 @@ private:
     std::ofstream logo_led_rgb;
     std::ofstream scroll_led_effect;
     std::ofstream scroll_led_rgb;
-};
+};

RGBController/RGBController_PatriotViper.cpp

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

RGBController/RGBController_PatriotViper.h

@@ -16,13 +16,14 @@ class RGBController_PatriotViper : public RGBController
 {
 public:
     RGBController_PatriotViper(PatriotViperController* viper_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     PatriotViperController* viper;
-};
+};

RGBController/RGBController_Polychrome.cpp

@@ -24,6 +24,33 @@ 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++)
@@ -36,16 +63,6 @@ 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"
@@ -88,7 +105,6 @@ 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,13 +16,14 @@ class RGBController_Polychrome : public RGBController
 {
 public:
     RGBController_Polychrome(PolychromeController* polychrome_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     PolychromeController* polychrome;
-};
+};

RGBController/RGBController_RGBFusion.cpp

@@ -24,32 +24,43 @@ void RGBController_RGBFusion::SetCustomMode()
     rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC);
 }
 
-void RGBController_RGBFusion::UpdateLEDs()
+void RGBController_RGBFusion::SetAllLEDs(RGBColor color)
 {
-    for (std::size_t led = 0; led < colors.size(); 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);
-    }
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+    
+    rgb_fusion->SetAllColors(red, grn, blu);
 }
 
-void RGBController_RGBFusion::UpdateZoneLEDs(int zone)
+void RGBController_RGBFusion::SetAllZoneLEDs(int zone, RGBColor color)
 {
-    RGBColor      color = colors[zone];
-    unsigned char red   = RGBGetRValue(color);
-    unsigned char grn   = RGBGetGValue(color);
-    unsigned char blu   = RGBGetBValue(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::UpdateSingleLED(int led)
+void RGBController_RGBFusion::SetLED(int led, RGBColor color)
 {
-    UpdateZoneLEDs(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::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]);
+
+        rgb_fusion->SetLEDColor(led, red, grn, blu);
+    }
 }
 
 static const char* rgb_fusion_zone_names[] =
@@ -99,7 +110,6 @@ 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,13 +16,14 @@ class RGBController_RGBFusion : public RGBController
 {
 public:
     RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     RGBFusionController* rgb_fusion;
-};
+};

RGBController/RGBController_RazerChromaSDK.cpp

@@ -85,6 +85,36 @@ 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)
@@ -159,13 +189,3 @@ void RGBController_RazerChromaSDK::UpdateLEDs()
         break;
     }
 }
-
-void RGBController_RazerChromaSDK::UpdateZoneLEDs(int zone)
-{
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
-{
-    UpdateLEDs();
-}

RGBController/RGBController_RazerChromaSDK.h

@@ -229,12 +229,13 @@ class RGBController_RazerChromaSDK : public RGBController
 {
 public:
     RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
-    int         GetMode();
-    void        SetMode(int mode);
-    void        SetCustomMode();
-    void        UpdateLEDs();
-    void        UpdateZoneLEDs(int zone);
-    void        UpdateSingleLED(int led);
+    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();
 
 private:
     const razer_device* device;

i2c_smbus/i2c_smbus.cpp

@@ -9,17 +9,6 @@
 #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);
@@ -139,18 +128,3 @@ 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,14 +69,8 @@ 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,11 +90,6 @@ OpenRGBDevicePage::OpenRGBDevicePage(RGBController *dev, QWidget *parent) :
     }
 
     ui->LEDBox->setCurrentIndex(0);
-
-    /*-----------------------------------------------------*\
-    | Update color picker with color of first LED           |
-    \*-----------------------------------------------------*/
-    on_LEDBox_currentIndexChanged(0);
 }
 
 OpenRGBDevicePage::~OpenRGBDevicePage()
@@ -107,18 +102,9 @@ 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,62 +14,6 @@ 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                                |
     \*-----------------------------------------------------*/
@@ -212,51 +156,6 @@ 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++)
@@ -264,15 +163,3 @@ 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,20 +34,9 @@ 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,8 +1,5 @@
 #include "find_usb_serial_port.h"
 
-#include <unistd.h>
-#include <dirent.h>
-
 /*---------------------------------------------------------------------*\
 |                                                                       |
 |   find_usb_serial_port                                                |
@@ -33,7 +30,7 @@ std::string find_usb_serial_port(unsigned short vid, unsigned short pid)
     if(dir == NULL)
     {
         closedir(dir);
-        return ret_string;
+        return false;
     }
 
     /*-----------------------------------------------------------------*\
@@ -88,7 +85,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)