Segments

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp

@@ -206,6 +206,9 @@ void NZXTHue2Controller::UpdateDeviceList()
                 break;
             }
 
+            channel_dev_ids[chan][dev] = usb_buf[start + dev];
+            channel_dev_szs[chan][dev] = num_leds_in_device;
+
             LOG_DEBUG("[NZXT Hue 2] %d: Device ID: %02X LEDs: %d", dev, usb_buf[start + dev], num_leds_in_device);
 
             num_leds_on_channel += num_leds_in_device;

Controllers/NZXTHue2Controller/NZXTHue2Controller.h

@@ -109,6 +109,8 @@ public:
     void            UpdateStatus();
     
     unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
+    unsigned int    channel_dev_ids[HUE_2_NUM_CHANNELS][6];
+    unsigned int    channel_dev_szs[HUE_2_NUM_CHANNELS][6];
 
 private:
     hid_device*     dev;

Controllers/NZXTHue2Controller/RGBController_NZXTHue2.cpp

@@ -245,6 +245,85 @@ void RGBController_NZXTHue2::SetupZones()
         }
     }
 
+    /*-------------------------------------------------*\
+    | Set up segments                                   |
+    \*-------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int start_idx = 0;
+
+        for(unsigned int dev_idx = 0; dev_idx < 6; dev_idx++)
+        {
+            std::string device_name = "";
+            switch(controller->channel_dev_ids[zone_idx][dev_idx])
+            {
+            case 0x01: //Hue 1 strip
+                device_name = "Hue 1 strip";
+                break;
+
+            case 0x02: //Aer 1 fan
+                device_name = "Aer 1 fan";
+                break;
+
+            case 0x04: //Hue 2 strip (10 LEDs)
+                device_name = "Hue 2 strip (10 LEDs)";
+                break;
+
+            case 0x05: //Hue 2 strip (8 LEDs)
+                device_name = "Hue 2 strip (8 LEDs)";
+                break;
+
+            case 0x06: //Hue 2 strip (6 LEDs)
+                device_name = "Hue 2 strip (6 LEDs)";
+                break;
+
+            case 0x09: //Hue 2 Underglow (300mm) (15 LEDs)
+                device_name = "Hue 2 Underglow (300mm) (15 LEDs)";
+                break;
+
+            case 0x0A: //Hue 2 Underglow (200mm) (10 LEDs)
+                device_name = "Hue 2 Underglow (200mm) (10 LEDs)";
+                break;
+
+            case 0x0B: //Aer 2 fan (120mm)
+                device_name = "Aer 2 fan (120mm)";
+                break;
+
+            case 0x0C: //Aer 2 fan (140mm)
+                device_name = "Aer 2 fan (140mm)";
+                break;
+
+            case 0x10: //Kraken X3 ring
+                device_name = "Kraken X3 ring";
+                break;
+
+            case 0x11: //Kraken X3 logo
+                device_name = "Kraken X3 logo";
+                break;
+
+            case 0x08: //Hue 2 Cable Comb (14 LEDs)
+                device_name = "Hue 2 Cable Comb (14 LEDs)";
+                break;
+
+            default:
+                break;
+            }
+
+            if(device_name != "")
+            {
+                segment new_segment;
+                new_segment.name = device_name;
+                new_segment.type = ZONE_TYPE_LINEAR;
+                new_segment.start_idx = start_idx;
+                new_segment.leds_count = controller->channel_dev_szs[zone_idx][dev_idx];
+
+                zones[zone_idx].segments.push_back(new_segment);
+
+                start_idx += new_segment.leds_count;
+            }
+        }
+    }
+
     SetupColors();
 }
 

NetworkProtocol.h

@@ -15,8 +15,9 @@
 |   1:      Add versioning, vendor string (Release 0.5) |
 |   2:      Add profile controls (Release 0.6)          |
 |   3:      Add brightness field to modes (Release 0.7) |
+|   4:      Add segments field to zones (Release 0.9)   |
 \*-----------------------------------------------------*/
