Fix warnings

CalcProgrammer1 · CalcProgrammer1 · commit be90537d1059 · 2022-11-27T02:52:39.000-06:00
diff --git a/Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp b/Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp
@@ -262,12 +262,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
 {
     DeviceUpdateLEDs();
 }
 
-void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
+void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
 {
     DeviceUpdateLEDs();
 }
diff --git a/Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp b/Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp
@@ -77,7 +77,7 @@ std::string AuraTUFKeyboardController::GetVersion()
         {
             snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
         }
-        
+
         return std::string(version);
     }
     else
@@ -111,7 +111,7 @@ std::string AuraTUFKeyboardController::GetVersion()
 
         char version[9];
         snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
-        
+
         return std::string(version);
     }
 }
@@ -137,12 +137,12 @@ int AuraTUFKeyboardController::GetLayout()
     }
     else
     {
-        char layout[] = "";
-    
+        char layout[4];
+
         sprintf(layout, "%X", version);
 
         int layoutnum = std::stoi(std::string(layout, 1));
-        
+
         switch(layoutnum)
         {
             case 1:
@@ -276,14 +276,14 @@ void AuraTUFKeyboardController::UpdateLeds
         usb_buf[3] = leds;
         usb_buf[4] = 0x00;
 
-        for(unsigned int j = 0; j < leds; j++)
+        for(int j = 0; j < leds; j++)
         {
             usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
             usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
             usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
             usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
         }
-        
+
         ClearResponses();
 
         hid_write(dev, usb_buf, 65);
@@ -352,7 +352,7 @@ void AuraTUFKeyboardController::UpdateDevice
                     usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
                 }
             }
-                
+
         }
     }
     else
diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp b/Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp
@@ -28,7 +28,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
     pid = controller->device_pid;
 
