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

Resizable Effects-Only Zones

Browse source
This commit is contained in:
Adam Honse 2024-01-13 02:30:11 +00:00
parent e1a821f3c9
commit 032b6c6300
5 changed files with 117 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

52
Controllers/MSIMysticLightController/MSIMysticLight185Controller/RGBController_MSIMysticLight185.cpp
View file

@ -147,23 +147,37 @@ void RGBController_MSIMysticLight185::SetupZones()
zone new_zone; zone new_zone;
new_zone.name = zd->name; new_zone.name = zd->name;
new_zone.flags = 0;
int maxLeds = (int)controller->GetMaxDirectLeds(zd->zone_type); int maxLeds = (int)controller->GetMaxDirectLeds(zd->zone_type);
/*-------------------------------------------------*\ /*-------------------------------------------------*\
| This is a fixed size zone | | This is a fixed size zone |
| Either this is a board which only supports zone |
| control or this is not an ARGB header zone |
\*-------------------------------------------------*/ \*-------------------------------------------------*/
if((controller->GetSupportedDirectMode() == MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED) if(((zd->zone_type != MSI_ZONE_J_RAINBOW_1)
|| ((zd->zone_type != MSI_ZONE_J_RAINBOW_1) && (zd->zone_type != MSI_ZONE_J_RAINBOW_2) && (zd->zone_type != MSI_ZONE_J_RAINBOW_3) && (zd->zone_type != MSI_ZONE_J_CORSAIR))) && (zd->zone_type != MSI_ZONE_J_RAINBOW_2)
&& (zd->zone_type != MSI_ZONE_J_RAINBOW_3)
&& (zd->zone_type != MSI_ZONE_J_CORSAIR)))
{ {
new_zone.leds_min = maxLeds; new_zone.leds_min = maxLeds;
new_zone.leds_max = maxLeds; new_zone.leds_max = maxLeds;
new_zone.leds_count = maxLeds; new_zone.leds_count = maxLeds;
} }
/*--------------------------------------------------\ /*--------------------------------------------------\
| This is a resizable zone on a per-LED board | | This is a resizable zone on a board that does not |
| support per-LED direct mode |
\*-------------------------------------------------*/
else if(controller->GetSupportedDirectMode() == MSIMysticLight185Controller::DIRECT_MODE_ZONE_BASED)
{
new_zone.leds_min = 0;
new_zone.leds_max = 30;//maxLeds;
new_zone.leds_count = 0;
last_resizable_zone = zd->zone_type;
new_zone.flags |= ZONE_FLAG_RESIZE_EFFECTS_ONLY;
}
/*--------------------------------------------------\
| This is a resizable zone on a board that does |
| support per-LED direct mode |
\*-------------------------------------------------*/ \*-------------------------------------------------*/
else else
{ {
@ -176,7 +190,7 @@ void RGBController_MSIMysticLight185::SetupZones()
/*-------------------------------------------------*\ /*-------------------------------------------------*\
| Determine zone type based on max number of LEDs | | Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/ \*-------------------------------------------------*/
if(new_zone.leds_max == 1) if((new_zone.leds_max == 1) || (new_zone.flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY))
{ {
new_zone.type = ZONE_TYPE_SINGLE; new_zone.type = ZONE_TYPE_SINGLE;
} }
@ -199,16 +213,28 @@ void RGBController_MSIMysticLight185::SetupZones()
{ {
controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count); controller->SetCycleCount(zone_description[zone_idx]->zone_type, zones[zone_idx].leds_count);
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx) if((zones[zone_idx].flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY) == 0)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
{
led new_led;
new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(" LED " + std::to_string(led_idx + 1));
}
new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led);
}
}
else if(zones[zone_idx].leds_count > 0)
{ {
led new_led; led new_led;
new_led.name = zones[zone_idx].name + " LED "; new_led.name = zones[zone_idx].name;
if(zones[zone_idx].leds_count > 1)
{
new_led.name.append(std::to_string(led_idx + 1));
}
new_led.value = zone_description[zone_idx]->zone_type; new_led.value = zone_description[zone_idx]->zone_type;
leds.push_back(new_led); leds.push_back(new_led);

48
RGBController/RGBController.cpp
View file

@ -37,6 +37,25 @@ mode::~mode()
colors.clear(); colors.clear();
} }
zone::zone()
{
name = "";
type = 0;
leds = NULL;
colors = NULL;
start_idx = 0;
leds_count = 0;
leds_min = 0;
leds_max = 0;
matrix_map = NULL;
flags = 0;
}
zone::~zone()
{
}
RGBController::RGBController() RGBController::RGBController()
{ {
DeviceThreadRunning = true; DeviceThreadRunning = true;
@ -1515,6 +1534,7 @@ void RGBController::SetSingleLEDColorDescription(unsigned char* data_buf)
void RGBController::SetupColors() void RGBController::SetupColors()
{ {
unsigned int total_led_count; unsigned int total_led_count;
unsigned int zone_led_count;
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Determine total number of LEDs on the device | | Determine total number of LEDs on the device |
@ -1523,7 +1543,7 @@ void RGBController::SetupColors()
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{ {
total_led_count += zones[zone_idx].leds_count; total_led_count += GetLEDsInZone(zone_idx);
} }
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
@ -1538,9 +1558,10 @@ void RGBController::SetupColors()
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{ {
zones[zone_idx].start_idx=total_led_count; zones[zone_idx].start_idx = total_led_count;
zone_led_count = GetLEDsInZone(zone_idx);
if((colors.size() > 0) && (zones[zone_idx].leds_count > 0)) if((colors.size() > 0) && (zone_led_count > 0))
{ {
zones[zone_idx].colors = &colors[total_led_count]; zones[zone_idx].colors = &colors[total_led_count];
} }
@ -1549,7 +1570,7 @@ void RGBController::SetupColors()
zones[zone_idx].colors = NULL; zones[zone_idx].colors = NULL;
} }
if((leds.size() > 0) && (zones[zone_idx].leds_count > 0)) if((leds.size() > 0) && (zone_led_count > 0))
{ {
zones[zone_idx].leds = &leds[total_led_count]; zones[zone_idx].leds = &leds[total_led_count];
} }
@ -1559,10 +1580,25 @@ void RGBController::SetupColors()
} }
total_led_count += zones[zone_idx].leds_count; total_led_count += zone_led_count;
} }
} }
unsigned int RGBController::GetLEDsInZone(unsigned int zone)
{
unsigned int leds_count = zones[zone].leds_count;
if(zones[zone].flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY)
{
if(leds_count > 1)
{
leds_count = 1;
}
}
return(leds_count);
}
RGBColor RGBController::GetLED(unsigned int led) RGBColor RGBController::GetLED(unsigned int led)
{ {
if(led < colors.size()) if(led < colors.size())
@ -1593,7 +1629,7 @@ void RGBController::SetAllLEDs(RGBColor color)
void RGBController::SetAllZoneLEDs(int zone, RGBColor color) void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
{ {
for (std::size_t color_idx = 0; color_idx < zones[zone].leds_count; color_idx++) for (std::size_t color_idx = 0; color_idx < GetLEDsInZone(zone); color_idx++)
{ {
zones[zone].colors[color_idx] = color; zones[zone].colors[color_idx] = color;
} }

27
RGBController/RGBController.h
View file

@ -116,6 +116,15 @@ typedef struct
unsigned int value; /* Device-specific LED value */ unsigned int value; /* Device-specific LED value */
} led; } led;
/*------------------------------------------------------------------*\
| Zone Flags |
\*------------------------------------------------------------------*/
enum
{
ZONE_FLAG_RESIZE_EFFECTS_ONLY = (1 << 0), /* Zone is resizable, but only for */
/* effects - treat as single LED */
};
/*------------------------------------------------------------------*\ /*------------------------------------------------------------------*\
| Zone Types | | Zone Types |
\*------------------------------------------------------------------*/ \*------------------------------------------------------------------*/
@ -150,10 +159,11 @@ typedef struct
} segment; } segment;
/*------------------------------------------------------------------*\ /*------------------------------------------------------------------*\
| Zone Struct | | Zone Class |
\*------------------------------------------------------------------*/ \*------------------------------------------------------------------*/
typedef struct class zone
{ {
public:
std::string name; /* Zone name */ std::string name; /* Zone name */
zone_type type; /* Zone type */ zone_type type; /* Zone type */
led * leds; /* List of LEDs in zone */ led * leds; /* List of LEDs in zone */
@ -164,7 +174,14 @@ typedef struct
unsigned int leds_max; /* Maximum number of LEDs */ unsigned int leds_max; /* Maximum number of LEDs */
matrix_map_type * matrix_map; /* Matrix map pointer */ matrix_map_type * matrix_map; /* Matrix map pointer */
std::vector<segment> segments; /* Segments in zone */ std::vector<segment> segments; /* Segments in zone */
} zone; unsigned int flags; /* Zone flags bitfield */
/*--------------------------------------------------------------*\
| Zone Constructor / Destructor |
\*--------------------------------------------------------------*/
zone();
~zone();
};
/*------------------------------------------------------------------*\ /*------------------------------------------------------------------*\
| Device Types | | Device Types |
@ -210,6 +227,8 @@ class RGBControllerInterface
public: public:
virtual void SetupColors() = 0; virtual void SetupColors() = 0;
virtual unsigned int GetLEDsInZone(unsigned int zone) = 0;
virtual RGBColor GetLED(unsigned int led) = 0; virtual RGBColor GetLED(unsigned int led) = 0;
virtual void SetLED(unsigned int led, RGBColor color) = 0; virtual void SetLED(unsigned int led, RGBColor color) = 0;
virtual void SetAllLEDs(RGBColor color) = 0; virtual void SetAllLEDs(RGBColor color) = 0;
@ -291,6 +310,8 @@ public:
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
void SetupColors(); void SetupColors();
unsigned int GetLEDsInZone(unsigned int zone);
RGBColor GetLED(unsigned int led); RGBColor GetLED(unsigned int led);
void SetLED(unsigned int led, RGBColor color); void SetLED(unsigned int led, RGBColor color);
void SetAllLEDs(RGBColor color); void SetAllLEDs(RGBColor color);

6
qt/DeviceView.cpp
View file

@ -305,7 +305,7 @@ void DeviceView::InitDeviceView()
} }
else else
{ {
unsigned int count = controller->zones[zone_idx].leds_count; unsigned int count = controller->GetLEDsInZone(zone_idx);
zone_pos[zone_idx].matrix_w = std::min(count, (unsigned int)MAX_COLS); zone_pos[zone_idx].matrix_w = std::min(count, (unsigned int)MAX_COLS);
totalHeight += (count / MAX_COLS) + ((count % MAX_COLS) > 0); totalHeight += (count / MAX_COLS) + ((count % MAX_COLS) > 0);
} }
@ -473,7 +473,7 @@ void DeviceView::InitDeviceView()
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Calculate LED box positions for single/linear zones | | Calculate LED box positions for single/linear zones |
\*-----------------------------------------------------*/ \*-----------------------------------------------------*/
unsigned int leds_count = controller->zones[zone_idx].leds_count; unsigned int leds_count = controller->GetLEDsInZone(zone_idx);
for(unsigned int led_idx = 0; led_idx < leds_count; led_idx++) for(unsigned int led_idx = 0; led_idx < leds_count; led_idx++)
{ {
@ -1033,7 +1033,7 @@ bool DeviceView::selectZone(int zone, bool add)
int zoneStart = controller->zones[zone].start_idx; int zoneStart = controller->zones[zone].start_idx;
for(int led_idx = 0; led_idx < (int)controller->zones[zone].leds_count; led_idx++) for(int led_idx = 0; led_idx < controller->GetLEDsInZone(zone); led_idx++)
{ {
if(!selectionFlags[zoneStart + led_idx]) if(!selectionFlags[zoneStart + led_idx])
{ {

15
qt/OpenRGBDevicePage/OpenRGBDevicePage.cpp
View file

@ -307,13 +307,15 @@ void Ui::OpenRGBDevicePage::on_ZoneBox_currentIndexChanged(int index)
\*-----------------------------------------*/ \*-----------------------------------------*/
else if(selected_zone != -1 && selected_segment == -1) else if(selected_zone != -1 && selected_segment == -1)
{ {
unsigned int leds_in_zone = device->GetLEDsInZone(selected_zone);
/*-------------------------------------*\ /*-------------------------------------*\
| If there are multiple LEDs, add the | | If there are multiple LEDs, add the |
| "Entire Zone" option to the LED box | | "Entire Zone" option to the LED box |
| and enable it, otherwise there is | | and enable it, otherwise there is |
| only one LED so disable it | | only one LED so disable it |
\*-------------------------------------*/ \*-------------------------------------*/
if(device->zones[selected_zone].leds_count > 1) if(leds_in_zone > 1)
{ {
ui->LEDBox->addItem(tr("Entire Zone")); ui->LEDBox->addItem(tr("Entire Zone"));
ui->LEDBox->setEnabled(1); ui->LEDBox->setEnabled(1);
@ -327,7 +329,7 @@ void Ui::OpenRGBDevicePage::on_ZoneBox_currentIndexChanged(int index)
| Fill in the LED list with all LEDs in | | Fill in the LED list with all LEDs in |
| the zone | | the zone |
\*-------------------------------------*/ \*-------------------------------------*/
for(std::size_t led_idx = 0; led_idx < device->zones[selected_zone].leds_count; led_idx++) for(std::size_t led_idx = 0; led_idx < leds_in_zone; led_idx++)
{ {
ui->LEDBox->addItem(device->zones[selected_zone].leds[led_idx].name.c_str()); ui->LEDBox->addItem(device->zones[selected_zone].leds[led_idx].name.c_str());
} }
@ -591,9 +593,9 @@ void Ui::OpenRGBDevicePage::on_LEDBox_currentIndexChanged(int index)
/*-------------------------------------*\ /*-------------------------------------*\
| Handle single selected LED | | Handle single selected LED |
\*-------------------------------------*/ \*-------------------------------------*/
if(device->zones[selected_zone].leds_count == 1 || selected_led != -1) if(device->GetLEDsInZone(selected_zone) == 1 || selected_led != -1)
{ {
if((unsigned int)selected_led < device->zones[selected_zone].leds_count) if((unsigned int)selected_led < device->GetLEDsInZone(selected_zone))
{ {
/*-----------------------------*\ /*-----------------------------*\
| Get selected LED's current | | Get selected LED's current |
@ -1624,9 +1626,10 @@ void Ui::OpenRGBDevicePage::on_EditZoneButton_clicked()
} }
/*-----------------------------------------*\ /*-----------------------------------------*\
| Only allow resizing linear zones | | Only allow resizing linear zones or |
| effects-only resizable zones |
\*-----------------------------------------*/ \*-----------------------------------------*/
if(device->zones[selected_zone].type == ZONE_TYPE_LINEAR) if((device->zones[selected_zone].type == ZONE_TYPE_LINEAR) || (device->zones[selected_zone].flags & ZONE_FLAG_RESIZE_EFFECTS_ONLY))
{ {
OpenRGBZoneResizeDialog dlg(device, selected_zone); OpenRGBZoneResizeDialog dlg(device, selected_zone);