-#define OPENRGB_SDK_PROTOCOL_VERSION    3
+#define OPENRGB_SDK_PROTOCOL_VERSION    4
 
 /*-----------------------------------------------------*\
 | Default Interface to bind to.                         |

ProfileManager.cpp

@@ -271,6 +271,11 @@ bool ProfileManager::LoadDeviceFromListWithOptions
                          &&(temp_controller->zones[zone_idx].leds_count != load_controller->zones[zone_idx].leds_count))
                         {
                             load_controller->ResizeZone(zone_idx, temp_controller->zones[zone_idx].leds_count);
+
+                            for(std::size_t segment_idx = 0; segment_idx < temp_controller->zones[zone_idx].segments.size(); segment_idx++)
+                            {
+                                load_controller->zones[zone_idx].segments.push_back(temp_controller->zones[zone_idx].segments[segment_idx]);
+                            }
                         }
                     }
                 }

RGBController/RGBController.cpp

@@ -137,6 +137,31 @@ unsigned char * RGBController::GetDeviceDescription(unsigned int protocol_versio
 
         data_size += sizeof(zone_matrix_len[zone_index]);
         data_size += zone_matrix_len[zone_index];
+
+        if(protocol_version >= 4)
+        {
+            /*---------------------------------------------------------*\
+            | Number of segments in zone                                |
+            \*---------------------------------------------------------*/
+            data_size += sizeof(unsigned short);
+
+            for(int segment_index = 0; segment_index < zones[zone_index].segments.size(); segment_index++)
+            {
+                /*---------------------------------------------------------*\
+                | Length of segment name string                             |
+                \*---------------------------------------------------------*/
+                data_size += sizeof(unsigned short);
+
+                /*---------------------------------------------------------*\
+                | Segment name string data                                  |
+                \*---------------------------------------------------------*/
+                data_size += strlen(zones[zone_index].segments[segment_index].name.c_str()) + 1;
+
+                data_size += sizeof(zones[zone_index].segments[segment_index].type);
+                data_size += sizeof(zones[zone_index].segments[segment_index].start_idx);
+                data_size += sizeof(zones[zone_index].segments[segment_index].leds_count);
+            }
+        }
     }
 
     data_size += sizeof(num_leds);
@@ -424,6 +449,55 @@ unsigned char * RGBController::GetDeviceDescription(unsigned int protocol_versio
                 data_ptr += sizeof(zones[zone_index].matrix_map->map[matrix_idx]);
             }
         }
