mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2025-12-23 23:37:48 -05:00
Code Issues Packages Projects Releases Wiki Activity

Fix segment creation and modification over the network protocol

Browse Source
This commit is contained in:
Adam Honse
2024-07-25 23:11:48 -05:00
parent e634a77860
commit 012cb5e62d
9 changed files with 261 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
NetworkClient.cpp
View File

@@ -609,6 +609,8 @@ void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * d
for(unsigned int i = 0; i < server_controllers[dev_idx]->zones.size(); i++)
{
server_controllers[dev_idx]->zones[i].leds_count = new_controller->zones[i].leds_count;
server_controllers[dev_idx]->zones[i].segments.clear();
server_controllers[dev_idx]->zones[i].segments = new_controller->zones[i].segments;
}
server_controllers[dev_idx]->SetupColors();
@@ -754,6 +756,39 @@ void NetworkClient::SendRequest_ProtocolVersion()
send_in_progress.unlock();
}
void NetworkClient::SendRequest_RGBController_ClearSegments(unsigned int dev_idx, int zone)
{
if(change_in_progress)
{
return;
}
NetPacketHeader request_hdr;
int request_data[1];
InitNetPacketHeader(&request_hdr, dev_idx, NET_PACKET_ID_RGBCONTROLLER_CLEARSEGMENTS, sizeof(request_data));
request_data[0] = zone;
send(client_sock, (char *)&request_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
send(client_sock, (char *)&request_data, sizeof(request_data), MSG_NOSIGNAL);
}
void NetworkClient::SendRequest_RGBController_AddSegment(unsigned int dev_idx, unsigned char * data, unsigned int size)
{
if(change_in_progress)
{
return;
}
NetPacketHeader request_hdr;
InitNetPacketHeader(&request_hdr, dev_idx, NET_PACKET_ID_RGBCONTROLLER_ADDSEGMENT, size);
send(client_sock, (char *)&request_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
send(client_sock, (char *)data, size, 0);
}
void NetworkClient::SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size)
{
if(change_in_progress)

4
NetworkClient.h
View File

@@ -48,7 +48,7 @@ public:
void ListenThreadFunction();
void WaitOnControllerData();
void ProcessReply_ControllerCount(unsigned int data_size, char * data);
void ProcessReply_ControllerData(unsigned int data_size, char * data, unsigned int dev_idx);
void ProcessReply_ProtocolVersion(unsigned int data_size, char * data);
@@ -61,6 +61,8 @@ public:
void SendRequest_ControllerData(unsigned int dev_idx);
void SendRequest_ProtocolVersion();
void SendRequest_RGBController_ClearSegments(unsigned int dev_idx, int zone);
void SendRequest_RGBController_AddSegment(unsigned int dev_idx, unsigned char * data, unsigned int size);
void SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size);
void SendRequest_RGBController_UpdateLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size);

2
NetworkProtocol.h
View File

@@ -74,6 +74,8 @@ enum
| RGBController class functions |
\*----------------------------------------------------------------------------------------------------------*/
NET_PACKET_ID_RGBCONTROLLER_RESIZEZONE = 1000, /* RGBController::ResizeZone() */
NET_PACKET_ID_RGBCONTROLLER_CLEARSEGMENTS = 1001, /* RGBController::ClearSegments() */
NET_PACKET_ID_RGBCONTROLLER_ADDSEGMENT = 1002, /* RGBController::AddSegment() */
NET_PACKET_ID_RGBCONTROLLER_UPDATELEDS = 1050, /* RGBController::UpdateLEDs() */
NET_PACKET_ID_RGBCONTROLLER_UPDATEZONELEDS = 1051, /* RGBController::UpdateZoneLEDs() */

33
NetworkServer.cpp
View File

@@ -932,6 +932,39 @@ void NetworkServer::ListenThreadFunction(NetworkClientInfo * client_info)
}
break;
}
break;
case NET_PACKET_ID_RGBCONTROLLER_CLEARSEGMENTS:
if(data == NULL)
{
break;
}
if((header.pkt_dev_idx < controllers.size()) && (header.pkt_size == sizeof(int)))
{
int zone;
memcpy(&zone, data, sizeof(int));
controllers[header.pkt_dev_idx]->zones[zone].segments.clear();
}
break;
case NET_PACKET_ID_RGBCONTROLLER_ADDSEGMENT:
{
/*---------------------------------------------------------*\
| Verify the mode description size (first 4 bytes of data) |
| matches the packet size in the header |
\*---------------------------------------------------------*/
if(header.pkt_size == *((unsigned int*)data))
{
if(header.pkt_dev_idx < controllers.size())
{
controllers[header.pkt_dev_idx]->SetSegmentDescription((unsigned char *)data);
}
}
}
break;
}
delete[] data;

