jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rework the RGBController API to handle the colors vector outside of device specific implementations

Browse source
This commit is contained in:
Adam Honse 2020-01-06 21:16:05 -06:00
parent 11770aaa3a
commit c7030ad47d
38 changed files with 515 additions and 685 deletions
Download patch file Download diff file Expand all files Collapse all files

15
Controllers/AuraController/AuraController.cpp
View file

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

3
Controllers/AuraController/AuraController.h
View file

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

11
Controllers/CorsairController/CorsairController.cpp
View file

@ -44,16 +44,7 @@ unsigned int CorsairController::GetLEDCount()
return(led_count);
}
void CorsairController::SetAllColors(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::SetLEDColor(unsigned int /*led*/, 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);

3
Controllers/CorsairController/CorsairController.h
View file

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

1
OpenRGB.pro
View file

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

46
RGBController/RGBController.cpp Normal file
View file

@ -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);
}

24
RGBController/RGBController.h
View file

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

80
RGBController/RGBController_AMDWraithPrism.cpp
View file

@ -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,57 +81,6 @@ void RGBController_AMDWraithPrism::SetCustomMode()
}
void RGBController_AMDWraithPrism::SetAllLEDs(RGBColor color)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
wraith->SetFanColor(red, grn, blu);
wraith->SetLogoColor(red, grn, blu);
wraith->SetRingColor(red, grn, blu);
}
void RGBController_AMDWraithPrism::SetAllZoneLEDs(int zone, RGBColor color)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
if(zone == 0)
{
wraith->SetLogoColor(red, grn, blu);
}
else if(zone == 1)
{
wraith->SetFanColor(red, grn, blu);
}
else if(zone == 2)
{
wraith->SetRingColor(red, grn, blu);
}
}
void RGBController_AMDWraithPrism::SetLED(int led, RGBColor color)
{
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()
{
unsigned char red = RGBGetRValue(colors[0]);
@ -146,3 +98,29 @@ void RGBController_AMDWraithPrism::UpdateLEDs()
blu = RGBGetBValue(colors[2]);
wraith->SetRingColor(red, grn, blu);
}
void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
if(zone == 0)
{
wraith->SetLogoColor(red, grn, blu);
}
else if(zone == 1)
{
wraith->SetFanColor(red, grn, blu);
}
else if(zone == 2)
{
wraith->SetRingColor(red, grn, blu);
}
}
void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}

15
RGBController/RGBController_AMDWraithPrism.h
View file

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

44
RGBController/RGBController_AorusGPU.cpp
View file

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

13
RGBController/RGBController_AorusGPU.h
View file

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

102
RGBController/RGBController_Aura.cpp
View file

@ -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;
@ -163,7 +150,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.push_back(ToRGBColor(red, grn, blu));
}
std::vector<unsigned char> aura_zones;

15
RGBController/RGBController_Aura.h
View file

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

48
RGBController/RGBController_Corsair.cpp
View file

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

13
RGBController/RGBController_Corsair.h
View file

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

46
RGBController/RGBController_CorsairPro.cpp
View file

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

15
RGBController/RGBController_CorsairPro.h
View file

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

42
RGBController/RGBController_E131.cpp
View file

@ -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();
}

15
RGBController/RGBController_E131.h
View file

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

85
RGBController/RGBController_Hue2.cpp
View file

@ -80,58 +80,6 @@ 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++)
@ -154,3 +102,36 @@ void RGBController_Hue2::UpdateLEDs()
}
}
}
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]);
}
}
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]);
}
}
hue2->SetChannelLEDs(channel, channel_colors);
}

15
RGBController/RGBController_Hue2.h
View file

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

85
RGBController/RGBController_HuePlus.cpp
View file

@ -82,58 +82,6 @@ void RGBController_HuePlus::SetCustomMode()
}
void RGBController_HuePlus::SetAllLEDs(RGBColor color)
{
for (std::size_t i = 0; i < colors.size(); i++)
{
colors[i] = color;
}
hueplus->SetChannelLEDs(0, colors);
}
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++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
hueplus->SetChannelLEDs(channel, channel_colors);
}
void RGBController_HuePlus::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]);
}
}
hueplus->SetChannelLEDs(channel, channel_colors);
}
void RGBController_HuePlus::UpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx <= zones.size(); zone_idx++)
@ -156,3 +104,36 @@ void RGBController_HuePlus::UpdateLEDs()
}
}
}
void RGBController_HuePlus::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]);
}
}
hueplus->SetChannelLEDs(channel, channel_colors);
}
void RGBController_HuePlus::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]);
}
}
hueplus->SetChannelLEDs(channel, channel_colors);
}

15
RGBController/RGBController_HuePlus.h
View file

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

68
RGBController/RGBController_HyperX.cpp
View file

@ -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,23 +96,6 @@ void RGBController_HyperX::SetLED(int led, RGBColor color)
}
}
void RGBController_HyperX::UpdateLEDs()
{
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++)
{
unsigned char red = RGBGetRValue(colors[zones[zone].map[x][y]]);
unsigned char grn = RGBGetGValue(colors[zones[zone].map[x][y]]);
unsigned char blu = RGBGetBValue(colors[zones[zone].map[x][y]]);
hyperx->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
}
}
}
}
RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
{
hyperx = hyperx_ptr;

15
RGBController/RGBController_HyperX.h
View file

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

37
RGBController/RGBController_LEDStrip.cpp
View file

@ -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);
}

16
RGBController/RGBController_LEDStrip.h
View file

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

24
RGBController/RGBController_OpenRazer.cpp
View file

@ -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();
}

15
RGBController/RGBController_OpenRazer.h
View file

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

70
RGBController/RGBController_PatriotViper.cpp
View file

@ -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,17 +79,6 @@ void RGBController_PatriotViper::SetLED(int led, RGBColor color)
}
}
void RGBController_PatriotViper::UpdateLEDs()
{
for(int led = 0; led < 5; led++)
{
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
viper->SetLEDColor(led, red, grn, blu);
}
}
RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* viper_ptr)
{
viper = viper_ptr;

15
RGBController/RGBController_PatriotViper.h
View file

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

38
RGBController/RGBController_Polychrome.cpp
View file

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

15
RGBController/RGBController_Polychrome.h
View file

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

50
RGBController/RGBController_RGBFusion.cpp
View file

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

15
RGBController/RGBController_RGBFusion.h
View file

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

40
RGBController/RGBController_RazerChromaSDK.cpp
View file

@ -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();
}

13
RGBController/RGBController_RazerChromaSDK.h
View file

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

18
qt/OpenRGBDevicePage.cpp
View file

@ -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*/)