+
+        /*---------------------------------------------------------*\
+        | Copy in segments                                          |
+        \*---------------------------------------------------------*/
+        if(protocol_version >= 4)
+        {
+            unsigned short num_segments = zones[zone_index].segments.size();
+
+            /*---------------------------------------------------------*\
+            | Number of segments in zone                                |
+            \*---------------------------------------------------------*/
+            memcpy(&data_buf[data_ptr], &num_segments, sizeof(num_segments));
+            data_ptr += sizeof(num_segments);
+
+            for(int segment_index = 0; segment_index < num_segments; segment_index++)
+            {
+                /*---------------------------------------------------------*\
+                | Length of segment name string                             |
+                \*---------------------------------------------------------*/
+                unsigned short segment_name_length = strlen(zones[zone_index].segments[segment_index].name.c_str()) + 1;
+                
+                memcpy(&data_buf[data_ptr], &segment_name_length, sizeof(segment_name_length));
+                data_ptr += sizeof(segment_name_length);
+
+                /*---------------------------------------------------------*\
+                | Segment name string data                                  |
+                \*---------------------------------------------------------*/
+                strcpy((char *)&data_buf[data_ptr], zones[zone_index].segments[segment_index].name.c_str());
+                data_ptr += segment_name_length;
+
+                /*---------------------------------------------------------*\
+                | Segment type data                                         |
+                \*---------------------------------------------------------*/
+                memcpy(&data_buf[data_ptr], &zones[zone_index].segments[segment_index].type, sizeof(zones[zone_index].segments[segment_index].type));
+                data_ptr += sizeof(zones[zone_index].segments[segment_index].type);
+
+                /*---------------------------------------------------------*\
+                | Segment start index data                                  |
+                \*---------------------------------------------------------*/
+                memcpy(&data_buf[data_ptr], &zones[zone_index].segments[segment_index].start_idx, sizeof(zones[zone_index].segments[segment_index].start_idx));
+                data_ptr += sizeof(zones[zone_index].segments[segment_index].start_idx);
+
+                /*---------------------------------------------------------*\
+                | Segment LED count data                                  |
+                \*---------------------------------------------------------*/
+                memcpy(&data_buf[data_ptr], &zones[zone_index].segments[segment_index].leds_count, sizeof(zones[zone_index].segments[segment_index].leds_count));
+                data_ptr += sizeof(zones[zone_index].segments[segment_index].leds_count);
+            }
+        }
     }
 
     /*---------------------------------------------------------*\
@@ -784,6 +858,54 @@ void RGBController::ReadDeviceDescription(unsigned char* data_buf, unsigned int
             new_zone.matrix_map = NULL;
         }
         
+        /*---------------------------------------------------------*\
+        | Copy in segments                                          |
+        \*---------------------------------------------------------*/
+        if(protocol_version >= 4)
+        {
+            unsigned short num_segments = 0;
+
+            /*---------------------------------------------------------*\
+            | Number of segments in zone                                |
+            \*---------------------------------------------------------*/
+            memcpy(&num_segments, &data_buf[data_ptr], sizeof(num_segments));
+            data_ptr += sizeof(num_segments);
+
+            for(int segment_index = 0; segment_index < num_segments; segment_index++)
+            {
+                segment new_segment;
+
+                /*---------------------------------------------------------*\
+                | Copy in segment name (size+data)                          |
+                \*---------------------------------------------------------*/
+                unsigned short segmentname_len;
+                memcpy(&segmentname_len, &data_buf[data_ptr], sizeof(unsigned short));
+                data_ptr += sizeof(unsigned short);
+
+                new_segment.name = (char *)&data_buf[data_ptr];
+                data_ptr += segmentname_len;
+
+                /*---------------------------------------------------------*\
+                | Segment type data                                         |
+                \*---------------------------------------------------------*/
+                memcpy(&new_segment.type, &data_buf[data_ptr], sizeof(new_segment.type));
+                data_ptr += sizeof(new_segment.type);
+
+                /*---------------------------------------------------------*\
+                | Segment start index data                                  |
+                \*---------------------------------------------------------*/
+                memcpy(&new_segment.start_idx, &data_buf[data_ptr], sizeof(new_segment.start_idx));
+                data_ptr += sizeof(new_segment.start_idx);
+
+                /*---------------------------------------------------------*\
+                | Segment LED count data                                    |
+                \*---------------------------------------------------------*/
+                memcpy(&new_segment.leds_count, &data_buf[data_ptr], sizeof(new_segment.leds_count));
+                data_ptr += sizeof(new_segment.leds_count);
+
+                new_zone.segments.push_back(new_segment);
+            }
+        }
         zones.push_back(new_zone);
     }
 

RGBController/RGBController.h

@@ -135,6 +135,17 @@ typedef struct
     unsigned int *          map;
 } matrix_map_type;
 
+/*------------------------------------------------------------------*\
+| Segment Struct                                                     |
+\*------------------------------------------------------------------*/
+typedef struct
+{
+    std::string             name;           /* Segment name             */
+    zone_type               type;           /* Segment type             */
+    unsigned int            start_idx;      /* Start index within zone  */
+    unsigned int            leds_count;     /* Number of LEDs in segment*/
+} segment;
+
 /*------------------------------------------------------------------*\
 | Zone Struct                                                        |
 \*------------------------------------------------------------------*/
@@ -149,6 +160,7 @@ typedef struct
     unsigned int            leds_min;       /* Minimum number of LEDs   */
     unsigned int            leds_max;       /* Maximum number of LEDs   */
     matrix_map_type *       matrix_map;     /* Matrix map pointer       */
+	std::vector<segment>    segments;       /* Segments in zone         */
 } zone;
 
 /*------------------------------------------------------------------*\

qt/DeviceView.cpp

@@ -20,6 +20,7 @@
 #define PAD_LED     0.1
 #define PAD_TEXT    0.1
 #define PAD_ZONE    1.0
+#define PAD_SEGMENT 0.9
 #define SIZE_TEXT   0.5
 
 DeviceView::DeviceView(QWidget *parent) :
@@ -226,6 +227,7 @@ void DeviceView::InitDeviceView()
     | Process position and size for zones                   |
     \*-----------------------------------------------------*/
     unsigned int maxWidth       = 0;