152
RGBController/RGBController.cpp
View File

@@ -1723,6 +1723,148 @@ void RGBController::SetSingleLEDColorDescription(unsigned char* data_buf)
memcpy(&colors[led_idx], &data_buf[sizeof(led_idx)], sizeof(RGBColor));
}
unsigned char * RGBController::GetSegmentDescription(int zone, segment new_segment)
{
unsigned int data_ptr = 0;
unsigned int data_size = 0;
/*---------------------------------------------------------*\
| Length of data size |
\*---------------------------------------------------------*/
data_size += sizeof(data_size);
/*---------------------------------------------------------*\
| Length of zone index |
\*---------------------------------------------------------*/
data_size += sizeof(zone);
/*---------------------------------------------------------*\
| Length of segment name string |
\*---------------------------------------------------------*/
data_size += sizeof(unsigned short);
/*---------------------------------------------------------*\
| Segment name string data |
\*---------------------------------------------------------*/
data_size += strlen(new_segment.name.c_str()) + 1;
data_size += sizeof(new_segment.type);
data_size += sizeof(new_segment.start_idx);
data_size += sizeof(new_segment.leds_count);
/*---------------------------------------------------------*\
| Create data buffer |
\*---------------------------------------------------------*/
unsigned char *data_buf = new unsigned char[data_size];
/*---------------------------------------------------------*\
| Copy in data size |
\*---------------------------------------------------------*/
memcpy(&data_buf[data_ptr], &data_size, sizeof(data_size));
data_ptr += sizeof(data_size);
/*---------------------------------------------------------*\
| Copy in zone index |
\*---------------------------------------------------------*/
memcpy(&data_buf[data_ptr], &zone, sizeof(zone));
data_ptr += sizeof(zone);
/*---------------------------------------------------------*\
| Length of segment name string |
\*---------------------------------------------------------*/
unsigned short segment_name_length = strlen(new_segment.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], new_segment.name.c_str());
data_ptr += segment_name_length;
/*---------------------------------------------------------*\
| Segment type data |
\*---------------------------------------------------------*/
memcpy(&data_buf[data_ptr], &new_segment.type, sizeof(new_segment.type));
data_ptr += sizeof(new_segment.type);
/*---------------------------------------------------------*\
| Segment start index data |
\*---------------------------------------------------------*/
memcpy(&data_buf[data_ptr], &new_segment.start_idx, sizeof(new_segment.start_idx));
data_ptr += sizeof(new_segment.start_idx);
/*---------------------------------------------------------*\
| Segment LED count data |
\*---------------------------------------------------------*/
memcpy(&data_buf[data_ptr], &new_segment.leds_count, sizeof(new_segment.leds_count));
data_ptr += sizeof(new_segment.leds_count);
return(data_buf);
}
void RGBController::SetSegmentDescription(unsigned char* data_buf)
{
unsigned int data_ptr = sizeof(unsigned int);
/*---------------------------------------------------------*\
| Copy in zone index |
\*---------------------------------------------------------*/
unsigned int zone_idx;
memcpy(&zone_idx, &data_buf[data_ptr], sizeof(zone_idx));
data_ptr += sizeof(zone_idx);
/*---------------------------------------------------------*\
| Length of segment name string |
\*---------------------------------------------------------*/
unsigned short segment_name_length;
memcpy(&segment_name_length, &data_buf[data_ptr], sizeof(segment_name_length));
data_ptr += sizeof(segment_name_length);
/*---------------------------------------------------------*\
| Segment name string data |
\*---------------------------------------------------------*/
char * segment_name = new char[segment_name_length];
memcpy(segment_name, &data_buf[data_ptr], segment_name_length);
data_ptr += segment_name_length;
/*---------------------------------------------------------*\
| Segment type data |
\*---------------------------------------------------------*/
zone_type segment_type;
memcpy(&segment_type, &data_buf[data_ptr], sizeof(segment_type));
data_ptr += sizeof(segment_type);
/*---------------------------------------------------------*\
| Segment start index data |
\*---------------------------------------------------------*/
unsigned int segment_start_idx;
memcpy(&segment_start_idx, &data_buf[data_ptr], sizeof(segment_start_idx));
data_ptr += sizeof(segment_start_idx);
/*---------------------------------------------------------*\
| Segment LED count data |
\*---------------------------------------------------------*/
unsigned int segment_leds_count;
memcpy(&segment_leds_count, &data_buf[data_ptr], sizeof(segment_leds_count));
data_ptr += sizeof(segment_leds_count);
/*---------------------------------------------------------*\
| Add new segment |
\*---------------------------------------------------------*/
segment new_segment;
new_segment.name = segment_name;
new_segment.type = segment_type;
new_segment.start_idx = segment_start_idx;
new_segment.leds_count = segment_leds_count;
AddSegment(zone_idx, new_segment);
delete[] segment_name;
}
void RGBController::SetupColors()
{
unsigned int total_led_count;
@@ -1970,6 +2112,16 @@ void RGBController::DeviceSaveMode()
\*-------------------------------------------------*/
}
void RGBController::ClearSegments(int zone)
{
zones[zone].segments.clear();
}
void RGBController::AddSegment(int zone, segment new_segment)
{
zones[zone].segments.push_back(new_segment);
}
std::string device_type_to_str(device_type type)
{
switch(type)

9
RGBController/RGBController.h
View File

@@ -276,6 +276,9 @@ public:
virtual void DeviceCallThreadFunction() = 0;
virtual void ClearSegments(int zone) = 0;
virtual void AddSegment(int zone, segment new_segment) = 0;
/*---------------------------------------------------------*\
| Functions to be implemented in device implementation |
\*---------------------------------------------------------*/
@@ -357,6 +360,9 @@ public:
unsigned char * GetSingleLEDColorDescription(int led);
void SetSingleLEDColorDescription(unsigned char* data_buf);
unsigned char * GetSegmentDescription(int zone, segment new_segment);
void SetSegmentDescription(unsigned char* data_buf);
void RegisterUpdateCallback(RGBControllerCallback new_callback, void * new_callback_arg);
void UnregisterUpdateCallback(void * callback_arg);
void ClearCallbacks();
@@ -371,6 +377,9 @@ public:
void DeviceCallThreadFunction();
void ClearSegments(int zone);
void AddSegment(int zone, segment new_segment);
/*---------------------------------------------------------*\
| Functions to be implemented in device implementation |
\*---------------------------------------------------------*/

23
RGBController/RGBController_Network.cpp
View File

@@ -25,6 +25,29 @@ void RGBController_Network::SetupZones()
//Don't send anything, this function should only process on host
}
void RGBController_Network::ClearSegments(int zone)
{
client->SendRequest_RGBController_ClearSegments(dev_idx, zone);
client->SendRequest_ControllerData(dev_idx);
client->WaitOnControllerData();
}
void RGBController_Network::AddSegment(int zone, segment new_segment)
{
unsigned char * data = GetSegmentDescription(zone, new_segment);
unsigned int size;
memcpy(&size, &data[0], sizeof(unsigned int));
client->SendRequest_RGBController_AddSegment(dev_idx, data, size);
delete[] data;
client->SendRequest_ControllerData(dev_idx);
client->WaitOnControllerData();
}
void RGBController_Network::ResizeZone(int zone, int new_size)
{
client->SendRequest_RGBController_ResizeZone(dev_idx, zone, new_size);

2
RGBController/RGBController_Network.h
View File

@@ -22,6 +22,8 @@ public:
void SetupZones();
void ClearSegments(int zone);
void AddSegment(int zone, segment new_segment);
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();

4
qt/OpenRGBZoneResizeDialog/OpenRGBZoneResizeDialog.cpp
View File

@@ -183,7 +183,7 @@ int Ui::OpenRGBZoneResizeDialog::show()
{
edit_dev->ResizeZone(edit_zone_idx, ret_val);
edit_dev->zones[edit_zone_idx].segments.clear();
edit_dev->ClearSegments(edit_zone_idx);
unsigned int start_idx = 0;
@@ -195,7 +195,7 @@ int Ui::OpenRGBZoneResizeDialog::show()
new_segment.start_idx = start_idx;
new_segment.leds_count = ((QLineEdit*)ui->SegmentsTreeWidget->itemWidget(ui->SegmentsTreeWidget->topLevelItem(item_idx), 1))->text().toInt();
edit_dev->zones[edit_zone_idx].segments.push_back(new_segment);
edit_dev->AddSegment(edit_zone_idx, new_segment);
start_idx += new_segment.leds_count;
}