-    if(pid != AURA_ROG_CLAYMORE_PID) 
+    if(pid != AURA_ROG_CLAYMORE_PID)
     {
         name        = "ASUS Aura Keyboard";
         vendor      = "ASUS";
@@ -398,7 +398,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()
     keyboard_zone.matrix_map->map    = keyboard[layout].matrix_map;
     zones.push_back(keyboard_zone);
 
-    for(unsigned int led_id = 0; led_id < keyboard[layout].size; led_id++)
+    for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
     {
         led new_led;
         new_led.name  = keyboard[layout].led_names[led_id].name;
@@ -423,7 +423,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
 {
     std::vector<led_color> led_color_list = {};
 
-    for(int i = 0; i < colors.size(); i++)
+    for(unsigned int i = 0; i < colors.size(); i++)
     {
         led_color_list.push_back({ leds[i].value, colors[i] });
     }
@@ -448,13 +448,13 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
 
 static const uint8_t direction_map[2][6] =
 {
-    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical   
+    { 4,  0,  6,  2,  8,  1 },          // Default directions Left, Right, Up, Down, Horizontal, Vertical
     { 0,  4,  6,  2,  0xFF,  0xFF },    // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
 };
 
 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 {
-    if(pid == AURA_ROG_CLAYMORE_PID) 
+    if(pid == AURA_ROG_CLAYMORE_PID)
     {
         controller->AllowRemoteControl(1);
     }
@@ -468,7 +468,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
         if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
         return;
     };
-    
+
     if(pid != AURA_ROG_CLAYMORE_PID)
     {
         brightness = modes[active_mode].brightness * 25;
@@ -521,7 +521,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
 
     controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
 
-    if(pid == AURA_ROG_CLAYMORE_PID) 
+    if(pid == AURA_ROG_CLAYMORE_PID)
     {
         controller->UpdateMode(modes[active_mode].value);
         controller->SaveMode();
@@ -534,7 +534,7 @@ void RGBController_AuraTUFKeyboard::DeviceSaveMode()
     /*----------------------------------------------------------*\
     | not available for Claymore                                 |
     \*----------------------------------------------------------*/
-    if(pid != AURA_ROG_CLAYMORE_PID) 
+    if(pid != AURA_ROG_CLAYMORE_PID)
     {
         DeviceUpdateMode();
         controller->SaveMode();
diff --git a/Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp b/Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController.cpp
@@ -54,7 +54,7 @@ std::string AsusCerberusKeyboardController::GetSerialString()
 
 std::string AsusCerberusKeyboardController::GetVersion()
 {
-    char versionstr[] = "";
+    char versionstr[5];
     snprintf(versionstr, 3, "%X", version);
     return(std::string(versionstr, 3));
 }
diff --git a/Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp b/Controllers/AsusLegacyUSBController/RGBController_AsusCerberusKeyboard.cpp
@@ -301,7 +301,7 @@ void RGBController_AsusCerberusKeyboard::SetupZones()
     keyboard.matrix_map->map    = *matrix_map;
     zones.push_back(keyboard);
 
-    for(unsigned int led_id = 0; led_id < zone_size; led_id++)
+    for(int led_id = 0; led_id < zone_size; led_id++)
     {
         led new_led;
         new_led.name  = led_names[led_id].name;
@@ -320,7 +320,7 @@ void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size
 
 void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
 {
-    for(int i = 0; i < colors.size(); i++)
+    for(unsigned int i = 0; i < colors.size(); i++)
     {
         uint8_t red   = RGBGetRValue(colors[i]);
         uint8_t green = RGBGetGValue(colors[i]);
diff --git a/Controllers/IntelArcA770LEController/RGBController_IntelArcA770LE.cpp b/Controllers/IntelArcA770LEController/RGBController_IntelArcA770LE.cpp
@@ -188,12 +188,12 @@ void RGBController_IntelArcA770LE::DeviceUpdateLEDs()
     }
 }
 
-void RGBController_IntelArcA770LE::UpdateZoneLEDs(int zone)
+void RGBController_IntelArcA770LE::UpdateZoneLEDs(int /*zone*/)
 {
 
 }
 
-void RGBController_IntelArcA770LE::UpdateSingleLED(int led)
+void RGBController_IntelArcA770LE::UpdateSingleLED(int /*led*/)
 {
 }
 
diff --git a/Controllers/LenovoControllers/RGBController_LenovoUSB.cpp b/Controllers/LenovoControllers/RGBController_LenovoUSB.cpp
@@ -69,13 +69,14 @@ RGBController_LenovoUSB::RGBController_LenovoUSB(LenovoUSBController* controller
     }
 
     std::vector<uint8_t> response;
+
+    /*-----------------------*\
+    |Default to ANSI keyboard |
+    \*-----------------------*/
+    keyboard_type = ANSI;
+
     switch(controller->getPid())
     {
-        /*-----------------------*\
-        |Default to ANSI keyboard |
-        \*-----------------------*/
-        keyboard_type = ANSI;
-
         case LEGION_Y740:
             response = controller->getInformation(0x01);
             if(response.size() > 4 && response[4] <= 100)
diff --git a/Controllers/RoccatController/RGBController_RoccatVulcanAimo.cpp b/Controllers/RoccatController/RGBController_RoccatVulcanAimo.cpp
@@ -100,7 +100,7 @@ void RGBController_RoccatVulcanAimo::SetupZones()
     keyboard_zone.matrix_map->map    = RoccatVulcanLayouts[layout].matrix_map;
     zones.push_back(keyboard_zone);
 
-    for(unsigned int led_id = 0; led_id < RoccatVulcanLayouts[layout].size; led_id++)
+    for(int led_id = 0; led_id < RoccatVulcanLayouts[layout].size; led_id++)
     {
         led new_led;
         new_led.name  = RoccatVulcanLayouts[layout].led_names[led_id].name;
@@ -129,7 +129,7 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateLEDs()
     {
         std::vector<led_color> led_color_list = {};
 
-        for(int i = 0; i < colors.size(); i++)
+        for(unsigned int i = 0; i < colors.size(); i++)
         {
             led_color_list.push_back({ leds[i].value, colors[i] });
         }
@@ -158,7 +158,7 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateMode()
 
     if(modes[active_mode].value == ROCCAT_VULCAN_MODE_STATIC)
     {
-        for(int i = 0; i < colors.size(); i++)
+        for(unsigned int i = 0; i < colors.size(); i++)
         {
             led_color_list.push_back({ leds[i].value, colors[i] });
         }
diff --git a/Controllers/RoccatController/RoccatVulcanAimoController.cpp b/Controllers/RoccatController/RoccatVulcanAimoController.cpp
@@ -81,7 +81,7 @@ void RoccatVulcanAimoController::SendColors(std::vector<led_color> colors)
     bufs[0][3] = 0x01;
     bufs[0][4] = 0xB4;
 
-    for(int i = 0; i < colors.size(); i++)
+    for(unsigned int i = 0; i < colors.size(); i++)
     {
         int coloumn = floor(colors[i].value / 12);
         int row = colors[i].value % 12;
@@ -127,7 +127,7 @@ void RoccatVulcanAimoController::SendMode(unsigned int mode, unsigned int speed,
     if(mode == ROCCAT_VULCAN_MODE_STATIC)
     {
 
-        for(int i = 0; i < colors.size(); i++)
+        for(unsigned int i = 0; i < colors.size(); i++)
         {
             int coloumn = floor(colors[i].value / 12);
             int row = colors[i].value % 12;
diff --git a/Controllers/SinowealthController/SinowealthControllerDetect.cpp b/Controllers/SinowealthController/SinowealthControllerDetect.cpp
@@ -395,15 +395,14 @@ void DetectSinowealthGenesisKeyboard(hid_device_info* info, const std::string& n
     hid_device* dev = hid_open_path(info->path);
     if(dev)
     {
-        RGBController *rgb_controller;
-
         if(pid == GENESIS_THOR_300_PID)
         {
-            SinowealthKeyboard90Controller* controller = new SinowealthKeyboard90Controller(dev, info->path, pid);
-            rgb_controller                             = new RGBController_SinowealthKeyboard90(controller);
+            SinowealthKeyboard90Controller* controller         = new SinowealthKeyboard90Controller(dev, info->path, pid);
+            RGBController_SinowealthKeyboard90* rgb_controller = new RGBController_SinowealthKeyboard90(controller);
+            rgb_controller->name                               = name;
+
+            ResourceManager::get()->RegisterRGBController(rgb_controller);
         }
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
     }
 }
 
diff --git a/Controllers/SteelSeriesController/SteelSeriesApex8ZoneController.cpp b/Controllers/SteelSeriesController/SteelSeriesApex8ZoneController.cpp
@@ -77,7 +77,7 @@ void SteelSeriesApex8ZoneController::SetColor(std::vector<RGBColor> colors, uint
 
     buffer[1]              += mode;
 
-    for(int i = 0; i < colors.size(); i++)
+    for(unsigned int i = 0; i < colors.size(); i++)
     {
         uint8_t index       = i * 3;
 
diff --git a/cli.cpp b/cli.cpp
@@ -573,7 +573,7 @@ bool OptionDevice(std::vector<DeviceOptions>* current_devices, std::string argum
     {
         if(argument.length() > 1)
         {
-            for(int i = 0; i < rgb_controllers.size(); i++)
+            for(unsigned int i = 0; i < rgb_controllers.size(); i++)
             {
                 /*---------------------------------------------------------*\
                 | If the argument is not a number then check all the        |
@@ -640,7 +640,7 @@ bool OptionZone(std::vector<DeviceOptions>* current_devices, std::string argumen
     return found;
 }
 
-bool OptionColor(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
+bool OptionColor(std::vector<DeviceOptions>* current_devices, std::string argument, Options* /*options*/)
 {
     bool found = false;
 
@@ -663,7 +663,7 @@ bool OptionColor(std::vector<DeviceOptions>* current_devices, std::string argume
     return found;
 }
 
-bool OptionMode(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
+bool OptionMode(std::vector<DeviceOptions>* current_devices, std::string argument, Options* /*options*/)
 {
     if(argument.size() == 0)
     {
@@ -685,7 +685,7 @@ bool OptionMode(std::vector<DeviceOptions>* current_devices, std::string argumen
     return found;
 }
 
-bool OptionBrightness(std::vector<DeviceOptions>* current_devices, std::string argument, Options* options)
+bool OptionBrightness(std::vector<DeviceOptions>* current_devices, std::string argument, Options* /*options*/)
 {
     if(argument.size() == 0)
     {

Original file line number	Diff line number	Diff line change
`@@ -262,12 +262,12 @@ void RGBController_AMDWraithPrism::DeviceUpdateLEDs()`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`-void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)`
	`265`	`+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /zone/)`
`266`	`266`	`{`
`267`	`267`	`DeviceUpdateLEDs();`
`268`	`268`	`}`
`269`	`269`
`270`		`-void RGBController_AMDWraithPrism::UpdateSingleLED(int led)`
	`270`	`+void RGBController_AMDWraithPrism::UpdateSingleLED(int /led/)`
`271`	`271`	`{`
`272`	`272`	`DeviceUpdateLEDs();`
`273`	`273`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ std::string AuraTUFKeyboardController::GetVersion()`
`77`	`77`	`{`
`78`	`78`	`snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);`
`79`	`79`	`}`
`80`		`-`
	`80`	`+`
`81`	`81`	`return std::string(version);`
`82`	`82`	`}`
`83`	`83`	`else`
`@@ -111,7 +111,7 @@ std::string AuraTUFKeyboardController::GetVersion()`
`111`	`111`
`112`	`112`	`char version[9];`
`113`	`113`	`snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);`
`114`		`-`
	`114`	`+`
`115`	`115`	`return std::string(version);`
`116`	`116`	`}`
`117`	`117`	`}`
`@@ -137,12 +137,12 @@ int AuraTUFKeyboardController::GetLayout()`
`137`	`137`	`}`
`138`	`138`	`else`
`139`	`139`	`{`
`140`		`- char layout[] = "";`
`141`		`-`
	`140`	`+ char layout[4];`
	`141`	`+`
`142`	`142`	`sprintf(layout, "%X", version);`
`143`	`143`
`144`	`144`	`int layoutnum = std::stoi(std::string(layout, 1));`
`145`		`-`
	`145`	`+`
`146`	`146`	`switch(layoutnum)`
`147`	`147`	`{`
`148`	`148`	`case 1:`
`@@ -276,14 +276,14 @@ void AuraTUFKeyboardController::UpdateLeds`
`276`	`276`	`usb_buf[3] = leds;`
`277`	`277`	`usb_buf[4] = 0x00;`
`278`	`278`
`279`		`- for(unsigned int j = 0; j < leds; j++)`
	`279`	`+ for(int j = 0; j < leds; j++)`
`280`	`280`	`{`
`281`	`281`	`usb_buf[j * 4 + 5] = colors[i * 15 + j].value;`
`282`	`282`	`usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);`
`283`	`283`	`usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);`
`284`	`284`	`usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);`
`285`	`285`	`}`
`286`		`-`
	`286`	`+`
`287`	`287`	`ClearResponses();`
`288`	`288`
`289`	`289`	`hid_write(dev, usb_buf, 65);`
`@@ -352,7 +352,7 @@ void AuraTUFKeyboardController::UpdateDevice`
`352`	`352`	`usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);`
`353`	`353`	`}`
`354`	`354`	`}`
`355`		`-`
	`355`	`+`
`356`	`356`	`}`
`357`	`357`	`}`
`358`	`358`	`else`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont`
`28`	`28`
`29`	`29`	`pid = controller->device_pid;`
`30`	`30`
`31`		`- if(pid != AURA_ROG_CLAYMORE_PID)`
	`31`	`+ if(pid != AURA_ROG_CLAYMORE_PID)`
`32`	`32`	`{`
`33`	`33`	`name = "ASUS Aura Keyboard";`
`34`	`34`	`vendor = "ASUS";`
`@@ -398,7 +398,7 @@ void RGBController_AuraTUFKeyboard::SetupZones()`
`398`	`398`	`keyboard_zone.matrix_map->map = keyboard[layout].matrix_map;`
`399`	`399`	`zones.push_back(keyboard_zone);`
`400`	`400`
`401`		`- for(unsigned int led_id = 0; led_id < keyboard[layout].size; led_id++)`
	`401`	`+ for(int led_id = 0; led_id < keyboard[layout].size; led_id++)`
`402`	`402`	`{`
`403`	`403`	`led new_led;`
`404`	`404`	`new_led.name = keyboard[layout].led_names[led_id].name;`
`@@ -423,7 +423,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()`
`423`	`423`	`{`
`424`	`424`	`std::vector<led_color> led_color_list = {};`
`425`	`425`
`426`		`- for(int i = 0; i < colors.size(); i++)`
	`426`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`427`	`427`	`{`
`428`	`428`	`led_color_list.push_back({ leds[i].value, colors[i] });`
`429`	`429`	`}`
`@@ -448,13 +448,13 @@ void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)`
`448`	`448`
`449`	`449`	`static const uint8_t direction_map[2][6] =`
`450`	`450`	`{`
`451`		`- { 4, 0, 6, 2, 8, 1 }, // Default directions Left, Right, Up, Down, Horizontal, Vertical`
	`451`	`+ { 4, 0, 6, 2, 8, 1 }, // Default directions Left, Right, Up, Down, Horizontal, Vertical`
`452`	`452`	`{ 0, 4, 6, 2, 0xFF, 0xFF }, // AURA_ROG_CLAYMORE directions Left, Right, Up, Down`
`453`	`453`	`};`
`454`	`454`
`455`	`455`	`void RGBController_AuraTUFKeyboard::DeviceUpdateMode()`
`456`	`456`	`{`
`457`		`- if(pid == AURA_ROG_CLAYMORE_PID)`
	`457`	`+ if(pid == AURA_ROG_CLAYMORE_PID)`
`458`	`458`	`{`
`459`	`459`	`controller->AllowRemoteControl(1);`
`460`	`460`	`}`
`@@ -468,7 +468,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()`
`468`	`468`	`if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);`
`469`	`469`	`return;`
`470`	`470`	`};`
`471`		`-`
	`471`	`+`
`472`	`472`	`if(pid != AURA_ROG_CLAYMORE_PID)`
`473`	`473`	`{`
`474`	`474`	`brightness = modes[active_mode].brightness * 25;`
`@@ -521,7 +521,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()`
`521`	`521`
`522`	`522`	`controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);`
`523`	`523`
`524`		`- if(pid == AURA_ROG_CLAYMORE_PID)`
	`524`	`+ if(pid == AURA_ROG_CLAYMORE_PID)`
`525`	`525`	`{`
`526`	`526`	`controller->UpdateMode(modes[active_mode].value);`
`527`	`527`	`controller->SaveMode();`
`@@ -534,7 +534,7 @@ void RGBController_AuraTUFKeyboard::DeviceSaveMode()`
`534`	`534`	`/----------------------------------------------------------\`
`535`	`535`	`\| not available for Claymore \|`
`536`	`536`	`\----------------------------------------------------------/`
`537`		`- if(pid != AURA_ROG_CLAYMORE_PID)`
	`537`	`+ if(pid != AURA_ROG_CLAYMORE_PID)`
`538`	`538`	`{`
`539`	`539`	`DeviceUpdateMode();`
`540`	`540`	`controller->SaveMode();`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ std::string AsusCerberusKeyboardController::GetSerialString()`
`54`	`54`
`55`	`55`	`std::string AsusCerberusKeyboardController::GetVersion()`
`56`	`56`	`{`
`57`		`- char versionstr[] = "";`
	`57`	`+ char versionstr[5];`
`58`	`58`	`snprintf(versionstr, 3, "%X", version);`
`59`	`59`	`return(std::string(versionstr, 3));`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ void RGBController_AsusCerberusKeyboard::SetupZones()`
`301`	`301`	`keyboard.matrix_map->map = *matrix_map;`
`302`	`302`	`zones.push_back(keyboard);`
`303`	`303`
`304`		`- for(unsigned int led_id = 0; led_id < zone_size; led_id++)`
	`304`	`+ for(int led_id = 0; led_id < zone_size; led_id++)`
`305`	`305`	`{`
`306`	`306`	`led new_led;`
`307`	`307`	`new_led.name = led_names[led_id].name;`
`@@ -320,7 +320,7 @@ void RGBController_AsusCerberusKeyboard::ResizeZone(int /zone/, int /*new_size`
`320`	`320`
`321`	`321`	`void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()`
`322`	`322`	`{`
`323`		`- for(int i = 0; i < colors.size(); i++)`
	`323`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`324`	`324`	`{`
`325`	`325`	`uint8_t red = RGBGetRValue(colors[i]);`
`326`	`326`	`uint8_t green = RGBGetGValue(colors[i]);`
Original file line number	Diff line number	Diff line change
`@@ -188,12 +188,12 @@ void RGBController_IntelArcA770LE::DeviceUpdateLEDs()`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`191`		`-void RGBController_IntelArcA770LE::UpdateZoneLEDs(int zone)`
	`191`	`+void RGBController_IntelArcA770LE::UpdateZoneLEDs(int /zone/)`
`192`	`192`	`{`
`193`	`193`
`194`	`194`	`}`
`195`	`195`
`196`		`-void RGBController_IntelArcA770LE::UpdateSingleLED(int led)`
	`196`	`+void RGBController_IntelArcA770LE::UpdateSingleLED(int /led/)`
`197`	`197`	`{`
`198`	`198`	`}`
`199`	`199`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ void RGBController_RoccatVulcanAimo::SetupZones()`
`100`	`100`	`keyboard_zone.matrix_map->map = RoccatVulcanLayouts[layout].matrix_map;`
`101`	`101`	`zones.push_back(keyboard_zone);`
`102`	`102`
`103`		`- for(unsigned int led_id = 0; led_id < RoccatVulcanLayouts[layout].size; led_id++)`
	`103`	`+ for(int led_id = 0; led_id < RoccatVulcanLayouts[layout].size; led_id++)`
`104`	`104`	`{`
`105`	`105`	`led new_led;`
`106`	`106`	`new_led.name = RoccatVulcanLayouts[layout].led_names[led_id].name;`
`@@ -129,7 +129,7 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateLEDs()`
`129`	`129`	`{`
`130`	`130`	`std::vector<led_color> led_color_list = {};`
`131`	`131`
`132`		`- for(int i = 0; i < colors.size(); i++)`
	`132`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`133`	`133`	`{`
`134`	`134`	`led_color_list.push_back({ leds[i].value, colors[i] });`
`135`	`135`	`}`
`@@ -158,7 +158,7 @@ void RGBController_RoccatVulcanAimo::DeviceUpdateMode()`
`158`	`158`
`159`	`159`	`if(modes[active_mode].value == ROCCAT_VULCAN_MODE_STATIC)`
`160`	`160`	`{`
`161`		`- for(int i = 0; i < colors.size(); i++)`
	`161`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`162`	`162`	`{`
`163`	`163`	`led_color_list.push_back({ leds[i].value, colors[i] });`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ void RoccatVulcanAimoController::SendColors(std::vector<led_color> colors)`
`81`	`81`	`bufs[0][3] = 0x01;`
`82`	`82`	`bufs[0][4] = 0xB4;`
`83`	`83`
`84`		`- for(int i = 0; i < colors.size(); i++)`
	`84`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`85`	`85`	`{`
`86`	`86`	`int coloumn = floor(colors[i].value / 12);`
`87`	`87`	`int row = colors[i].value % 12;`
`@@ -127,7 +127,7 @@ void RoccatVulcanAimoController::SendMode(unsigned int mode, unsigned int speed,`
`127`	`127`	`if(mode == ROCCAT_VULCAN_MODE_STATIC)`
`128`	`128`	`{`
`129`	`129`
`130`		`- for(int i = 0; i < colors.size(); i++)`
	`130`	`+ for(unsigned int i = 0; i < colors.size(); i++)`
`131`	`131`	`{`
`132`	`132`	`int coloumn = floor(colors[i].value / 12);`
`133`	`133`	`int row = colors[i].value % 12;`
Original file line number	Diff line number	Diff line change
`@@ -395,15 +395,14 @@ void DetectSinowealthGenesisKeyboard(hid_device_info* info, const std::string& n`
`395`	`395`	`hid_device* dev = hid_open_path(info->path);`
`396`	`396`	`if(dev)`
`397`	`397`	`{`
`398`		`- RGBController *rgb_controller;`
`399`		`-`
`400`	`398`	`if(pid == GENESIS_THOR_300_PID)`
`401`	`399`	`{`
`402`		`- SinowealthKeyboard90Controller* controller = new SinowealthKeyboard90Controller(dev, info->path, pid);`
`403`		`- rgb_controller = new RGBController_SinowealthKeyboard90(controller);`
	`400`	`+ SinowealthKeyboard90Controller* controller = new SinowealthKeyboard90Controller(dev, info->path, pid);`
	`401`	`+ RGBController_SinowealthKeyboard90* rgb_controller = new RGBController_SinowealthKeyboard90(controller);`
	`402`	`+ rgb_controller->name = name;`
	`403`	`+`
	`404`	`+ ResourceManager::get()->RegisterRGBController(rgb_controller);`
`404`	`405`	`}`
`405`		`- rgb_controller->name = name;`
`406`		`- ResourceManager::get()->RegisterRGBController(rgb_controller);`
`407`	`406`	`}`
`408`	`407`	`}`
`409`	`408`