+    unsigned int segment_count  = 0;
     float        totalHeight    = 0;
 
     /*-----------------------------------------------------*\
@@ -245,6 +247,17 @@ void DeviceView::InitDeviceView()
         | For all other zones, compute the height including     |
         | wrap-around                                           |
         \*-----------------------------------------------------*/
+        else if(controller->zones[zone_idx].segments.size() > 0)
+        {
+            for(std::size_t segment_idx = 0; segment_idx < controller->zones[zone_idx].segments.size(); segment_idx++)
+            {
+                unsigned int count          = controller->zones[zone_idx].segments[segment_idx].leds_count;
+                zone_pos[zone_idx].matrix_w = std::min(count, (unsigned int)MAX_COLS);
+                totalHeight                += (count / MAX_COLS) + ((count % MAX_COLS) > 0);
+
+                segment_count++;
+            }
+        }
         else
         {
             unsigned int count          = controller->zones[zone_idx].leds_count;
@@ -261,13 +274,17 @@ void DeviceView::InitDeviceView()
         }
     }
 
+    segment_pos.resize(segment_count);
+
     /*-----------------------------------------------------*\
     | Add some space for zone names and padding             |
     \*-----------------------------------------------------*/
     totalHeight    += controller->zones.size() * PAD_ZONE;
+    totalHeight    += segment_count * PAD_SEGMENT;
 
     float current_y = 0;                    // We will be descending, placing each zone one unit below the previous one
     matrix_h        = totalHeight;
+    segment_count   = 0;
 
     for(std::size_t zone_idx = 0; zone_idx < controller->zones.size(); zone_idx++)
     {
@@ -366,6 +383,43 @@ void DeviceView::InitDeviceView()
 
             current_y += map->height;
         }
+        else if(controller->zones[zone_idx].segments.size() > 0)
+        {
+            for(std::size_t segment_idx = 0; segment_idx < controller->zones[zone_idx].segments.size(); segment_idx++)
+            {
+                /*-----------------------------------------------------*\
+                | Calculate segment label position and size             |
+                \*-----------------------------------------------------*/
+                segment_pos[segment_count].matrix_x = (maxWidth - zone_pos[zone_idx].matrix_w) / 2.0;
+                segment_pos[segment_count].matrix_y = current_y + SIZE_TEXT;
+                segment_pos[segment_count].matrix_w = zone_pos[zone_idx].matrix_w;
+                segment_pos[segment_count].matrix_h = SIZE_TEXT - PAD_TEXT;
+                current_y                          += PAD_SEGMENT;
+
+                segment_count++;
+
+                /*-----------------------------------------------------*\
+                | Calculate LED box positions for segmented zones       |
+                \*-----------------------------------------------------*/
+                unsigned int leds_count = controller->zones[zone_idx].segments[segment_idx].leds_count;
+                
+                for(unsigned int led_idx = 0; led_idx < leds_count; led_idx++)
+                {
+                    unsigned int led_pos_idx = controller->zones[zone_idx].start_idx + controller->zones[zone_idx].segments[segment_idx].start_idx + led_idx;
+
+                    led_pos[led_pos_idx].matrix_x = zone_pos[zone_idx].matrix_x + ((led_idx % MAX_COLS) + PAD_LED);
+                    led_pos[led_pos_idx].matrix_y = current_y + ((led_idx / MAX_COLS) + PAD_LED);
+
+                    /*-----------------------------------------------------*\
+                    | LED is a 1x1 square, minus padding on all sides       |
+                    \*-----------------------------------------------------*/
+                    led_pos[led_pos_idx].matrix_w = (1 - (2 * PAD_LED));
+                    led_pos[led_pos_idx].matrix_h = (1 - (2 * PAD_LED));
+                }
+
+                current_y += (leds_count / MAX_COLS) + ((leds_count % MAX_COLS) > 0);
+            }
+        }
         else
         {
             /*-----------------------------------------------------*\
@@ -409,7 +463,7 @@ void DeviceView::InitDeviceView()
     }
 
     /*-----------------------------------------------------*\
-    | Scale the zones and LEDs                              |
+    | Scale the zones, segments, and LEDs                   |
     |                                                       |
     | Atom is the width of a single square; if the whole    |
     | thing becomes too tall, we ignore it and let the view |
@@ -425,6 +479,14 @@ void DeviceView::InitDeviceView()
         zone_pos[zone_idx].matrix_h *= atom;
     }
 
+    for(std::size_t segment_idx = 0; segment_idx < segment_pos.size(); segment_idx++)
+    {
+        segment_pos[segment_idx].matrix_x *= atom;
+        segment_pos[segment_idx].matrix_y *= atom;
+        segment_pos[segment_idx].matrix_w *= atom;
+        segment_pos[segment_idx].matrix_h *= atom;
+    }
+
     for(std::size_t led_idx = 0; led_idx < led_pos.size(); led_idx++)
     {
         led_pos[led_idx].matrix_x *= atom;
@@ -547,7 +609,7 @@ void DeviceView::mouseReleaseEvent(QMouseEvent* event)
 
             for(std::size_t zone_idx = 0; zone_idx < controller->zones.size(); zone_idx++)
             {
-                int posx = zone_pos[zone_idx].matrix_x * size + offset_x;
+                int posx = zone_pos[zone_idx].matrix_x * size + offset_x + 12;
                 int posy = zone_pos[zone_idx].matrix_y * size;
                 int posw = zone_pos[zone_idx].matrix_w * size;
                 int posh = zone_pos[zone_idx].matrix_h * size;
@@ -656,8 +718,10 @@ void DeviceView::paintEvent(QPaintEvent* /* event */)
     painter.setFont(font);
 
     /*-----------------------------------------------------*\
-    | Zone names                                            |
+    | Zone and Segment names                                |
     \*-----------------------------------------------------*/
