mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2025-12-24 15:57:50 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
1996d346500896e0ade3054b83553624bfccdf01
OpenRGB/Controllers/DebugController/DebugControllerDetect.cpp
Chris M 1996d34650 Updated Debug Keyboard to process KLM Opcodes 
* Added InsertRow, RemoveRow and RemoveKey opcodes.
* Adjusted iterator for style and formatting.
2023-09-17 10:36:29 +10:00

751 lines
37 KiB
C++
Raw Blame History

#include "Detector.h"
#include "RGBController.h"
#include "RGBController_Debug.h"
#include "RGBController_Dummy.h"
#include "RGBControllerKeyNames.h"
#include "KeyboardLayoutManager.h"
#include "SettingsManager.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <string>
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int dummy_keyboard_underglow_map[3][10] =
{ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 },
{ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 } };
/******************************************************************************************\
* *
* DetectDebugControllers *
* *
* Add dummy controllers based on the DebugDevices key in the settings json *
* *
\******************************************************************************************/
void DetectDebugControllers()
{
json debug_settings;
/*-------------------------------------------------*\
| Get Debug Device settings from settings manager |
\*-------------------------------------------------*/
debug_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DebugDevices");
/*-------------------------------------------------*\
| If the Debug settings contains devices, process |
\*-------------------------------------------------*/
if(debug_settings.contains("devices"))
{
for(unsigned int device_idx = 0; device_idx < debug_settings["devices"].size(); device_idx++)
{
std::string type = "";
if(debug_settings["devices"][device_idx].contains("type"))
{
type = debug_settings["devices"][device_idx]["type"];
}
if(type == "motherboard")
{
/*---------------------------------------------------------*\
| Create a dummy motherboard |
\*---------------------------------------------------------*/
RGBController_Dummy* dummy_motherboard = new RGBController_Dummy();
dummy_motherboard->name = "Debug Motherboard";
dummy_motherboard->type = DEVICE_TYPE_MOTHERBOARD;
dummy_motherboard->description = "Debug Motherboard Device";
dummy_motherboard->location = "Debug Motherboard Location";
dummy_motherboard->version = "Debug Motherboard Version";
dummy_motherboard->serial = "Debug Motherboard Serial";
/*---------------------------------------------------------*\
| Create a direct mode for the dummy motherboard |
\*---------------------------------------------------------*/
mode dummy_motherboard_direct_mode;
dummy_motherboard_direct_mode.name = "Direct";
dummy_motherboard_direct_mode.value = 0;
dummy_motherboard_direct_mode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_motherboard_direct_mode.color_mode = MODE_COLORS_PER_LED;
dummy_motherboard->modes.push_back(dummy_motherboard_direct_mode);
/*---------------------------------------------------------*\
| Create a single zone/LED for the dummy motherboard |
\*---------------------------------------------------------*/
zone dummy_motherboard_single_zone;
dummy_motherboard_single_zone.name = "Single Zone";
dummy_motherboard_single_zone.type = ZONE_TYPE_SINGLE;
dummy_motherboard_single_zone.leds_min = 1;
dummy_motherboard_single_zone.leds_max = 1;
dummy_motherboard_single_zone.leds_count = 1;
dummy_motherboard_single_zone.matrix_map = NULL;
dummy_motherboard->zones.push_back(dummy_motherboard_single_zone);
led dummy_motherboard_single_led;
dummy_motherboard_single_led.name = "Single LED";
dummy_motherboard->leds.push_back(dummy_motherboard_single_led);
/*---------------------------------------------------------*\
| Create a linear zone for the dummy motherboard |
\*---------------------------------------------------------*/
zone dummy_motherboard_linear_zone;
dummy_motherboard_linear_zone.name = "Linear Zone";
dummy_motherboard_linear_zone.type = ZONE_TYPE_LINEAR;
dummy_motherboard_linear_zone.leds_min = 10;
dummy_motherboard_linear_zone.leds_max = 10;
dummy_motherboard_linear_zone.leds_count = 10;
dummy_motherboard_linear_zone.matrix_map = NULL;
dummy_motherboard->zones.push_back(dummy_motherboard_linear_zone);
for(std::size_t led_idx = 0; led_idx < 10; led_idx++)
{
led dummy_motherboard_linear_led;
dummy_motherboard_linear_led.name = "Linear LED " + std::to_string(led_idx);
dummy_motherboard->leds.push_back(dummy_motherboard_linear_led);
}
dummy_motherboard->SetupColors();
/*---------------------------------------------------------*\
| Push the dummy motherboard onto the controller list |
\*---------------------------------------------------------*/
ResourceManager::get()->RegisterRGBController(dummy_motherboard);
}
else if(type == "dram")
{
/*---------------------------------------------------------*\
| Create a dummy DRAM |
\*---------------------------------------------------------*/
RGBController_Dummy* dummy_dram = new RGBController_Dummy();
dummy_dram->name = "Debug DRAM";
dummy_dram->type = DEVICE_TYPE_DRAM;
dummy_dram->description = "Debug DRAM Device";
dummy_dram->location = "Debug DRAM Location";
dummy_dram->version = "Debug DRAM Version";
dummy_dram->serial = "Debug DRAM Serial";
/*---------------------------------------------------------*\
| Create a direct mode for the dummy DRAM |
\*---------------------------------------------------------*/
mode dummy_dram_direct_mode;
dummy_dram_direct_mode.name = "Direct";
dummy_dram_direct_mode.value = 0;
dummy_dram_direct_mode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_dram_direct_mode.color_mode = MODE_COLORS_PER_LED;
dummy_dram->modes.push_back(dummy_dram_direct_mode);
/*---------------------------------------------------------*\
| Create a single zone/LED for the dummy DRAM |
\*---------------------------------------------------------*/
zone dummy_dram_single_zone;
dummy_dram_single_zone.name = "Single Zone";
dummy_dram_single_zone.type = ZONE_TYPE_SINGLE;
dummy_dram_single_zone.leds_min = 1;
dummy_dram_single_zone.leds_max = 1;
dummy_dram_single_zone.leds_count = 1;
dummy_dram_single_zone.matrix_map = NULL;
dummy_dram->zones.push_back(dummy_dram_single_zone);
led dummy_dram_single_led;
dummy_dram_single_led.name = "Single LED";
dummy_dram->leds.push_back(dummy_dram_single_led);
/*---------------------------------------------------------*\
| Create a linear zone for the dummy DRAM |
\*---------------------------------------------------------*/
zone dummy_dram_linear_zone;
dummy_dram_linear_zone.name = "Linear Zone";
dummy_dram_linear_zone.type = ZONE_TYPE_LINEAR;
dummy_dram_linear_zone.leds_min = 5;
dummy_dram_linear_zone.leds_max = 5;
dummy_dram_linear_zone.leds_count = 5;
dummy_dram_linear_zone.matrix_map = NULL;
dummy_dram->zones.push_back(dummy_dram_linear_zone);
for(std::size_t led_idx = 0; led_idx < 5; led_idx++)
{
led dummy_dram_linear_led;
dummy_dram_linear_led.name = "Linear LED " + std::to_string(led_idx);
dummy_dram->leds.push_back(dummy_dram_linear_led);
}
dummy_dram->SetupColors();
/*---------------------------------------------------------*\
| Push the dummy DRAM onto the controller list |
\*---------------------------------------------------------*/
ResourceManager::get()->RegisterRGBController(dummy_dram);
}
else if(type == "gpu")
{
/*---------------------------------------------------------*\
| Create a dummy GPU |
\*---------------------------------------------------------*/
RGBController_Dummy* dummy_gpu = new RGBController_Dummy();
dummy_gpu->name = "Debug GPU";
dummy_gpu->type = DEVICE_TYPE_GPU;
dummy_gpu->description = "Debug GPU Device";
dummy_gpu->location = "Debug GPU Location";
dummy_gpu->version = "Debug GPU Version";
dummy_gpu->serial = "Debug GPU Serial";
/*---------------------------------------------------------*\
| Create a direct mode for the dummy GPU |
\*---------------------------------------------------------*/
mode dummy_gpu_direct_mode;
dummy_gpu_direct_mode.name = "Direct";
dummy_gpu_direct_mode.value = 0;
dummy_gpu_direct_mode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_gpu_direct_mode.color_mode = MODE_COLORS_PER_LED;
dummy_gpu->modes.push_back(dummy_gpu_direct_mode);
/*---------------------------------------------------------*\
| Create a single zone/LED for the dummy GPU |
\*---------------------------------------------------------*/
zone dummy_gpu_single_zone;
dummy_gpu_single_zone.name = "Single Zone";
dummy_gpu_single_zone.type = ZONE_TYPE_SINGLE;
dummy_gpu_single_zone.leds_min = 1;
dummy_gpu_single_zone.leds_max = 1;
dummy_gpu_single_zone.leds_count = 1;
dummy_gpu_single_zone.matrix_map = NULL;
dummy_gpu->zones.push_back(dummy_gpu_single_zone);
led dummy_gpu_single_led;
dummy_gpu_single_led.name = "Single LED";
dummy_gpu->leds.push_back(dummy_gpu_single_led);
/*---------------------------------------------------------*\
| Create a linear zone for the dummy GPU |
\*---------------------------------------------------------*/
zone dummy_gpu_linear_zone;
dummy_gpu_linear_zone.name = "Linear Zone";
dummy_gpu_linear_zone.type = ZONE_TYPE_LINEAR;
dummy_gpu_linear_zone.leds_min = 15;
dummy_gpu_linear_zone.leds_max = 15;
dummy_gpu_linear_zone.leds_count = 15;
dummy_gpu_linear_zone.matrix_map = NULL;
dummy_gpu->zones.push_back(dummy_gpu_linear_zone);
for(std::size_t led_idx = 0; led_idx < 15; led_idx++)
{
led dummy_gpu_linear_led;
dummy_gpu_linear_led.name = "Linear LED " + std::to_string(led_idx);
dummy_gpu->leds.push_back(dummy_gpu_linear_led);
}
dummy_gpu->SetupColors();
/*---------------------------------------------------------*\
| Push the dummy GPU onto the controller list |
\*---------------------------------------------------------*/
ResourceManager::get()->RegisterRGBController(dummy_gpu);
}
else if(type == "keyboard")
{
json json_kbd = debug_settings["devices"][device_idx];
KEYBOARD_LAYOUT layout = KEYBOARD_LAYOUT::KEYBOARD_LAYOUT_ANSI_QWERTY;
KEYBOARD_SIZE size = KEYBOARD_SIZE::KEYBOARD_SIZE_FULL;
if(json_kbd.contains("layout"))
{
layout = json_kbd["layout"];
}
if(json_kbd.contains("size"))
{
size = json_kbd["size"];
}
/*---------------------------------------------------------*\
| Create a dummy Keyboard |
\*---------------------------------------------------------*/
RGBController_Dummy* dummy_keyboard = new RGBController_Dummy();
KeyboardLayoutManager new_kb(layout, size);
/*---------------------------------------------------------*\
| Check for custom key inserts and swaps |
\*---------------------------------------------------------*/
std::vector<keyboard_led> change;
const char* change_keys = "change_keys";
const char* ins_key = "ins_key";
const char* ins_row = "ins_row";
const char* rmv_key = "rmv_key";
const char* rmv_row = "rmv_row";
const char* swp_key = "swp_key";
const char* dbg_zone = "Zone";
const char* dbg_row = "Row";
const char* dbg_col = "Col";
const char* dbg_val = "Val";
const char* dbg_name = "Name";
const char* dbg_opcode = "Opcode";
if(json_kbd.contains(change_keys))
{
for(size_t i = 0; i < json_kbd[change_keys].size(); i++)
{
keyboard_led* key = new keyboard_led;
key->zone = json_kbd[change_keys][i][dbg_zone];
key->row = json_kbd[change_keys][i][dbg_row];
key->col = json_kbd[change_keys][i][dbg_col];
key->value = json_kbd[change_keys][i][dbg_val];
key->name = json_kbd[change_keys][i][dbg_name].get_ref<const std::string&>().c_str();
if(json_kbd[change_keys][i][dbg_opcode] == ins_row)
{
key->opcode = KEYBOARD_OPCODE_INSERT_ROW;
}
else if(json_kbd[change_keys][i][dbg_opcode] == rmv_key)
{
key->opcode = KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT;
}
else if(json_kbd[change_keys][i][dbg_opcode] == rmv_row)
{
key->opcode = KEYBOARD_OPCODE_REMOVE_ROW;
}
else if(json_kbd[change_keys][i][dbg_opcode] == swp_key)
{
key->opcode = KEYBOARD_OPCODE_SWAP_ONLY;
}
else
{
key->opcode = KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT;
}
change.push_back(*key);
}
}
new_kb.ChangeKeys(change);
dummy_keyboard->name = new_kb.GetName();
dummy_keyboard->type = DEVICE_TYPE_KEYBOARD;
dummy_keyboard->description = dummy_keyboard->name;
dummy_keyboard->description.append(" Debug Keyboard");
dummy_keyboard->location = "Debug Keyboard Location";
dummy_keyboard->version = "Debug Keyboard Version";
dummy_keyboard->serial = "Debug Keyboard Serial";
/*---------------------------------------------------------*\
| Create a direct mode for the dummy keyboard |
\*---------------------------------------------------------*/
mode dummy_keyboard_direct_mode;
dummy_keyboard_direct_mode.name = "Direct";
dummy_keyboard_direct_mode.value = 0;
dummy_keyboard_direct_mode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_keyboard_direct_mode.color_mode = MODE_COLORS_PER_LED;
dummy_keyboard->modes.push_back(dummy_keyboard_direct_mode);
/*---------------------------------------------------------*\
| Create a matrix zone for the debug Keyboard |
\*---------------------------------------------------------*/
zone dummy_keyboard_matrix_zone;
dummy_keyboard_matrix_zone.name = "Keyboard Matrix Zone";
dummy_keyboard_matrix_zone.type = ZONE_TYPE_MATRIX;
dummy_keyboard_matrix_zone.leds_min = new_kb.GetKeyCount();
dummy_keyboard_matrix_zone.leds_max = new_kb.GetKeyCount();
dummy_keyboard_matrix_zone.leds_count = new_kb.GetKeyCount();
dummy_keyboard_matrix_zone.matrix_map = new matrix_map_type;
dummy_keyboard_matrix_zone.matrix_map->height = new_kb.GetRowCount();
dummy_keyboard_matrix_zone.matrix_map->width = new_kb.GetColumnCount();
dummy_keyboard_matrix_zone.matrix_map->map = new unsigned int[dummy_keyboard_matrix_zone.matrix_map->height
* dummy_keyboard_matrix_zone.matrix_map->width];
new_kb.GetKeyMap(dummy_keyboard_matrix_zone.matrix_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_matrix_zone.leds_count; led_idx++)
{
led dummy_keyboard_led;
dummy_keyboard_led.name = new_kb.GetKeyNameAt(led_idx);
dummy_keyboard->leds.push_back(dummy_keyboard_led);
}
/*-----------------------------------------------------------------*\
| Add another matrix zone so that is can resemble a huntsman elite |
\*-----------------------------------------------------------------*/
bool underglow = true;
if(json_kbd.contains("underglow"))
{
underglow = json_kbd["underglow"];
}
if(underglow)
{
zone dummy_keyboard_underglow_matrix_zone;
dummy_keyboard_underglow_matrix_zone.name = "Underglow";
dummy_keyboard_underglow_matrix_zone.type = ZONE_TYPE_MATRIX;
dummy_keyboard_underglow_matrix_zone.leds_min = 30;
dummy_keyboard_underglow_matrix_zone.leds_max = 30;
dummy_keyboard_underglow_matrix_zone.leds_count = 30;
dummy_keyboard_underglow_matrix_zone.matrix_map = new matrix_map_type;
dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
dummy_keyboard_underglow_matrix_zone.matrix_map->width = 10;
dummy_keyboard_underglow_matrix_zone.matrix_map->map = (unsigned int*)&dummy_keyboard_underglow_map;
dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_underglow_matrix_zone.leds_count; led_idx++)
{
led dummy_keyboard_led;
dummy_keyboard_led.name = dummy_keyboard_underglow_matrix_zone.name + " LED ";
dummy_keyboard_led.name.append(std::to_string(led_idx));
dummy_keyboard->leds.push_back(dummy_keyboard_led);
}
}
/*---------------------------------------------------------*\
| Create a linear zone for the dummy Keyboard |
\*---------------------------------------------------------*/
bool linear = true;
if(json_kbd.contains("linear"))
{
linear = json_kbd["linear"];
}
if(linear)
{
zone dummy_keyboard_linear_zone;
dummy_keyboard_linear_zone.name = "Linear Zone";
dummy_keyboard_linear_zone.type = ZONE_TYPE_LINEAR;
dummy_keyboard_linear_zone.leds_min = 18;
dummy_keyboard_linear_zone.leds_max = 18;
dummy_keyboard_linear_zone.leds_count = 18;
dummy_keyboard_linear_zone.matrix_map = NULL;
dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_linear_zone.leds_count; led_idx++)
{
led dummy_keyboard_led;
dummy_keyboard_led.name = "RGB Strip ";
dummy_keyboard_led.name.append(std::to_string(led_idx));
dummy_keyboard->leds.push_back(dummy_keyboard_led);
}
}
dummy_keyboard->SetupColors();
/*---------------------------------------------------------*\
| Push the dummy Keyboard onto the controller list |
\*---------------------------------------------------------*/
ResourceManager::get()->RegisterRGBController(dummy_keyboard);
}
else if(type == "argb")
{
/*---------------------------------------------------------*\
| Create a dummy ARGB |
\*---------------------------------------------------------*/
RGBController_Debug* dummy_argb = new RGBController_Debug();
dummy_argb->name = "Debug ARGB";
dummy_argb->type = DEVICE_TYPE_LEDSTRIP;
dummy_argb->description = "Debug ARGB Device";
dummy_argb->location = "Debug ARGB Location";
dummy_argb->version = "Debug ARGB Version";
dummy_argb->serial = "Debug ARGB Serial";
/*---------------------------------------------------------*\
| Create a direct mode for the dummy ARGB |
\*---------------------------------------------------------*/
mode dummy_argb_direct_mode;
dummy_argb_direct_mode.name = "Direct";
dummy_argb_direct_mode.value = 0;
dummy_argb_direct_mode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_argb_direct_mode.color_mode = MODE_COLORS_PER_LED;
dummy_argb->modes.push_back(dummy_argb_direct_mode);
/*---------------------------------------------------------*\
| Create a linear zone for the dummy ARGB |
\*---------------------------------------------------------*/
zone dummy_argb_linear_zone;
dummy_argb_linear_zone.name = "Resizable zone";
dummy_argb_linear_zone.type = ZONE_TYPE_LINEAR;
dummy_argb_linear_zone.leds_min = 1;
dummy_argb_linear_zone.leds_max = 100;
dummy_argb_linear_zone.leds_count = 0;
dummy_argb_linear_zone.matrix_map = NULL;
dummy_argb->zones.push_back(dummy_argb_linear_zone);
dummy_argb->SetupColors();
dummy_argb->ResizeZone(0, 60);
/*---------------------------------------------------------*\
| Push the dummy ARGB onto the controller list |
\*---------------------------------------------------------*/
ResourceManager::get()->RegisterRGBController(dummy_argb);
}
}
}
if (debug_settings.contains("CustomDevices"))
{
for (int CustomDevice = 0; CustomDevice < (int)debug_settings["CustomDevices"].size(); CustomDevice++)
{
json CustomDev = debug_settings["CustomDevices"][CustomDevice];
/*---------------------------*\
| Create a custom controller |
\*---------------------------*/
RGBController_Debug* dummy_custom = new RGBController_Debug();
/*----------------------------------------------------------------------*\
| if ANY of the attributes are missing then go ahead and skip the entry |
\*----------------------------------------------------------------------*/
if (
!CustomDev.contains("DeviceName") ||
!CustomDev.contains("DeviceType") ||
!CustomDev.contains("DeviceDescription") ||
!CustomDev.contains("DeviceLocation") ||
!CustomDev.contains("DeviceVersion") ||
!CustomDev.contains("DeviceSerial") ||
!CustomDev.contains("DeviceZones")
)
{
continue;
}
/*-------------*\
| Set the name |
\*-------------*/
dummy_custom->name = CustomDev["DeviceName"];
/*---------------------*\
| Find the device type |
\*---------------------*/
if (CustomDev["DeviceType"] == "motherboard") dummy_custom->type = DEVICE_TYPE_MOTHERBOARD;
else if (CustomDev["DeviceType"] == "dram") dummy_custom->type = DEVICE_TYPE_DRAM;
else if (CustomDev["DeviceType"] == "gpu") dummy_custom->type = DEVICE_TYPE_GPU;
else if (CustomDev["DeviceType"] == "cooler") dummy_custom->type = DEVICE_TYPE_COOLER;
else if (CustomDev["DeviceType"] == "led_strip") dummy_custom->type = DEVICE_TYPE_LEDSTRIP;
else if (CustomDev["DeviceType"] == "keyboard") dummy_custom->type = DEVICE_TYPE_KEYBOARD;
else if (CustomDev["DeviceType"] == "mouse") dummy_custom->type = DEVICE_TYPE_MOUSE;
else if (CustomDev["DeviceType"] == "mousemat") dummy_custom->type = DEVICE_TYPE_MOUSEMAT;
else if (CustomDev["DeviceType"] == "headset") dummy_custom->type = DEVICE_TYPE_HEADSET;
else if (CustomDev["DeviceType"] == "headset_stand") dummy_custom->type = DEVICE_TYPE_HEADSET_STAND;
else if (CustomDev["DeviceType"] == "gamepad") dummy_custom->type = DEVICE_TYPE_GAMEPAD;
else if (CustomDev["DeviceType"] == "light") dummy_custom->type = DEVICE_TYPE_LIGHT;
else if (CustomDev["DeviceType"] == "speaker") dummy_custom->type = DEVICE_TYPE_SPEAKER;
else if (CustomDev["DeviceType"] == "unknown") dummy_custom->type = DEVICE_TYPE_UNKNOWN;
/*-----------------------------------------------*\
| Set description, location, version, and serial |
\*-----------------------------------------------*/
dummy_custom->description = CustomDev["DeviceDescription"];
dummy_custom->location = CustomDev["DeviceLocation"];
dummy_custom->version = CustomDev["DeviceVersion"];
dummy_custom->serial = CustomDev["DeviceSerial"];
/*----------------*\
| Create the mode |
\*----------------*/
mode dummy_custom_direct;
dummy_custom_direct.name = "Direct";
dummy_custom_direct.value = 0;
dummy_custom_direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
dummy_custom_direct.color_mode = MODE_COLORS_PER_LED;
dummy_custom->modes.push_back(dummy_custom_direct);
/*--------------*\
| Fill in zones |
\*--------------*/
for (int ZoneID = 0; ZoneID < (int)CustomDev["DeviceZones"].size(); ZoneID++)
{
json ZoneJson = CustomDev["DeviceZones"][ZoneID];
if
(
!ZoneJson.contains("name") ||
!ZoneJson.contains("type") ||
!ZoneJson.contains("leds_min") ||
!ZoneJson.contains("leds_max") ||
!ZoneJson.contains("leds_count")
)
{
continue;
}
zone custom_zone;
custom_zone.name = ZoneJson["name"];
if (ZoneJson["type"] == "linear") custom_zone.type = ZONE_TYPE_LINEAR;
else if (ZoneJson["type"] == "matrix") custom_zone.type = ZONE_TYPE_MATRIX;
else if (ZoneJson["type"] == "single") custom_zone.type = ZONE_TYPE_SINGLE;
else
{
continue;
}
custom_zone.leds_min = ZoneJson["leds_min"];
custom_zone.leds_max = ZoneJson["leds_max"];
custom_zone.leds_count = ZoneJson["leds_count"];
/*-----------------------*\
| Fill in the matrix map |
\*-----------------------*/
bool BadVal = false;
if (custom_zone.type == ZONE_TYPE_MATRIX)
{
if
(
!ZoneJson.contains("matrix_height") ||
!ZoneJson.contains("matrix_width") ||
!ZoneJson.contains("matrix_map")
)
{
/*--------------------------------------------------------------*\
| If there is no map then the zone can't be valid. Don't add it |
\*--------------------------------------------------------------*/
continue;
}
custom_zone.matrix_map = new matrix_map_type;
custom_zone.matrix_map->width = ZoneJson["matrix_width"];
custom_zone.matrix_map->height = ZoneJson["matrix_height"];
int H = custom_zone.matrix_map->height;
int W = custom_zone.matrix_map->width;
BadVal = (ZoneJson["matrix_map"].size() != custom_zone.matrix_map->height);
unsigned int* MatrixARR = new unsigned int[H * W];
for (int MatrixMapRow = 0; MatrixMapRow < H; MatrixMapRow++)
{
/*-----------------------------------------------------------------------------------------------------*\
| If something went wrong then make no attempt to recover and just move on in a way that doesn't crash |
| Even 1 bad row can corrupt the map so skip the zone entirely |
\*-----------------------------------------------------------------------------------------------------*/
if ((custom_zone.matrix_map->width != ZoneJson["matrix_map"][MatrixMapRow].size()) || BadVal)
{
BadVal = true;
break;
}
for (int MatrixMapCol = 0; MatrixMapCol < W; MatrixMapCol++)
{
int Val = ZoneJson["matrix_map"][MatrixMapRow][MatrixMapCol];
if ((signed)Val == -1)
{
MatrixARR[MatrixMapRow * W + MatrixMapCol] = NA;
}
else
{
MatrixARR[MatrixMapRow * W + MatrixMapCol] = (unsigned)Val;
}
}
}
custom_zone.matrix_map->map = MatrixARR;
}
/*------------------------------------*\
| Don't add the zone if it is invalid |
\*------------------------------------*/
if (BadVal)
{
continue;
}
bool UseCustomLabels = false;
if (ZoneJson.contains("custom_labels"))
{
/*-------------------------------------------------------*\
| If the count is correct and the zone is non-resizeable |
\*-------------------------------------------------------*/
if ((ZoneJson["custom_labels"].size() == custom_zone.leds_count) && (custom_zone.leds_min == custom_zone.leds_max))
{
UseCustomLabels = true;
}
}
/*------------------*\
| Set the LED names |
\*------------------*/
for (int LED_ID = 0; LED_ID < (int)custom_zone.leds_count; LED_ID++)
{
led custom_led;
if (UseCustomLabels)
{
/*----------------------------------------*\
| Set the label to the user defined label |
\*----------------------------------------*/
custom_led.name = ZoneJson["custom_labels"][LED_ID];
}
else
{
/*------------------------------------------------*\
| Set default labels because something went wrong |
\*------------------------------------------------*/
custom_led.name = ("Custom LED. Zone " + std::to_string(ZoneID) + ", LED " + std::to_string(LED_ID));
}
dummy_custom->leds.push_back(custom_led);
}
dummy_custom->zones.push_back(custom_zone);
}
dummy_custom->SetupColors();
ResourceManager::get()->RegisterRGBController(dummy_custom);
}
}
} /* DetectDebugControllers() */
REGISTER_DETECTOR("Debug Controllers", DetectDebugControllers);
Reference in New Issue View Git Blame Copy Permalink