jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
OpenRGB/qt/OpenRGBDevicePage.cpp
Chris 6fd2ea9276 Initial commit for Brightness in RGBController API 
* Added DeviceHasBrightness() = false; to RGBController as overridable
* Added Brightness to Mode struct
* Added BrightnessSlider to the OpenRGBDevicePage ui and the supporting
code to pass to the RGBController

Commit amended for code style and to split API changes and controller changes out by Adam Honse
<calcprogrammer1@gmail.com>
2021-07-04 21:16:49 -05:00

1313 lines
47 KiB
C++
Raw Blame History

#include "OpenRGBDialog2.h"
#include "OpenRGBDevicePage.h"
#include "OpenRGBZoneResizeDialog.h"
#include "ResourceManager.h"
#include "hsv.h"
using namespace Ui;
static void UpdateCallback(void * this_ptr)
{
OpenRGBDevicePage * this_obj = (OpenRGBDevicePage *)this_ptr;
QMetaObject::invokeMethod(this_obj, "UpdateInterface", Qt::QueuedConnection);
}
static QString ModeDescription(const mode& m)
{
/*-----------------------------------------------------------------*\
| List of common mode names can be found on the OpenRGB Wiki: |
| https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/Common-Modes |
\*-----------------------------------------------------------------*/
static const std::unordered_map<std::string, QString> descriptions =
{
{"Direct", "Set individual LEDs to static colors. Safe for use with software-driven effects." },
{"Custom", "Set individual LEDs to static colors. Not safe for use with software-driven effects." },
{"Static", "Sets the entire device or a zone to a single color." },
{"Breathing", "Gradually fades between fully off and fully on." },
{"Flashing", "Abruptly changes between fully off and fully on." },
{"Spectrum Cycle", "Gradually cycles through the entire color spectrum. All lights on the device are the same color." },
{"Rainbow Wave", "Gradually cycles through the entire color spectrum. Produces a rainbow pattern that moves." },
{"Reactive", "Flashes lights when keys or buttons are pressed." },
};
/*-----------------------------------------------------------------*\
| Find the given mode name in the list and return the description |
| if it exists, otherwise return an empty string |
\*-----------------------------------------------------------------*/
std::unordered_map<std::string, QString>::const_iterator it = descriptions.find(m.name);
if(it != descriptions.end())
{
return it->second;
}
return "";
}
OpenRGBDevicePage::OpenRGBDevicePage(RGBController *dev, QWidget *parent) :
QFrame(parent),
ui(new Ui::OpenRGBDevicePageUi)
{
ui->setupUi(this);
/*-----------------------------------------------------*\
| Store device pointer |
\*-----------------------------------------------------*/
device = dev;
/*-----------------------------------------------------*\
| Register update callback with the device |
\*-----------------------------------------------------*/
device->RegisterUpdateCallback(UpdateCallback, this);
/*-----------------------------------------------------*\
| Set up the device view |
\*-----------------------------------------------------*/
connect(ui->DeviceViewBox, &DeviceView::selectionChanged, this, &OpenRGBDevicePage::on_DeviceViewBox_selectionChanged);
/*-----------------------------------------------------*\
| Get the UserInterface settings and check the |
| numerical labels setting |
\*-----------------------------------------------------*/
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
std::string ui_string = "UserInterface";
json ui_settings;
ui_settings = settings_manager->GetSettings(ui_string);
if(ui_settings.contains("numerical_labels"))
{
bool numerical_labels = ui_settings["numerical_labels"];
ui->DeviceViewBox->setNumericalLabels(numerical_labels);
}
ui->DeviceViewBox->setController(device);
ui->DeviceViewBox->hide();
/*-----------------------------------------------------*\
| Fill in the mode selection box |
\*-----------------------------------------------------*/
ui->ModeBox->blockSignals(true);
ui->ModeBox->clear();
for (std::size_t i = 0; i < device->modes.size(); i++)
{
ui->ModeBox->addItem(device->modes[i].name.c_str());
ui->ModeBox->setItemData(i, ModeDescription(device->modes[i]), Qt::ToolTipRole);
}
ui->ModeBox->setCurrentIndex(device->GetMode());
ui->ModeBox->blockSignals(false);
/*-----------------------------------------------------*\
| Update mode user interface elements |
\*-----------------------------------------------------*/
UpdateModeUi();
ui->RedSpinBox->setValue(ui->ColorWheelBox->color().red());
ui->GreenSpinBox->setValue(ui->ColorWheelBox->color().green());
ui->BlueSpinBox->setValue(ui->ColorWheelBox->color().blue());
}
OpenRGBDevicePage::~OpenRGBDevicePage()
{
/*-----------------------------------------------------*\
| Unregister update callback from the controller if the |
| controller still exists |
\*-----------------------------------------------------*/
for(unsigned int controller_idx = 0; controller_idx < ResourceManager::get()->GetRGBControllers().size(); controller_idx++)
{
if(ResourceManager::get()->GetRGBControllers()[controller_idx] == device)
{
device->UnregisterUpdateCallback(this);
break;
}
}
delete ui;
}
RGBController* Ui::OpenRGBDevicePage::GetController()
{
return device;
}
void Ui::OpenRGBDevicePage::on_ZoneBox_currentIndexChanged(int /*index*/)
{
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
int selected_zone = ui->ZoneBox->currentIndex();
QString msLine;
if(MultipleSelected)
{
msLine = ui->LEDBox->itemText(ui->LEDBox->count() - 1);
}
ui->LEDBox->blockSignals(true);
ui->LEDBox->clear();
if(device->zones.size() > 1)
{
if(selected_zone == 0)
{
if(device->leds.size() > 1)
{
ui->LEDBox->addItem("Entire Device");
ui->LEDBox->setEnabled(1);
}
else
{
ui->LEDBox->setDisabled(1);
}
for (std::size_t i = 0; i < device->leds.size(); i++)
{
ui->LEDBox->addItem(device->leds[i].name.c_str());
}
if(MultipleSelected) // Preserve the multiple() option
{
ui->LEDBox->addItem(msLine);
ui->LEDBox->setCurrentIndex(device->leds.size());
}
ui->ResizeButton->setEnabled(false);
if(!ui->ZoneBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->clearSelection();
ui->DeviceViewBox->blockSignals(false);
}
}
selected_zone = selected_zone - 1;
}
if(device->zones.size() == 1 || selected_zone != -1)
{
// Disable led box if there's only one LED anyway
if(device->zones[selected_zone].leds_count > 1)
{
ui->LEDBox->addItem("Entire Zone");
ui->LEDBox->setEnabled(1);
}
else
{
ui->LEDBox->setDisabled(1);
}
for (std::size_t led_idx = 0; led_idx < device->zones[selected_zone].leds_count; led_idx++)
{
ui->LEDBox->addItem(device->zones[selected_zone].leds[led_idx].name.c_str());
}
if(device->zones[selected_zone].leds_min == device->zones[selected_zone].leds_max)
{
ui->ResizeButton->setEnabled(false);
}
else
{
ui->ResizeButton->setEnabled(true);
}
if(!ui->ZoneBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->selectZone(selected_zone);
ui->DeviceViewBox->blockSignals(false);
}
}
ui->LEDBox->setCurrentIndex(0);
on_LEDBox_currentIndexChanged(0);
ui->LEDBox->blockSignals(false);
}
break;
}
}
void Ui::OpenRGBDevicePage::on_LEDBox_currentIndexChanged(int index)
{
if(index < 0)
{
return;
}
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
int selected_zone = ui->ZoneBox->currentIndex();
bool multiple = (std::size_t(index) == (device->leds.size() + 1));
RGBColor color = 0x00000000;
bool updateColor = 0;
if(device->zones.size() > 1)
{
if(selected_zone == 0) // All zones
{
if(device->leds.size() > 1)
{
if(index == 0) // All LEDs on the entire device
{
if(!ui->LEDBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->clearSelection();
ui->DeviceViewBox->blockSignals(false);
}
}
index = index - 1;
}
if((device->leds.size() == 1 || index != -1) && !multiple)
{
if(MultipleSelected)
{
ui->LEDBox->removeItem(device->leds.size() + 1);
}
MultipleSelected = 0;
color = device->GetLED(index); // One LED, proceed
updateColor = 1;
if(!ui->LEDBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->selectLed(index);
ui->DeviceViewBox->blockSignals(false);
}
}
}
selected_zone = selected_zone - 1;
}
if(device->zones.size() == 1 || selected_zone != -1) // A specific zone is selected
{
if(device->zones[selected_zone].leds_count > 1)
{
if(index == 0) // Entire zone
{
if(!ui->LEDBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->selectZone(selected_zone);
ui->DeviceViewBox->blockSignals(false);
}
}
index = index - 1;
}
if(device->zones[selected_zone].leds_count == 1 || index != -1)
{
if((unsigned int)index < device->zones[selected_zone].leds_count)
{
color = device->zones[selected_zone].colors[index];
updateColor = 1;
int globalIndex = device->zones[selected_zone].leds - &(device->leds[0]) + index;
if(!ui->LEDBox->signalsBlocked())
{
ui->DeviceViewBox->blockSignals(true);
ui->DeviceViewBox->selectLed(globalIndex);
ui->DeviceViewBox->blockSignals(false);
}
}
}
}
/*-----------------------------------------------------*\
| Update color picker with color of selected LED |
\*-----------------------------------------------------*/
if(updateColor)
{
UpdatingColor = true;
ui->RedSpinBox->setValue(RGBGetRValue(color));
ui->GreenSpinBox->setValue(RGBGetGValue(color));
ui->BlueSpinBox->setValue(RGBGetBValue(color));
UpdatingColor = false;
updateHSV();
updateWheel();
}
}
break;
case MODE_COLORS_MODE_SPECIFIC:
{
/*-----------------------------------------------------*\
| Update color picker with color of selected mode |
\*-----------------------------------------------------*/
RGBColor color = device->modes[selected_mode].colors[index];
UpdatingColor = true;
ui->RedSpinBox->setValue(RGBGetRValue(color));
ui->GreenSpinBox->setValue(RGBGetGValue(color));
ui->BlueSpinBox->setValue(RGBGetBValue(color));
UpdatingColor = false;
updateHSV();
updateWheel();
}
break;
}
}
void Ui::OpenRGBDevicePage::on_ModeBox_currentIndexChanged(int /*index*/)
{
/*-----------------------------------------------------*\
| Update mode user interface elements |
\*-----------------------------------------------------*/
UpdateModeUi();
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
}
void Ui::OpenRGBDevicePage::on_PerLEDCheck_clicked()
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
/*-----------------------------------------------------*\
| Update mode user interface elements |
\*-----------------------------------------------------*/
UpdateModeUi();
}
void Ui::OpenRGBDevicePage::on_ModeSpecificCheck_clicked()
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
/*-----------------------------------------------------*\
| Update mode user interface elements |
\*-----------------------------------------------------*/
UpdateModeUi();
}
void Ui::OpenRGBDevicePage::on_RandomCheck_clicked()
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
/*-----------------------------------------------------*\
| Update mode user interface elements |
\*-----------------------------------------------------*/
UpdateModeUi();
}
void Ui::OpenRGBDevicePage::on_BrightnessSlider_valueChanged(int /*value*/)
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
}
void Ui::OpenRGBDevicePage::on_SpeedSlider_valueChanged(int /*value*/)
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
}
void Ui::OpenRGBDevicePage::on_DirectionBox_currentIndexChanged(int /*index*/)
{
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
UpdateMode();
}
void Ui::OpenRGBDevicePage::UpdateInterface()
{
//UpdateModeUi();
ui->DeviceViewBox->repaint();
}
void Ui::OpenRGBDevicePage::UpdateModeUi()
{
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
/*-----------------------------------------------------*\
| Don't update the UI if the current mode is invalid |
\*-----------------------------------------------------*/
if(selected_mode < device->modes.size())
{
bool supports_per_led = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_PER_LED_COLOR );
bool supports_mode_specific = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR );
bool supports_random = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR );
bool supports_speed = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_SPEED );
bool supports_brightness = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_BRIGHTNESS);
bool supports_dir_lr = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_LR );
bool supports_dir_ud = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_UD );
bool supports_dir_hv = ( device->modes[selected_mode].flags & MODE_FLAG_HAS_DIRECTION_HV );
bool per_led = device->modes[selected_mode].color_mode == MODE_COLORS_PER_LED;
bool mode_specific = device->modes[selected_mode].color_mode == MODE_COLORS_MODE_SPECIFIC;
bool random = device->modes[selected_mode].color_mode == MODE_COLORS_RANDOM;
unsigned int dir = device->modes[selected_mode].direction;
if(supports_speed)
{
ui->SpeedSlider->blockSignals(true);
int current_speed;
InvertedSpeed = device->modes[selected_mode].speed_min > device->modes[selected_mode].speed_max;
if(InvertedSpeed)
{
/*-----------------------------------------------------*\
| If Speed Slider is inverted, invert value |
\*-----------------------------------------------------*/
ui->SpeedSlider->setMinimum(device->modes[selected_mode].speed_max);
ui->SpeedSlider->setMaximum(device->modes[selected_mode].speed_min);
current_speed = device->modes[selected_mode].speed_min - device->modes[selected_mode].speed + device->modes[selected_mode].speed_max;
}
else
{
ui->SpeedSlider->setMinimum(device->modes[selected_mode].speed_min);
ui->SpeedSlider->setMaximum(device->modes[selected_mode].speed_max);
current_speed = device->modes[selected_mode].speed;
}
ui->SpeedSlider->setValue(current_speed);
ui->SpeedSlider->setEnabled(true);
ui->SpeedSlider->blockSignals(false);
}
else
{
ui->SpeedSlider->blockSignals(true);
ui->SpeedSlider->setEnabled(false);
ui->SpeedSlider->blockSignals(false);
}
if(supports_brightness)
{
ui->BrightnessSlider->blockSignals(true);
InvertedBrightness = device->modes[selected_mode].brightness_min > device->modes[selected_mode].brightness_max;
if(InvertedBrightness)
{
/*-----------------------------------------------------*\
| If Brightness Slider is inverted, invert value |
\*-----------------------------------------------------*/
ui->BrightnessSlider->setMinimum(device->modes[selected_mode].brightness_max);
ui->BrightnessSlider->setMaximum(device->modes[selected_mode].brightness_min);
}
else
{
ui->BrightnessSlider->setMinimum(device->modes[selected_mode].brightness_min);
ui->BrightnessSlider->setMaximum(device->modes[selected_mode].brightness_max);
}
ui->BrightnessSlider->setValue(device->modes[selected_mode].brightness);
ui->BrightnessSlider->setEnabled(true);
ui->BrightnessSlider->blockSignals(false);
}
else
{
ui->BrightnessSlider->blockSignals(true);
ui->BrightnessSlider->setEnabled(false);
ui->BrightnessSlider->blockSignals(false);
}
ui->DirectionBox->blockSignals(true);
ui->DirectionBox->clear();
if(supports_dir_lr)
{
ui->DirectionBox->addItem("Left");
ui->DirectionBox->addItem("Right");
}
if(supports_dir_ud)
{
ui->DirectionBox->addItem("Up");
ui->DirectionBox->addItem("Down");
}
if(supports_dir_hv)
{
ui->DirectionBox->addItem("Horizontal");
ui->DirectionBox->addItem("Vertical");
}
if(supports_dir_lr || supports_dir_ud || supports_dir_hv)
{
if((supports_dir_lr)
&&((dir == MODE_DIRECTION_LEFT)
||(dir == MODE_DIRECTION_RIGHT)))
{
ui->DirectionBox->setCurrentIndex(dir);
}
if((supports_dir_ud)
&&((dir == MODE_DIRECTION_UP)
||(dir == MODE_DIRECTION_DOWN)))
{
if(supports_dir_lr)
{
ui->DirectionBox->setCurrentIndex(dir);
}
else
{
ui->DirectionBox->setCurrentIndex(dir - 2);
}
}
if((supports_dir_hv)
&&((dir == MODE_DIRECTION_HORIZONTAL)
||(dir == MODE_DIRECTION_VERTICAL)))
{
if(supports_dir_lr && supports_dir_ud)
{
ui->DirectionBox->setCurrentIndex(dir);
}
else if(supports_dir_lr || supports_dir_ud)
{
ui->DirectionBox->setCurrentIndex(dir - 2);
}
else
{
ui->DirectionBox->setCurrentIndex(dir - 4);
}
}
ui->DirectionBox->setEnabled(true);
}
else
{
ui->DirectionBox->setEnabled(false);
}
ui->DirectionBox->blockSignals(false);
if(supports_per_led)
{
ui->PerLEDCheck->setEnabled(true);
ui->PerLEDCheck->setChecked(per_led);
}
else
{
ui->PerLEDCheck->setEnabled(false);
ui->PerLEDCheck->setAutoExclusive(false);
ui->PerLEDCheck->setChecked(false);
ui->PerLEDCheck->setAutoExclusive(true);
}
if(supports_mode_specific)
{
ui->ModeSpecificCheck->setEnabled(true);
ui->ModeSpecificCheck->setChecked(mode_specific);
}
else
{
ui->ModeSpecificCheck->setEnabled(false);
ui->ModeSpecificCheck->setAutoExclusive(false);
ui->ModeSpecificCheck->setChecked(false);
ui->ModeSpecificCheck->setAutoExclusive(true);
}
if(supports_random)
{
ui->RandomCheck->setEnabled(true);
ui->RandomCheck->setChecked(random);
}
else
{
ui->RandomCheck->setEnabled(false);
ui->RandomCheck->setAutoExclusive(false);
ui->RandomCheck->setChecked(false);
ui->RandomCheck->setAutoExclusive(true);
}
/*-----------------------------------------------------*\
| Fill in the zone box based on color mode |
\*-----------------------------------------------------*/
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_NONE:
case MODE_COLORS_RANDOM:
ui->ZoneBox->blockSignals(true);
ui->ZoneBox->clear();
ui->ZoneBox->blockSignals(false);
ui->LEDBox->blockSignals(true);
ui->LEDBox->clear();
ui->LEDBox->blockSignals(false);
ui->ResizeButton->setEnabled(false);
ui->ApplyColorsButton->setEnabled(false);
//ui->AutoFillCheck->setEnabled(false);
break;
case MODE_COLORS_PER_LED:
ui->ZoneBox->blockSignals(true);
ui->ZoneBox->clear();
if(device->zones.size() > 1)
{
ui->ZoneBox->setEnabled(1);
ui->ZoneBox->addItem("All Zones");
}
else
{
ui->ZoneBox->setDisabled(1);
}
for (std::size_t i = 0; i < device->zones.size(); i++)
{
ui->ZoneBox->addItem(device->zones[i].name.c_str());
}
ui->ZoneBox->setCurrentIndex(0);
ui->ZoneBox->blockSignals(false);
ui->ApplyColorsButton->setEnabled(true);
//ui->AutoFillCheck->setEnabled(true);
/*-----------------------------------------------------*\
| Update LED box |
\*-----------------------------------------------------*/
on_ZoneBox_currentIndexChanged(0);
/*-----------------------------------------------------*\
| Update color picker with color of first LED |
\*-----------------------------------------------------*/
//on_LEDBox_currentIndexChanged(0);
break;
case MODE_COLORS_MODE_SPECIFIC:
ui->ZoneBox->blockSignals(true);
ui->ZoneBox->clear();
ui->ZoneBox->addItem("Mode Specific");
ui->ZoneBox->blockSignals(false);
ui->LEDBox->blockSignals(true);
ui->LEDBox->clear();
if(device->modes[selected_mode].colors_min == device->modes[selected_mode].colors_max)
{
ui->ResizeButton->setEnabled(false);
}
else
{
ui->ResizeButton->setEnabled(true);
}
for(unsigned int i = 0; i < device->modes[selected_mode].colors.size(); i++)
{
char id_buf[32];
snprintf(id_buf, 16, "Mode Color %u", i);
ui->LEDBox->addItem(id_buf);
}
ui->LEDBox->setCurrentIndex(0);
on_LEDBox_currentIndexChanged(0);
ui->LEDBox->setEnabled(true);
ui->LEDBox->blockSignals(false);
ui->ApplyColorsButton->setEnabled(true);
//ui->AutoFillCheck->setEnabled(true);
break;
}
}
}
void Ui::OpenRGBDevicePage::UpdateMode()
{
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
int current_mode = ui->ModeBox->currentIndex();
if(current_mode >= 0)
{
int current_speed = 0;
int current_brightness = 0;
bool current_per_led = ui->PerLEDCheck->isChecked();
bool current_mode_specific = ui->ModeSpecificCheck->isChecked();
bool current_random = ui->RandomCheck->isChecked();
int current_dir_idx = ui->DirectionBox->currentIndex();
int current_direction = 0;
bool supports_dir_lr = ( device->modes[(unsigned int)current_mode].flags & MODE_FLAG_HAS_DIRECTION_LR );
bool supports_dir_ud = ( device->modes[(unsigned int)current_mode].flags & MODE_FLAG_HAS_DIRECTION_UD );
bool supports_dir_hv = ( device->modes[(unsigned int)current_mode].flags & MODE_FLAG_HAS_DIRECTION_HV );
/*-----------------------------------------------------*\
| Set the direction value |
\*-----------------------------------------------------*/
if(supports_dir_hv)
{
if(supports_dir_lr && supports_dir_ud)
{
current_direction = current_dir_idx;
}
else if(supports_dir_lr || supports_dir_ud)
{
current_direction = current_dir_idx + 2;
}
else
{
current_direction = current_dir_idx + 4;
}
}
if(supports_dir_ud)
{
if(supports_dir_lr)
{
current_direction = current_dir_idx;
}
else
{
current_direction = current_dir_idx + 2;
}
}
if((supports_dir_lr)
&&(current_dir_idx < 2))
{
current_direction = current_dir_idx;
}
device->modes[(unsigned int)current_mode].direction = current_direction;
/*-----------------------------------------------------*\
| If Speed Slider is enabled, read the speed value |
\*-----------------------------------------------------*/
if(ui->SpeedSlider->isEnabled())
{
/*-----------------------------------------------------*\
| If Speed Slider is inverted, invert value |
\*-----------------------------------------------------*/
if(InvertedSpeed)
{
current_speed = device->modes[(unsigned int)current_mode].speed_min - ui->SpeedSlider->value() + device->modes[current_mode].speed_max;
}
else
{
current_speed = ui->SpeedSlider->value();
}
}
/*-----------------------------------------------------*\
| If Brightness Slider is enabled, read the value |
\*-----------------------------------------------------*/
if(ui->BrightnessSlider->isEnabled())
{
/*-----------------------------------------------------*\
| If Brightness Slider is inverted, invert value |
\*-----------------------------------------------------*/
if(InvertedBrightness)
{
current_brightness = device->modes[(unsigned int)current_mode].brightness_min - ui->BrightnessSlider->value() + device->modes[current_mode].brightness_max;
}
else
{
current_brightness = ui->BrightnessSlider->value();
}
}
/*-----------------------------------------------------*\
| Don't set the mode if the current mode is invalid |
\*-----------------------------------------------------*/
if((unsigned int)current_mode < device->modes.size())
{
/*-----------------------------------------------------*\
| Update mode parameters |
\*-----------------------------------------------------*/
device->modes[(unsigned int)current_mode].speed = current_speed;
device->modes[(unsigned int)current_mode].brightness = current_brightness;
if(current_per_led)
{
device->modes[(unsigned int)current_mode].color_mode = MODE_COLORS_PER_LED;
}
else if(current_mode_specific)
{
device->modes[(unsigned int)current_mode].color_mode = MODE_COLORS_MODE_SPECIFIC;
}
else if(current_random)
{
device->modes[(unsigned int)current_mode].color_mode = MODE_COLORS_RANDOM;
}
else
{
device->modes[(unsigned int)current_mode].color_mode = MODE_COLORS_NONE;
}
/*-----------------------------------------------------*\
| Change device mode |
\*-----------------------------------------------------*/
device->SetMode((unsigned int)current_mode);
if(device->modes[(unsigned int)current_mode].color_mode == MODE_COLORS_PER_LED)
{
device->UpdateLEDs();
}
}
}
}
void Ui::OpenRGBDevicePage::SetDevice(unsigned char red, unsigned char green, unsigned char blue)
{
UpdatingColor = true;
ui->RedSpinBox->setValue(red);
ui->GreenSpinBox->setValue(green);
ui->BlueSpinBox->setValue(blue);
UpdatingColor = false;
updateHSV();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::UpdateDevice()
{
ui->ModeBox->blockSignals(true);
ui->ModeBox->setCurrentIndex(device->active_mode);
ui->ModeBox->blockSignals(false);
UpdateModeUi();
UpdateMode();
}
void Ui::OpenRGBDevicePage::SetCustomMode(unsigned char red, unsigned char green, unsigned char blue)
{
/*-----------------------------------------------------*\
| Set the selected mode to the custom mode and update UI|
\*-----------------------------------------------------*/
device->SetCustomMode();
ui->ModeBox->blockSignals(true);
ui->ModeBox->setCurrentIndex(device->active_mode);
ui->ModeBox->blockSignals(false);
UpdateModeUi();
/*-----------------------------------------------------*\
| Set the color boxes |
\*-----------------------------------------------------*/
UpdatingColor = true;
ui->RedSpinBox->setValue(red);
ui->GreenSpinBox->setValue(green);
ui->BlueSpinBox->setValue(blue);
UpdatingColor = false;
updateHSV();
updateWheel();
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
/*-----------------------------------------------------*\
| Set all device LEDs to the current color |
\*-----------------------------------------------------*/
RGBColor color = ToRGBColor(
ui->RedSpinBox->text().toInt(),
ui->GreenSpinBox->text().toInt(),
ui->BlueSpinBox->text().toInt()
);
device->SetAllLEDs(color);
}
break;
case MODE_COLORS_MODE_SPECIFIC:
{
/*-----------------------------------------------------*\
| Set all device LEDs to the current color |
\*-----------------------------------------------------*/
RGBColor color = ToRGBColor(
ui->RedSpinBox->text().toInt(),
ui->GreenSpinBox->text().toInt(),
ui->BlueSpinBox->text().toInt()
);
for(std::size_t i = 0; i < device->modes[selected_mode].colors.size(); i++)
{
device->modes[selected_mode].colors[i] = color;
}
}
break;
}
/*-----------------------------------------------------*\
| Apply mode and colors |
\*-----------------------------------------------------*/
UpdateMode();
}
void Ui::OpenRGBDevicePage::on_SwatchBox_swatchChanged(const QColor color)
{
if(UpdatingColor)
{
return;
}
UpdatingColor = true;
ui->RedSpinBox->setValue(color.red());
ui->GreenSpinBox->setValue(color.green());
ui->BlueSpinBox->setValue(color.blue());
UpdatingColor = false;
ui->ColorWheelBox->setColor(color);
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_ColorWheelBox_colorChanged(const QColor color)
{
if(UpdatingColor)
{
return;
}
UpdatingColor = true;
ui->RedSpinBox->setValue(color.red());
ui->GreenSpinBox->setValue(color.green());
ui->BlueSpinBox->setValue(color.blue());
UpdatingColor = false;
updateHSV();
ui->SwatchBox->setCurrentColor(color);
updateDeviceView();
}
void Ui::OpenRGBDevicePage::updateRGB()
{
if(UpdatingColor)
{
return;
}
UpdatingColor = true;
hsv_t hsv;
hsv.hue = ui->HueSpinBox->value();
hsv.saturation = ui->SatSpinBox->value();
hsv.value = ui->ValSpinBox->value();
RGBColor rgb = hsv2rgb(&hsv);
ui->RedSpinBox->setValue(RGBGetRValue(rgb));
ui->GreenSpinBox->setValue(RGBGetGValue(rgb));
ui->BlueSpinBox->setValue(RGBGetBValue(rgb));
UpdatingColor = false;
}
void Ui::OpenRGBDevicePage::updateHSV()
{
if(UpdatingColor)
{
return;
}
UpdatingColor = true;
RGBColor rgb = ToRGBColor(ui->RedSpinBox->value(), ui->GreenSpinBox->value(), ui->BlueSpinBox->value());
hsv_t hsv;
rgb2hsv(rgb, &hsv);
ui->HueSpinBox->setValue(hsv.hue);
ui->SatSpinBox->setValue(hsv.saturation);
ui->ValSpinBox->setValue(hsv.value);
UpdatingColor = false;
}
void Ui::OpenRGBDevicePage::updateWheel()
{
if(UpdatingColor)
{
return;
}
UpdatingColor = true;
RGBColor qrgb = ToRGBColor
(
ui->BlueSpinBox->value(),
ui->GreenSpinBox->value(),
ui->RedSpinBox->value());
ui->ColorWheelBox->setColor(QColor::fromRgb(qrgb));
UpdatingColor = false;
}
void Ui::OpenRGBDevicePage::updateDeviceView()
{
if(false)//ui->AutoFillCheck->isChecked())
{
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
RGBColor qrgb = ToRGBColor
(
ui->RedSpinBox->value(),
ui->GreenSpinBox->value(),
ui->BlueSpinBox->value());
ui->DeviceViewBox->setSelectionColor(qrgb);
}
break;
case MODE_COLORS_MODE_SPECIFIC:
{
unsigned int index = ui->LEDBox->currentIndex();
/*-----------------------------------------------------*\
| Set all device LEDs to the current color |
\*-----------------------------------------------------*/
RGBColor color = ToRGBColor(
ui->RedSpinBox->text().toInt(),
ui->GreenSpinBox->text().toInt(),
ui->BlueSpinBox->text().toInt()
);
device->modes[selected_mode].colors[index] = color;
device->UpdateMode();
}
break;
}
}
}
void Ui::OpenRGBDevicePage::on_RedSpinBox_valueChanged(int /*arg1*/)
{
updateHSV();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_HueSpinBox_valueChanged(int /*arg1*/)
{
updateRGB();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_GreenSpinBox_valueChanged(int /*arg1*/)
{
updateHSV();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_SatSpinBox_valueChanged(int /*arg1*/)
{
updateRGB();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_BlueSpinBox_valueChanged(int /*arg1*/)
{
updateHSV();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_ValSpinBox_valueChanged(int /*arg1*/)
{
updateRGB();
updateWheel();
updateDeviceView();
}
void Ui::OpenRGBDevicePage::on_DeviceViewBox_selectionChanged(QVector<int> indices)
{
ui->ZoneBox->blockSignals(true);
ui->LEDBox->blockSignals(true);
ui->ZoneBox->setCurrentIndex(0);
on_ZoneBox_currentIndexChanged(0);
//updateLeds(); // We want to update the LED box, but we don't want any of the side effects of that action
ui->ZoneBox->blockSignals(false);
if(indices.size() != 0 && size_t(indices.size()) != device->leds.size())
{
if(indices.size() == 1)
{
if(device->leds.size() == 1)
{
ui->LEDBox->setCurrentIndex(0);
}
else
{
ui->LEDBox->setCurrentIndex(indices[0] + 1);
// Set everything to it's color
}
MultipleSelected = 0;
}
else
{
if(MultipleSelected)
{
ui->LEDBox->removeItem(device->leds.size() + 1);
}
ui->LEDBox->addItem("Multiple (" + QVariant(indices.size()).toString() + ")");
ui->LEDBox->setCurrentIndex(device->leds.size() + 1);
MultipleSelected = 1;
}
}
else
{
ui->LEDBox->setCurrentIndex(0);
}
ui->LEDBox->blockSignals(false);
}
void Ui::OpenRGBDevicePage::on_SetAllButton_clicked()
{
unsigned char red = ui->RedSpinBox->value();
unsigned char green = ui->GreenSpinBox->value();
unsigned char blue = ui->BlueSpinBox->value();
emit SetAllDevices(red, green, blue);
}
void Ui::OpenRGBDevicePage::on_ResizeButton_clicked()
{
switch(device->modes[device->active_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
int selected_zone = ui->ZoneBox->currentIndex();
if (device->zones.size() > 1)
{
selected_zone -= 1;
}
if(device->zones[selected_zone].type == ZONE_TYPE_LINEAR)
{
OpenRGBZoneResizeDialog dlg(device->zones[selected_zone].leds_min,
device->zones[selected_zone].leds_max,
device->zones[selected_zone].leds_count);
int new_size = dlg.show();
if(new_size >= 0)
{
device->ResizeZone(selected_zone, new_size);
/*-----------------------------------------------------*\
| Update LED box |
\*-----------------------------------------------------*/
on_ZoneBox_currentIndexChanged(selected_zone);
/*-----------------------------------------------------*\
| Update color picker with color of first LED |
\*-----------------------------------------------------*/
on_LEDBox_currentIndexChanged(0);
/*-----------------------------------------------------*\
| Save the size profile |
\*-----------------------------------------------------*/
SaveSizeProfile();
}
}
}
break;
case MODE_COLORS_MODE_SPECIFIC:
{
OpenRGBZoneResizeDialog dlg(device->modes[device->active_mode].colors_min,
device->modes[device->active_mode].colors_max,
device->modes[device->active_mode].colors.size());
int new_size = dlg.show();
if(new_size > 0)
{
device->modes[device->active_mode].colors.resize(new_size);
}
UpdateModeUi();
UpdateMode();
}
break;
}
}
void Ui::OpenRGBDevicePage::ShowDeviceView()
{
ui->DeviceViewBox->show();
}
void Ui::OpenRGBDevicePage::HideDeviceView()
{
ui->DeviceViewBox->hide();
}
void Ui::OpenRGBDevicePage::on_ApplyColorsButton_clicked()
{
/*-----------------------------------------------------*\
| Read selected mode |
\*-----------------------------------------------------*/
unsigned int selected_mode = (unsigned int)ui->ModeBox->currentIndex();
switch(device->modes[selected_mode].color_mode)
{
case MODE_COLORS_PER_LED:
{
RGBColor qrgb = ToRGBColor
(
ui->RedSpinBox->value(),
ui->GreenSpinBox->value(),
ui->BlueSpinBox->value());
ui->DeviceViewBox->setSelectionColor(qrgb);
}
break;
case MODE_COLORS_MODE_SPECIFIC:
{
unsigned int index = ui->LEDBox->currentIndex();
/*-----------------------------------------------------*\
| Set all device LEDs to the current color |
\*-----------------------------------------------------*/
RGBColor color = ToRGBColor(
ui->RedSpinBox->text().toInt(),
ui->GreenSpinBox->text().toInt(),
ui->BlueSpinBox->text().toInt()
);
device->modes[selected_mode].colors[index] = color;
device->UpdateMode();
}
break;
}
}
void Ui::OpenRGBDevicePage::on_SelectAllLEDsButton_clicked()
{
if(device->modes[device->active_mode].color_mode == MODE_COLORS_PER_LED)
{
ui->LEDBox->setCurrentIndex(0);
on_LEDBox_currentIndexChanged(0);
ui->DeviceViewBox->repaint();
}
}
Reference in a new issue View git blame Copy permalink