+    unsigned int segment_count = 0;
+
     for(std::size_t zone_idx = 0; zone_idx < controller->zones.size(); zone_idx++)
     {
         int posx = zone_pos[zone_idx].matrix_x * size + offset_x;
@@ -676,6 +740,28 @@ void DeviceView::paintEvent(QPaintEvent* /* event */)
             painter.setPen(palette().windowText().color());
         }
         painter.drawText(posx, posy + posh, QString(controller->zones[zone_idx].name.c_str()));
+
+        for(std::size_t segment_idx = 0; segment_idx < controller->zones[zone_idx].segments.size(); segment_idx++)
+        {
+            posx = segment_pos[segment_count].matrix_x * size + offset_x;
+            posy = segment_pos[segment_count].matrix_y * size;
+            posw = segment_pos[segment_count].matrix_w * size;
+            posh = segment_pos[segment_count].matrix_h * size;
+
+            segment_count++;
+
+            rect = {posx, posy, posw, posh};
+
+            if(rect.contains(lastMousePos) && (!mouseDown || !mouseMoved))
+            {
+                painter.setPen(palette().highlight().color());
+            }
+            else
+            {
+                painter.setPen(palette().windowText().color());
+            }
+            painter.drawText(posx, posy + posh, QString(controller->zones[zone_idx].segments[segment_idx].name.c_str()));   
+        }
     }
 
     /*-----------------------------------------------------*\

qt/DeviceView.h

@@ -49,6 +49,7 @@ private:
     bool per_led;
 
     std::vector<matrix_pos_size_type>   zone_pos;
+    std::vector<matrix_pos_size_type>   segment_pos;
     std::vector<matrix_pos_size_type>   led_pos;
     std::vector<QString>                led_labels;
 

qt/OpenRGBDevicePage.cpp

@@ -1089,16 +1089,12 @@ void Ui::OpenRGBDevicePage::on_ResizeButton_clicked()
 
             if(device->zones[selected_zone].type == ZONE_TYPE_LINEAR)
             {
-                OpenRGBZoneResizeDialog dlg(device->zones[selected_zone].leds_min,
+                OpenRGBZoneResizeDialog dlg(device, selected_zone);
-                                            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                                        |
                     \*-----------------------------------------------------*/
@@ -1117,7 +1113,7 @@ void Ui::OpenRGBDevicePage::on_ResizeButton_clicked()
             }
         }
         break;
-
+#if 0
     case MODE_COLORS_MODE_SPECIFIC:
         {
             OpenRGBZoneResizeDialog dlg(device->modes[device->active_mode].colors_min,
@@ -1135,6 +1131,7 @@ void Ui::OpenRGBDevicePage::on_ResizeButton_clicked()
             UpdateMode();
         }
         break;
+#endif
     }
 }
 

qt/OpenRGBDevicePage.ui

@@ -276,7 +276,7 @@
       <item row="0" column="3">
        <widget class="QPushButton" name="ResizeButton">
         <property name="text">
-         <string>Resize</string>
+         <string>Edit</string>
         </property>
        </widget>
       </item>

qt/OpenRGBZoneResizeDialog.cpp

@@ -1,11 +1,20 @@
 #include "OpenRGBZoneResizeDialog.h"
 
+#include <QLineEdit>
+
 using namespace Ui;
 
-OpenRGBZoneResizeDialog::OpenRGBZoneResizeDialog(int size_min, int size_max, int size_current, QWidget *parent) :
+OpenRGBZoneResizeDialog::OpenRGBZoneResizeDialog(RGBController* edit_dev_ptr, unsigned int edit_zone_idx_val, QWidget *parent) :
     QDialog(parent),
     ui(new Ui::OpenRGBZoneResizeDialogUi)
 {
+    edit_dev      = edit_dev_ptr;
+    edit_zone_idx = edit_zone_idx_val;
+
+    unsigned int size_min     = edit_dev->zones[edit_zone_idx].leds_min;
+    unsigned int size_max     = edit_dev->zones[edit_zone_idx].leds_max;
+    unsigned int size_current = edit_dev->zones[edit_zone_idx].leds_count;
+
     ui->setupUi(this);
 
     ui->ResizeSlider->setRange(size_min, size_max);
@@ -13,6 +22,23 @@ OpenRGBZoneResizeDialog::OpenRGBZoneResizeDialog(int size_min, int size_max, int
 
     ui->ResizeSlider->setValue(size_current);
     ui->ResizeBox->setValue(size_current);
+
+    for(unsigned int segment_idx = 0; segment_idx < edit_dev->zones[edit_zone_idx].segments.size(); segment_idx++)
+    {
+        QTreeWidgetItem* new_item = new QTreeWidgetItem(ui->SegmentsTreeWidget);
+
+        QLineEdit* lineedit_name = new QLineEdit(ui->SegmentsTreeWidget);
+        QLineEdit* lineedit_start = new QLineEdit(ui->SegmentsTreeWidget);
+        QLineEdit* lineedit_length = new QLineEdit(ui->SegmentsTreeWidget);
+
+        lineedit_name->setText(QString::fromStdString(edit_dev->zones[edit_zone_idx].segments[segment_idx].name));
+        lineedit_start->setText(QString::number(edit_dev->zones[edit_zone_idx].segments[segment_idx].start_idx));
+        lineedit_length->setText(QString::number(edit_dev->zones[edit_zone_idx].segments[segment_idx].leds_count));
+
+        ui->SegmentsTreeWidget->setItemWidget(new_item, 0, lineedit_name);
+        ui->SegmentsTreeWidget->setItemWidget(new_item, 1, lineedit_start);
+        ui->SegmentsTreeWidget->setItemWidget(new_item, 2, lineedit_length);
+    }
 }
 
 OpenRGBZoneResizeDialog::~OpenRGBZoneResizeDialog()
@@ -57,5 +83,43 @@ int Ui::OpenRGBZoneResizeDialog::show()
         ret_val = ui->ResizeBox->value();
     }
 
+    if(ret_val >= 0)
+    {
+        edit_dev->ResizeZone(edit_zone_idx, ret_val);
+
+        edit_dev->zones[edit_zone_idx].segments.clear();
+
+        for(unsigned int item_idx = 0; item_idx < ui->SegmentsTreeWidget->topLevelItemCount(); item_idx++)
+        {
+            segment new_segment;
+            new_segment.type       = ZONE_TYPE_LINEAR;
+            new_segment.name       = ((QLineEdit*)ui->SegmentsTreeWidget->itemWidget(ui->SegmentsTreeWidget->topLevelItem(item_idx), 0))->text().toStdString();
+            new_segment.start_idx  = ((QLineEdit*)ui->SegmentsTreeWidget->itemWidget(ui->SegmentsTreeWidget->topLevelItem(item_idx), 1))->text().toInt();
+            new_segment.leds_count = ((QLineEdit*)ui->SegmentsTreeWidget->itemWidget(ui->SegmentsTreeWidget->topLevelItem(item_idx), 2))->text().toInt();
+
+            edit_dev->zones[edit_zone_idx].segments.push_back(new_segment);
+        }
+    }
+
     return(ret_val);
 }
+
+void Ui::OpenRGBZoneResizeDialog::on_AddSegmentButton_clicked()
+{
+	QTreeWidgetItem* new_item = new QTreeWidgetItem(ui->SegmentsTreeWidget);
+    
+    QLineEdit* lineedit_name = new QLineEdit(ui->SegmentsTreeWidget);
+    QLineEdit* lineedit_start = new QLineEdit(ui->SegmentsTreeWidget);
+    QLineEdit* lineedit_length = new QLineEdit(ui->SegmentsTreeWidget);
+
+    ui->SegmentsTreeWidget->setItemWidget(new_item, 0, lineedit_name);
+    ui->SegmentsTreeWidget->setItemWidget(new_item, 1, lineedit_start);
+    ui->SegmentsTreeWidget->setItemWidget(new_item, 2, lineedit_length);
+}
+
+
+void Ui::OpenRGBZoneResizeDialog::on_RemoveSegmentButton_clicked()
+{
+    ui->SegmentsTreeWidget->takeTopLevelItem(ui->SegmentsTreeWidget->topLevelItemCount() - 1);
+}
+

qt/OpenRGBZoneResizeDialog.h

@@ -4,6 +4,8 @@
 #include <QDialog>
 #include "ui_OpenRGBZoneResizeDialog.h"
 
+#include "RGBController.h"
+
 namespace Ui {
 class OpenRGBZoneResizeDialog;
 }
@@ -13,7 +15,7 @@ class Ui::OpenRGBZoneResizeDialog : public QDialog
     Q_OBJECT
 
 public:
-    explicit OpenRGBZoneResizeDialog(int size_min, int size_max, int size_current, QWidget *parent = nullptr);
+    explicit OpenRGBZoneResizeDialog(RGBController* edit_dev_ptr, unsigned int edit_zone_idx_val, QWidget *parent = nullptr);
     ~OpenRGBZoneResizeDialog();
 
     int show();
@@ -24,8 +26,14 @@ private slots:
 
     void on_ResizeBox_valueChanged(int arg1);
 
+    void on_AddSegmentButton_clicked();
+
+    void on_RemoveSegmentButton_clicked();
+
 private:
     Ui::OpenRGBZoneResizeDialogUi *ui;
+    RGBController* edit_dev;
+    unsigned int edit_zone_idx;
 };
 
 #endif // OPENRGBZONERESIZEDIALOG_H

qt/OpenRGBZoneResizeDialog.ui

@@ -6,14 +6,32 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>233</width>
+    <width>340</width>
-    <height>73</height>
+    <height>187</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Resize Zone</string>
   </property>
   <layout class="QGridLayout" name="gridLayout" columnstretch="1,0">
+   <item row="3" column="0" colspan="2">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QPushButton" name="AddSegmentButton">
+       <property name="text">
+        <string>Add Segment</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="RemoveSegmentButton">
+       <property name="text">
+        <string>Remove Segment</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
    <item row="0" column="0">
     <widget class="QTooltipedSlider" name="ResizeSlider">
      <property name="sizePolicy">
@@ -27,17 +45,29 @@
      </property>
     </widget>
    </item>
-   <item row="0" column="1">
+   <item row="1" column="0" colspan="2">
-    <widget class="QSpinBox" name="ResizeBox">
+    <widget class="QTreeWidget" name="SegmentsTreeWidget">
-     <property name="sizePolicy">
+     <property name="columnCount">
-      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+      <number>3</number>
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
      </property>
+     <column>
+      <property name="text">
+       <string notr="true">Name</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>Start</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>Length</string>
+      </property>
+     </column>
     </widget>
    </item>
-   <item row="1" column="0" colspan="2">
+   <item row="4" column="0" colspan="2">
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
@@ -53,6 +83,16 @@
      </property>
     </widget>
    </item>
+   <item row="0" column="1">
+    <widget class="QSpinBox" name="ResizeBox">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+    </widget>
+   </item>
   </layout>
  </widget>
  <customwidgets>