Automatic generation of markdown pages for supported devices

+ Added build-supported-devices.sh script + Added new target in CI/CD to build at compile time
4 years ago · 524675108d
parent a7adfe251b
commit 524675108d
163 changed files with 699 additions and 265 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -28,6 +28,31 @@ before_script:
    - export APPIMAGE_EXTRACT_AND_RUN=1

 #-----------------------------------------------------------------------#
+# Supported Devices Build Target                                        #
+#-----------------------------------------------------------------------#
+"Supported Devices":
+  <<: *ccache_init
+  image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
+  stage: build
+  script:
+  - qmake
+  - make -j$(nproc)
+  - ./scripts/build-supported-devices-md.sh $CI_PROJECT_DIR $CI_COMMIT_SHORT_SHA
+
+  artifacts:
+    name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
+    paths:
+    - ./*.md
+    exclude:
+    - README.md
+    - CONTRIBUTING.md
+    expire_in: 30 days
+
+  rules:
+  - if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
+    when: on_success
+
+#-----------------------------------------------------------------------#
 # Linux (AppImage) 32-bit Build Target                                  #
 #-----------------------------------------------------------------------#
 "Linux 32 AppImage":
--- a/Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp
+++ b/Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name AMD Wraith Prism
+    @category Cooler
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp
+++ b/Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp
@ -34,6 +34,7 @@ static const char* polychrome_v2_zone_names[] =

 /**------------------------------------------------------------------*\
    @name ASRock Polychrome SMBus
+    @category Motherboard
    @type SMBus
    @save :warning:
    @direct :x:
@ -506,7 +507,7 @@ void RGBController_Polychrome::SetupZones()
                        {
                            new_zone->name          = polychrome_v2_zone_names[zone_idx];
                        }
-                        
+
                        if(zone_idx == POLYCHROME_ZONE_ADDRESSABLE)
                        {
                            new_zone->leds_min      = 1;
--- a/Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp
+++ b/Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp
@ -15,6 +15,7 @@

 /**------------------------------------------------------------------*\
    @name ASrock Polychrome USB
+    @category Motherboard
    @type USB
    @save :warning:
    @direct :x:
@ -203,15 +204,15 @@ void RGBController_PolychromeUSB::SetupZones()
            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
            zones[channel_idx].leds_min   = 0;
            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
-            zones[channel_idx].leds_count = device_info.num_leds; 
+            zones[channel_idx].leds_count = device_info.num_leds;
        }
-        else if(device_info.device_type==PolychromeDeviceType::FIXED) 
+        else if(device_info.device_type==PolychromeDeviceType::FIXED)
        {
            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
            zones[channel_idx].leds_min   = device_info.num_leds;
            zones[channel_idx].leds_max   = device_info.num_leds;
-            zones[channel_idx].leds_count = device_info.num_leds; 
-        }       
+            zones[channel_idx].leds_count = device_info.num_leds;
+        }


        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
@ -247,7 +248,7 @@ void RGBController_PolychromeUSB::SetupZones()
     for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
    {
        PolychromeZoneInfo zoneinfo;
-        zoneinfo = controller->GetZoneConfig(channel_idx); 
+        zoneinfo = controller->GetZoneConfig(channel_idx);
        zones_info.push_back(zoneinfo);
    }

@ -320,7 +321,7 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
    dev_mode    = controller->GetZoneConfig(zone).mode;
    active_mode = dev_mode;

-    return(active_mode);  
+    return(active_mode);
 }

 void RGBController_PolychromeUSB::SetCustomMode()
@ -337,10 +338,10 @@ void RGBController_PolychromeUSB::DeviceUpdateMode()
            unsigned char set_mode      =(unsigned char) modes[active_mode].value;
            zones_info[zone_idx].mode   =(unsigned char) modes[active_mode].value;
            zones_info[zone_idx].speed  =(unsigned char) modes[active_mode].speed;
-            
+
            if(set_mode > modes.size())
            {
-                set_mode = active_mode;                    
+                set_mode = active_mode;
            }

            controller->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
--- a/Controllers/AlienwareController/RGBController_Alienware.cpp
+++ b/Controllers/AlienwareController/RGBController_Alienware.cpp
@ -14,6 +14,7 @@

 /**------------------------------------------------------------------*\
    @name Alienware
+    @category Keyboard
    @type USB
    @save :x:
    @direct :x:
@ -147,7 +148,7 @@ void RGBController_Alienware::SetupZones()
    for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
    {
        led new_led;
-        
+
        new_led.name        = zones[led_idx].name + std::string(" LED");

        leds.emplace_back(new_led);
@ -228,7 +229,7 @@ void RGBController_Alienware::DeviceUpdateMode()
            uint16_t period = 0x07d0;

            controller->SetMode(zone_idx, current_mode.value);
-            
+
            switch(current_mode_idx)
            {
                case ALIENWARE_MODE_COLOR:
--- a/Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp
+++ b/Controllers/AlienwareKeyboardController/RGBController_AlienwareAW510K.cpp
@ -160,6 +160,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Alienware AW510 Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp
+++ b/Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp
@ -18,7 +18,7 @@ static unsigned int matrix_map[5][14] =
    { { 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, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, NA },
-      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA }, 
+      { 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, NA },
      { 53, NA, 54, 55, NA, NA, 56, NA, NA, 57, 58, 59, 60, NA } };

 static const char* zone_names[] =
@ -110,6 +110,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Anne Pro 2
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -118,7 +119,7 @@ static const led_type led_names[] =
    @comment
 \*-------------------------------------------------------------------*/

-RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr) 
+RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_ptr)
 {
    controller  = controller_ptr;

@ -139,12 +140,12 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
    SetupZones();
 }

-RGBController_AnnePro2::~RGBController_AnnePro2() 
+RGBController_AnnePro2::~RGBController_AnnePro2()
 {
    delete controller;
 }

-void RGBController_AnnePro2::SetupZones() 
+void RGBController_AnnePro2::SetupZones()
 {
    /*---------------------------------------------------------*\
    | Set up zones                                              |
@ -187,14 +188,14 @@ void RGBController_AnnePro2::SetupZones()
    SetupColors();
 }

-void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/) 
+void RGBController_AnnePro2::ResizeZone(int /*zone*/, int /*new_size*/)
 {
    /*---------------------------------------------------------*\
    | This device does not support resizing zones               |
    \*---------------------------------------------------------*/
 }

-void RGBController_AnnePro2::DeviceUpdateLEDs() 
+void RGBController_AnnePro2::DeviceUpdateLEDs()
 {
    const unsigned char frame_buf_length = LED_REAL_COUNT * 3;
    unsigned char frame_buf[frame_buf_length];
@ -225,22 +226,22 @@ void RGBController_AnnePro2::DeviceUpdateLEDs()
    controller->SendDirect(frame_buf_length, frame_buf);
 }

-void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/) 
+void RGBController_AnnePro2::UpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AnnePro2::UpdateSingleLED(int /*led*/) 
+void RGBController_AnnePro2::UpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_AnnePro2::SetCustomMode() 
+void RGBController_AnnePro2::SetCustomMode()
 {
    active_mode = 0;
 }

-void RGBController_AnnePro2::DeviceUpdateMode() 
+void RGBController_AnnePro2::DeviceUpdateMode()
 {
-    
+
 }
--- a/Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp
+++ b/Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Asus AURA Core
+    @category Keyboard,LEDStrip
    @type USB
    @save :x:
    @direct :warning:
@ -25,7 +26,7 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
    name        = "ASUS Aura Core Device";
    vendor      = "ASUS";
    location    = controller->GetDeviceLocation();
-    serial      = controller->GetSerialString();    
+    serial      = controller->GetSerialString();
    description = "ASUS Aura Core Device";
    type        = DEVICE_TYPE_UNKNOWN;

--- a/Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp
+++ b/Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp
@ -18,7 +18,7 @@ int RGBController_AuraGPU::GetDeviceMode()
        if (controller->direct)
        {
            dev_mode = AURA_GPU_MODE_DIRECT;
-        } 
+        }
    }

    switch(dev_mode)
@ -35,7 +35,7 @@ int RGBController_AuraGPU::GetDeviceMode()
        {
            active_mode            = mode;
            modes[mode].color_mode = color_mode;
-        }   
+        }
    }

    return(active_mode);
@ -43,10 +43,11 @@ int RGBController_AuraGPU::GetDeviceMode()

 /**------------------------------------------------------------------*\
    @name Asus Aura GPU
-    @type I2C
+    @category GPU
+    @type SMBus
    @save :x:
    @direct :white_check_mark:
-    @effects :white_check_mark::
+    @effects :white_check_mark:
    @detectors DetectAsusAuraGPUControllers
    @comment
 \*-------------------------------------------------------------------*/
@ -165,7 +166,7 @@ void RGBController_AuraGPU::DeviceUpdateLEDs()
        {
            controller->SetLEDColorsDirect(red, grn, blu);
        }
-        else 
+        else
        {
            controller->SetLEDColorsEffect(red, grn, blu);
        }
@ -191,7 +192,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
 {
    int new_mode       = modes[active_mode].value;
    controller->direct = false;
-    
+
    switch(new_mode)
    {
        // Set all LEDs to 0 and Mode to static as a workaround for the non existing Off Mode
@ -199,7 +200,7 @@ void RGBController_AuraGPU::DeviceUpdateMode()
            controller->SetLEDColorsEffect(0, 0, 0);
            new_mode           = AURA_GPU_MODE_STATIC;
            break;
-        
+
        // Direct mode is done by switching to Static and not applying color changes
        case AURA_GPU_MODE_DIRECT:
            controller->direct = true;
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Headset Stand
+    @category HeadsetStand
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp
@ -40,7 +40,7 @@ static unsigned int scope_tkl_matrix_map[6][18] =
 static unsigned int falchion_matrix_map[5][16] =
    { {   0,   5,   9,  14,  18,  22,  26,  31,  35,  39,  44,  49,  54,  58,  NA,  63 },
      {   1,  NA,   6,  10,  15,  19,  23,  27,  32,  36,  40,  45,  50,  55,  59,  64 },
-      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 }, 
+      {   2,  NA,   7,  11,  16,  20,  24,  28,  33,  37,  41,  46,  51,  60,  NA,  65 },
      {   3,  NA,  12,  17,  21,  25,  29,  34,  38,  42,  47,  52,  56,  NA,  61,  66 },
      {   4,   8,  13,  NA,  NA,  NA,  30,  NA,  NA,  NA,  43,  48,  53,  57,  62,  67 } };

@ -345,6 +345,7 @@ static const std::vector<led_type> default_65pct_led_names =

 /**------------------------------------------------------------------*\
    @name Asus Aura Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Monitor
+    @category LEDStrip
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp
@ -18,6 +18,7 @@ static std::string aura_mouse_zone_names[3]

 /**------------------------------------------------------------------*\
    @name Asus Aura Mouse
+    @category Mouse
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Mousemat
+    @category Mousemat
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
@ -259,7 +260,7 @@ void RGBController_AuraMousemat::DeviceUpdateMode()
            case AURA_MOUSEMAT_MODE_WAVE:
                pattern = modes[active_mode].colors.size() * 16 + modes[active_mode].direction;
                break;
-            case AURA_MOUSEMAT_MODE_WAVE_PLANE:       
+            case AURA_MOUSEMAT_MODE_WAVE_PLANE:
                switch(modes[active_mode].direction)
                {
                    case MODE_DIRECTION_LEFT:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura Strix Evolve
+    @category Mouse
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp
@ -13,6 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura TUF Keyboard
+    @category Keyboard
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
@ -276,7 +277,7 @@ void RGBController_AuraTUFKeyboard::SetCustomMode()
 }

 void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
-{   
+{
    unsigned char color_mode;
    std::vector<RGBColor> mode_colors;

--- a/Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
@ -11,12 +11,13 @@

 /**------------------------------------------------------------------*\
    @name Asus Aura USB
+    @category Motherboard
    @type USB
    @save :x:
    @direct :white_check_mark:
    @effects :white_check_mark:
    @detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
-    @comment The Asus AUra USB controller applies to most AMD and
+    @comment The Asus Aura USB controller applies to most AMD and
        Intel mainboards from the x470 and z390 chipsets onwards.
 \*-------------------------------------------------------------------*/

--- a/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp
+++ b/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp
@ -13,6 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Asus ROG Strix Liquid Cooler
+    @category Cooler
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp
+++ b/Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptopWMI.cpp
@ -12,6 +12,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name Asus TUF Laptop
+    @category Keyboard
    @type WMI
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp
+++ b/Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Blinky Tape
+    @category LEDStrip
    @type Serial
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CoolerMasterController/RGBController_CMARGBController.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMARGBController.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster ARGB
+    @category LEDStrip
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/CoolerMasterController/RGBController_CMMKController.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMMKController.cpp
@ -22,6 +22,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name Coolermaster Masterkeys Keyboards
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
@ -41,7 +42,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
    version                     = controller->GetFirmwareVersion();
    serial                      = "";
    location                    = controller->GetLocation();
-    
+
    mode Direct;
    Direct.name                 = "Direct";
    Direct.value                = CMMK_MODE_MANUAL;
@ -58,7 +59,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
    Static.colors_max           = 1;
    Static.colors.resize(1);
    modes.push_back(Static);
-    
+
    mode Breathing;
    Breathing.name              = "Breathing";
    Breathing.value             = CMMK_EFFECT_BREATHE;
@ -108,7 +109,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
    Wave.colors_max             = 1;
    Wave.colors.resize(1);
    modes.push_back(Wave);
-    
+
    mode Ripple;
    Ripple.name                 = "Ripple Effect";
    Ripple.value                = CMMK_EFFECT_RIPPLE;
@ -121,7 +122,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
    Ripple.colors_max           = 2;
    Ripple.colors.resize(2);
    modes.push_back(Ripple);
-    
+
    mode Cross;
    Cross.name                  = "Cross";
    Cross.value                 = CMMK_EFFECT_CROSS;
@ -147,7 +148,7 @@ RGBController_CMMKController::RGBController_CMMKController(CMMKController* contr
    Raindrops.colors_max        = 2;
    Raindrops.colors.resize(2);
    modes.push_back(Raindrops);
-    
+
    mode Stars;
    Stars.name                  = "Starfield";
    Stars.value                 = CMMK_EFFECT_STARS;
@ -224,7 +225,7 @@ void RGBController_CMMKController::SetupZones()
            std::stringstream namestrm;

            led key;
-            
+
            namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);

            key.name = namestrm.str();
@ -365,7 +366,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
        case CMMK_MODE_FIRMWARE:
            controller->SetFirmwareControl();
            break;
-        
+
        case CMMK_MODE_MANUAL:
            controller->SetManualControl();
            break;
@ -400,7 +401,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                controller->SetMode(cycle_effect);
            }
            break;
-        
+
        case CMMK_EFFECT_SINGLE:
            {
                cmmk_effect_single single_effect;
@ -412,7 +413,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                controller->SetMode(single_effect);
            }
            break;
-        
+
        case CMMK_EFFECT_WAVE:
            {
                cmmk_effect_wave wave_effect;
@ -424,7 +425,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                controller->SetMode(wave_effect);
            }
            break;
-        
+
        case CMMK_EFFECT_RIPPLE:
            {
                cmmk_effect_ripple ripple_effect;
@ -445,7 +446,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                controller->SetMode(ripple_effect);
            }
            break;
-        
+
        case CMMK_EFFECT_CROSS:
            {
                cmmk_effect_cross cross_effect;
@ -457,7 +458,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
                controller->SetMode(cross_effect);
            }
            break;
-        
+
        case CMMK_EFFECT_RAINDROPS:
            {
                cmmk_effect_raindrops raindrops_effect;
@ -474,12 +475,12 @@ void RGBController_CMMKController::DeviceUpdateMode()
        case CMMK_EFFECT_STARS:
            {
                cmmk_effect_stars stars_effect;
-                
+
                stars_effect.speed      = (uint8_t)modes[active_mode].speed;
                stars_effect.interval   = CMMK_SPEED_MID;
                stars_effect.active     = map_to_cmmk_rgb(modes[active_mode].colors[0]);
                stars_effect.rest       = map_to_cmmk_rgb(modes[active_mode].colors[1]);
-    
+
                controller->SetMode(stars_effect);
            }
            break;
@ -487,7 +488,7 @@ void RGBController_CMMKController::DeviceUpdateMode()
        case CMMK_EFFECT_SNAKE:
            {
                cmmk_effect_snake snake_effect;
-                
+
                snake_effect.speed = (uint8_t)modes[active_mode].speed;

                controller->SetMode(snake_effect);
--- a/Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp
@ -13,6 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster Master Mouse
+    @category Mouse
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/CoolerMasterController/RGBController_CMMMController.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMMMController.cpp
@ -14,6 +14,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster Master Mouse
+    @category Mouse
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster Mouse Pad
+    @category Mousemat
    @type USB
    @save :warning:
    @direct :x:
--- a/Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name AMD Radeon 6000
+    @category GPU
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -77,7 +78,7 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
    Breathing.colors_max = 1;
    Breathing.colors.resize(1);
    Breathing.speed      = speed;
-    modes.push_back(Breathing);    
+    modes.push_back(Breathing);

    SetupZones();
    active_mode = 1;
--- a/Controllers/CoolerMasterController/RGBController_CMRGBController.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMRGBController.cpp
@ -45,6 +45,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster RGB
+    @category LEDStrip
    @type USB
    @save :warning:
    @direct :x:
--- a/Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp
+++ b/Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Coolermaster Small ARGB
+    @category LEDStrip
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp
+++ b/Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Commander Core
+    @category Cooler
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp
+++ b/Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Dominator Platinum
+    @category RAM
    @type SMBus
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp
+++ b/Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Hydro
+    @category Cooler
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -86,7 +87,7 @@ RGBController_CorsairHydro::~RGBController_CorsairHydro()
 void RGBController_CorsairHydro::SetupZones()
 {
    zone new_zone;
-    
+
    new_zone.name       = "Pump Zone";
    new_zone.type       = ZONE_TYPE_SINGLE;
    new_zone.leds_min   = 1;
--- a/Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp
+++ b/Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp
@ -21,6 +21,7 @@ static unsigned int matrix_map[5][5] =

 /**------------------------------------------------------------------*\
    @name Corsair Hydro Platinum
+    @category Cooler
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp
+++ b/Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Lighting Node
+    @category LEDStrip
    @type USB
    @save :warning:
    @direct :white_check_mark:
@ -259,7 +260,7 @@ void RGBController_CorsairLightingNode::SetupZones()
        }

        zones[channel_idx].matrix_map = NULL;
-        
+
        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
        {
            char led_idx_string[4];
--- a/Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp
+++ b/Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp
@ -221,6 +221,7 @@ typedef struct

 /**------------------------------------------------------------------*\
    @name Corsair K100 Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp
+++ b/Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPRO.cpp
@ -11,6 +11,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name Corsair K55 RGB Pro
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp
+++ b/Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp
@ -122,6 +122,7 @@ std::vector<std::tuple<unsigned int, std::string>> keys =

 /**------------------------------------------------------------------*\
    @name Corsair K65 Mini
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp
+++ b/Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp
@ -756,8 +756,9 @@ static const char* corsair_harpoon_pro_leds[] =

 /**------------------------------------------------------------------*\
    @name Corsair Peripheral
+    @category Keyboard,Mouse,Mousemat,HeadsetStand
    @type USB
-    @save :white_check_mark: or :warning: or :x:
+    @save :x:
    @direct :white_check_mark:
    @effects :x:
    @detectors DetectCorsairPeripheralControllers
@ -1037,14 +1038,14 @@ void RGBController_CorsairPeripheral::SetupZones()
                    new_led.name = corsair_mouse_leds[led_idx];
                }
                break;
-            
+
            case DEVICE_TYPE_MOUSEMAT:
            case DEVICE_TYPE_HEADSET_STAND:
                new_led.name = "Mousemat LED ";
                new_led.name.append(std::to_string(led_idx + 1));
                break;
        }
-        
+
        leds.push_back(new_led);
    }

--- a/Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp
+++ b/Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Vengeance
+    @category RAM
    @type SMBus
    @save :warning:
    @direct :x:
--- a/Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp
+++ b/Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Corsair Vengeance Pro
+    @category RAM
    @type SMBus
    @save :warning:
    @direct :white_check_mark:
@ -291,7 +292,7 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
-        }        
+        }
    }

    if (modes[active_mode].name == "Direct")
--- a/Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp
+++ b/Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp
@ -182,6 +182,7 @@ static const char* led_names[] =

 /**------------------------------------------------------------------*\
    @name Corsair Wireless Peripheral
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CougarController/RGBController_CougarRevengerST.cpp
+++ b/Controllers/CougarController/RGBController_CougarRevengerST.cpp
@ -14,6 +14,7 @@

 /**------------------------------------------------------------------*\
    @name Cougar Revenger ST
+    @category Mouse
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp
+++ b/Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp
@ -2,6 +2,7 @@

 /**------------------------------------------------------------------*\
    @name Creative Sound BlasterX G6
+    @category Headset
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/CrucialController/RGBController_Crucial.cpp
+++ b/Controllers/CrucialController/RGBController_Crucial.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Crucial RAM
+    @category RAM
    @type SMBus
    @save :x:
    @direct :white_check_mark:
@ -43,7 +44,7 @@ RGBController_Crucial::RGBController_Crucial(CrucialController* controller_ptr)
    Shift.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
    Shift.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Shift);
-    
+
    mode GradientShift;
    GradientShift.name       = "Gradient Shift";
    GradientShift.value      = CRUCIAL_MODE_GRADIENT_SHIFT;
--- a/Controllers/DarkProject/RGBController_DarkProjectKeyboard.cpp
+++ b/Controllers/DarkProject/RGBController_DarkProjectKeyboard.cpp
@ -116,8 +116,9 @@ static const char *led_names[] =
    KEY_EN_RIGHT_ARROW
 };

-/**
+/**------------------------------------------------------------------*\
    @name Dark Project Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -125,7 +126,7 @@ static const char *led_names[] =
    @detectors DetectDarkProjectKeyboardControllers
    @comment The Dark Project keyboard controller currently supports
        the full size KD3B Version 2 (ANSI layout).
-*/
+\*-------------------------------------------------------------------*/

 RGBController_DarkProjectKeyboard::RGBController_DarkProjectKeyboard(DarkProjectKeyboardController *controller_ptr)
 {
--- a/Controllers/DasKeyboardController/RGBController_DasKeyboard.cpp
+++ b/Controllers/DasKeyboardController/RGBController_DasKeyboard.cpp
@ -192,6 +192,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name Das Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/DebugController/RGBController_Debug.cpp
+++ b/Controllers/DebugController/RGBController_Debug.cpp
@ -5,6 +5,7 @@

 /**------------------------------------------------------------------*\
    @name Debug
+    @category Unknown
    @type I2C
    @save :x:
    @direct :x:
@ -43,7 +44,7 @@ void RGBController_Debug::ResizeZone(int index, int new_size)

    // Add the new ammount of LEDs to the old ammount
    size_t new_leds_size = leds.size() - old_size + new_size;
-    
+
    leds.resize(std::max(old_leds_size, new_leds_size));

    memmove(&leds[zones[index].start_idx] + old_leds_size, &leds[zones[index].start_idx] + new_leds_size, (old_leds_size - zones[index].start_idx - old_size) * sizeof(led));
@ -54,6 +55,6 @@ void RGBController_Debug::ResizeZone(int index, int new_size)
    {
        leds[zones[index].start_idx + i].name = "Linear LED " + std::to_string(i);
    }
-    
+
    SetupColors();
 }
--- a/Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp
+++ b/Controllers/DuckyKeyboardController/RGBController_DuckyKeyboard.cpp
@ -188,9 +188,10 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name Ducky Keyboard
+    @category Keyboard
    @type USB
    @save :x:
-    @direct :white_check_mark
+    @direct :white_check_mark:
    @effects :x:
    @detectors DetectDuckyKeyboardControllers
    @comment
@ -291,11 +292,11 @@ void RGBController_DuckyKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
    | This device does not support resizing zones               |
    \*---------------------------------------------------------*/
 }
-    
+
 void RGBController_DuckyKeyboard::DeviceUpdateLEDs()
 {
    unsigned char colordata[155*3];
-    
+
    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
    {
        colordata[(color_idx*3)+0] = RGBGetRValue(colors[color_idx]);
--- a/Controllers/DygmaRaiseController/RGBController_DygmaRaise.cpp
+++ b/Controllers/DygmaRaiseController/RGBController_DygmaRaise.cpp
@ -17,8 +17,8 @@ static unsigned int kb_matrix_map_ISO[6][14] =
    { {  0,  1,  2,  3,  4,  5,  6, 39, 38, 37, 36, 35, 34, 33 },
      {  7,  8,  9, 10, 11, 12, 47, 46, 45, 44, 43, 42, 41, 40 },
      { 13, 14, 15, 16, 17, 18, 54, 53, 52, 51, 50, 49, 48, NA },
-      { 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA }, 
-      { 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 }, 
+      { 19, 20, 21, 22, 23, 24, 25, 60, 59, 58, 57, 56, 55, NA },
+      { 26, 27, 28, NA, 29, 30, NA, 66, 65, NA, 64, 63, 62, 61 },
      { NA, NA, NA, NA, 31, 32, NA, 68, 67, NA, NA, NA, NA, NA } };

 static unsigned int underglow_matrix[11][14] =
@ -77,20 +77,20 @@ static const char* led_names[] =
    KEY_EN_D,
    KEY_EN_F,
    KEY_EN_G,
-    KEY_EN_LEFT_SHIFT,             
-    KEY_EN_ISO_BACK_SLASH,               
+    KEY_EN_LEFT_SHIFT,
+    KEY_EN_ISO_BACK_SLASH,
    KEY_EN_Z,
    KEY_EN_X,
    KEY_EN_C,
    KEY_EN_V,
    KEY_EN_B,
-    KEY_EN_LEFT_CONTROL,           
-    KEY_EN_LEFT_WINDOWS,           
+    KEY_EN_LEFT_CONTROL,
+    KEY_EN_LEFT_WINDOWS,
    KEY_EN_LEFT_ALT,
-    "Key: T1",                     
-    "Key: T2",                     
-    "Key: T3",                     
-    "Key: T4",                     
+    "Key: T1",
+    "Key: T2",
+    "Key: T3",
+    "Key: T4",
    KEY_EN_BACKSPACE,
    KEY_EN_EQUALS,
    KEY_EN_MINUS,
@ -98,9 +98,9 @@ static const char* led_names[] =
    KEY_EN_9,
    KEY_EN_8,
    KEY_EN_7,
-    KEY_EN_ANSI_ENTER,                  
-    KEY_EN_RIGHT_BRACKET,                      
-    KEY_EN_LEFT_BRACKET,                      
+    KEY_EN_ANSI_ENTER,
+    KEY_EN_RIGHT_BRACKET,
+    KEY_EN_LEFT_BRACKET,
    KEY_EN_P,
    KEY_EN_O,
    KEY_EN_I,
@ -113,24 +113,25 @@ static const char* led_names[] =
    KEY_EN_K,
    KEY_EN_J,
    KEY_EN_H,
-    KEY_EN_RIGHT_SHIFT,            
-    KEY_EN_FORWARD_SLASH,                      
+    KEY_EN_RIGHT_SHIFT,
+    KEY_EN_FORWARD_SLASH,
    KEY_EN_PERIOD,
    KEY_EN_COMMA,
    KEY_EN_M,
    KEY_EN_N,
-    KEY_EN_RIGHT_CONTROL,          
-    KEY_EN_RIGHT_WINDOWS,          
-    KEY_EN_RIGHT_FUNCTION,               
-    KEY_EN_RIGHT_ALT,              
-    "Key: T6",                     
-    "Key: T5",                     
-    "Key: T8",                     
-    "Key: T7",             
+    KEY_EN_RIGHT_CONTROL,
+    KEY_EN_RIGHT_WINDOWS,
+    KEY_EN_RIGHT_FUNCTION,
+    KEY_EN_RIGHT_ALT,
+    "Key: T6",
+    "Key: T5",
+    "Key: T8",
+    "Key: T7",
 };

 /**------------------------------------------------------------------*\
    @name Dygma Raise Keyboard
+    @category Keyboard
    @type Serial
    @save :x:
    @direct :white_check_mark:
@ -139,7 +140,7 @@ static const char* led_names[] =
    @comment
 \*-------------------------------------------------------------------*/

-RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr) 
+RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* controller_ptr)
 {
    controller      = controller_ptr;

@ -159,12 +160,12 @@ RGBController_DygmaRaise::RGBController_DygmaRaise(DygmaRaiseController* control
    SetupZones();
 }

-RGBController_DygmaRaise::~RGBController_DygmaRaise() 
+RGBController_DygmaRaise::~RGBController_DygmaRaise()
 {
    delete controller;
 }

-void RGBController_DygmaRaise::SetupZones() 
+void RGBController_DygmaRaise::SetupZones()
 {
    /*---------------------------------------------------------*\
    | Set up zones                                              |
@ -192,10 +193,10 @@ void RGBController_DygmaRaise::SetupZones()
            new_zone.matrix_map->width      = 14;
            new_zone.matrix_map->map        = (unsigned int *)&underglow_matrix;
        }
-        
+
        zones.push_back(new_zone);
    }
-    
+
    /*---------------------------------------------------------*\
    | Set up keyboard LEDs                                      |
    \*---------------------------------------------------------*/
@ -226,7 +227,7 @@ void RGBController_DygmaRaise::SetupZones()
    SetupColors();
 }

-void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/) 
+void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
 {
    /*---------------------------------------------------------*\
    | This device does not support resizing zones               |
@ -234,27 +235,27 @@ void RGBController_DygmaRaise::ResizeZone(int /*zone*/, int /*new_size*/)
 }


-void RGBController_DygmaRaise::DeviceUpdateLEDs() 
+void RGBController_DygmaRaise::DeviceUpdateLEDs()
 {
    controller->SendDirect(colors,leds.size());
 }

-void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/) 
+void RGBController_DygmaRaise::UpdateZoneLEDs(int /*zone*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/) 
+void RGBController_DygmaRaise::UpdateSingleLED(int /*led*/)
 {
    DeviceUpdateLEDs();
 }

-void RGBController_DygmaRaise::SetCustomMode() 
+void RGBController_DygmaRaise::SetCustomMode()
 {
    active_mode = 0;
 }

-void RGBController_DygmaRaise::DeviceUpdateMode() 
+void RGBController_DygmaRaise::DeviceUpdateMode()
 {
-    
+
 }
--- a/Controllers/E131Controller/RGBController_E131.cpp
+++ b/Controllers/E131Controller/RGBController_E131.cpp
@ -15,6 +15,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name E1.31 Devices
+    @category LEDStrip
    @type E1.31
    @save :x:
    @direct :white_check_mark:
@ -114,7 +115,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
    for(unsigned int univ_list_idx = 0; univ_list_idx < universe_list.size(); univ_list_idx++)
    {
        location += std::to_string(universe_list[univ_list_idx]);
-        
+
        if(univ_list_idx < (universe_list.size() - 1))
        {
            location += ", ";
@ -135,7 +136,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
    | Create E1.31 socket                       |
    \*-----------------------------------------*/
    sockfd = e131_socket();
-    
+
    keepalive_delay = 0ms;

    SetupZones();
@ -291,7 +292,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
            }
            zones[device_idx].matrix_map = new_map;
        }
-	}
+    }

    if(keepalive_delay.count() > 0)
    {
@ -380,7 +381,7 @@ void RGBController_E131::DeviceUpdateLEDs()
    int color_idx = 0;

    last_update_time = std::chrono::steady_clock::now();
-    
+
    for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
    {
        float universe_size = devices[device_idx].universe_size;
@ -441,12 +442,12 @@ void RGBController_E131::DeviceUpdateLEDs()

 void RGBController_E131::UpdateZoneLEDs(int /*zone*/)
 {
-	DeviceUpdateLEDs();
+    DeviceUpdateLEDs();
 }

 void RGBController_E131::UpdateSingleLED(int /*led*/)
 {
-	DeviceUpdateLEDs();
+    DeviceUpdateLEDs();
 }

 void RGBController_E131::SetCustomMode()
--- a/Controllers/EKController/RGBController_EKController.cpp
+++ b/Controllers/EKController/RGBController_EKController.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name EK Loop Connect
+    @category LEDStrip
    @type USB
    @save :warning:
    @direct :x:
--- a/Controllers/ENESMBusController/RGBController_ENESMBus.cpp
+++ b/Controllers/ENESMBusController/RGBController_ENESMBus.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name ENE SMBus Device
+    @category RAM,Motherboard,GPU,Storage
    @type SMBus
    @save :white_check_mark:
    @direct :white_check_mark:
@ -64,7 +65,7 @@ RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_p
    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
    Static.color_mode = MODE_COLORS_PER_LED;
    modes.push_back(Static);
-    
+
    mode Breathing;
    Breathing.name       = "Breathing";
    Breathing.value      = ENE_MODE_BREATHING;
@ -361,7 +362,7 @@ void RGBController_ENESMBus::SetupZones()
            }

            new_zone->matrix_map = NULL;
-            
+
            /*---------------------------------------------------------*\
            | Push new zone to zones vector                             |
            \*---------------------------------------------------------*/
--- a/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp
+++ b/Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp
@ -20,6 +20,7 @@ static const char* evga_v3_zone_names[] =

 /**------------------------------------------------------------------*\
    @name EVGA RGB v3 GPU
+    @category GPU
    @type I2C
    @save :white_check_mark:
    @direct :white_check_mark:
@ -167,7 +168,7 @@ RGBController_EVGAGPUv3::RGBController_EVGAGPUv3(EVGAGPUv3Controller* evga_ptr)
    for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
    {
        active_mode = evga->GetZoneMode(0); // Hard coding zone 0 until per zone modes are available.
-        
+
        if(active_mode != EVGA_GPU_V3_MODE_OFF)
        {
            EVGAv3_config hw_config = evga->GetZoneConfig(zoneIndexMap[zone_idx], active_mode);
@ -266,7 +267,7 @@ void RGBController_EVGAGPUv3::DeviceUpdateLEDs()
    | modes and as such colorB will always be black (0x000000)  |
    \*---------------------------------------------------------*/
    EVGAv3_config zone_config;
-    
+
    zone_config.brightness      = modes[active_mode].brightness;
    zone_config.speed           = modes[active_mode].speed;
    zone_config.direction       = modes[active_mode].direction;
@ -311,7 +312,7 @@ void RGBController_EVGAGPUv3::DeviceUpdateMode()
    for(uint8_t zone = 0; zone < 4; zone++)
    {
        evga->SetZoneMode(zone, modes[active_mode].value);
-    } 
+    }
    */
    //LOG_TRACE("[%s] Updating to mode %1d", evga->evgaGPUName, modes[active_mode].value);
    DeviceUpdateLEDs();
--- a/Controllers/EVGAGP102GPUController/RGBController_EVGAGP102.cpp
+++ b/Controllers/EVGAGP102GPUController/RGBController_EVGAGP102.cpp
@ -12,6 +12,7 @@

 /**------------------------------------------------------------------*\
    @name EVGA GP102 GPU
+    @category GPU
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/EVGAPascalGPUController/RGBController_EVGAGPUv1.cpp
+++ b/Controllers/EVGAPascalGPUController/RGBController_EVGAGPUv1.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name EVGA RGB v1 GPU
+    @category GPU
    @type I2C
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.cpp
+++ b/Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name EVGA RGB v2 GPU
+    @category GPU
    @type I2C
    @save :white_check_mark:
    @direct :white_check_mark:
@ -218,7 +219,7 @@ void RGBController_EVGAGPUv2::DeviceUpdateMode()
        colorA = modes[active_mode].colors[0];
        colorB = (modes[active_mode].colors.size() == 2) ? modes[active_mode].colors[1] : 0 ;
    }
-    
+
    evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
 }

--- a/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp
+++ b/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp
@ -184,6 +184,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name EVGA USB Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp
+++ b/Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp
@ -22,6 +22,7 @@ static unsigned int matrix_map[6][23] =

 /**------------------------------------------------------------------*\
    @name EVision Keyboard
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :x:
@ -175,7 +176,7 @@ RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardCont
    Blooming.speed      = EVISION_KB_SPEED_NORMAL;
    Blooming.color_mode = MODE_COLORS_NONE;
    modes.push_back(Blooming);
-    
+
    mode Reactive;
    Reactive.name       = "Reactive";
    Reactive.value      = EVISION_KB_MODE_REACTIVE;
@ -247,7 +248,7 @@ void RGBController_EVisionKeyboard::SetupZones()
    new_zone.matrix_map->height = 6;
    new_zone.matrix_map->width  = 23;
    new_zone.matrix_map->map    = (unsigned int *)&matrix_map;
-    
+
    zones.push_back(new_zone);

    for(int led_idx = 0; led_idx < 126; led_idx++)
--- a/Controllers/EspurnaController/RGBController_Espurna.cpp
+++ b/Controllers/EspurnaController/RGBController_Espurna.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Espurna
+    @category Light
    @type TCP
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/FanBusController/RGBController_FanBus.cpp
+++ b/Controllers/FanBusController/RGBController_FanBus.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name FanBus
+    @category Cooler
    @type Serial
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/FaustusController/RGBController_Faustus.cpp
+++ b/Controllers/FaustusController/RGBController_Faustus.cpp
@ -5,6 +5,7 @@

 /**------------------------------------------------------------------*\
    @name ASUS TUF Keyboard (Faustus)
+    @category Keyboard
    @type File Stream
    @save :x:
    @direct :x:
--- a/Controllers/GainwardGPUController/RGBController_GainwardGPUv1.cpp
+++ b/Controllers/GainwardGPUController/RGBController_GainwardGPUv1.cpp
@ -16,6 +16,7 @@ int RGBController_GainwardGPUv1::GetDeviceMode()

 /**------------------------------------------------------------------*\
    @name Gainward GPU v1
+    @category GPU
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/GainwardGPUController/RGBController_GainwardGPUv2.cpp
+++ b/Controllers/GainwardGPUController/RGBController_GainwardGPUv2.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Gainward GPU v2
+    @category GPU
    @type I2C
    @save :x:
    @direct :x:
@ -181,7 +182,7 @@ void RGBController_GainwardGPUv2::DeviceUpdateMode()
                unsigned char b = RGBGetBValue(current_mode.colors[0]);
                controller->SetLEDColors(r, g, b, GAINWARD_V2_COLOR_REGISTER_TERTIARY);
            }
-        
+
        case 2:
            controller->SetMode((unsigned char)(current_mode.value), (unsigned char)(current_mode.speed));
            controller->SetDirection(current_mode.direction);
--- a/Controllers/GalaxGPUController/RGBController_GalaxGPU.cpp
+++ b/Controllers/GalaxGPUController/RGBController_GalaxGPU.cpp
@ -42,6 +42,7 @@ int RGBController_GalaxGPU::GetDeviceMode()

 /**------------------------------------------------------------------*\
    @name Galax GPU
+    @category GPU
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp
+++ b/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Aorus ATC800
+    @category Cooler
    @type USB
    @save :x:
    @direct :x:
--- a/Controllers/GigabyteRGBFusion2DRAMController/RGBController_GigabyteRGBFusion2DRAM.cpp
+++ b/Controllers/GigabyteRGBFusion2DRAMController/RGBController_GigabyteRGBFusion2DRAM.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Gigabyte Fusion2 DRAM
+    @category RAM
    @type I2C
    @save :x:
    @direct :x:
--- a/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp
+++ b/Controllers/GigabyteRGBFusion2GPUController/RGBController_GigabyteRGBFusion2GPU.cpp
@ -20,6 +20,7 @@ static const char* gigabyte_fusion2_gpu_zone[] =

 /**------------------------------------------------------------------*\
    @name Gigabyte Fusion 2 GPU
+    @category GPU
    @type I2C
    @save :white_check_mark:
    @direct :white_check_mark:
@ -130,7 +131,7 @@ RGBController_RGBFusion2GPU::RGBController_RGBFusion2GPU(RGBFusion2GPUController
    mode Shift;
    Shift.name                  = "Color Shift";
    Shift.value                 = RGB_FUSION2_GPU_MODE_COLOR_SHIFT;
-    Shift.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; 
+    Shift.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
    Shift.speed_min             = RGB_FUSION2_GPU_SPEED_SLOWEST;
    Shift.speed_max             = RGB_FUSION2_GPU_SPEED_FASTEST;
    Shift.speed                 = RGB_FUSION2_GPU_SPEED_NORMAL;
--- a/Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp
+++ b/Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp
@ -39,6 +39,7 @@ static const char* rgb_fusion_zone_names[] =

 /**------------------------------------------------------------------*\
    @name Gigabyte Fusion2 SMBus
+    @category Motherboard
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp
+++ b/Controllers/GigabyteRGBFusion2USBController/RGBController_GigabyteRGBFusion2USB.cpp
@ -112,7 +112,7 @@ static KnownLayout knownLayoutsLookup
                }
            }
        }
-    },    
+    },
    {
        "STD_ATX",
        {
@ -190,6 +190,7 @@ static KnownLayout knownLayoutsLookup

 /**------------------------------------------------------------------*\
    @name Gigabyte RGB Fusion 2 USB
+    @category Motherboard
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -555,7 +556,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
        unsigned char red = 0;
        unsigned char grn = 0;
        unsigned char blu = 0;
-        
+
        for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++)
        {
            /*---------------------------------------------------------*\
@ -590,7 +591,7 @@ void RGBController_RGBFusion2USB::UpdateZoneLEDs(int zone)
            \*---------------------------------------------------------*/
            controller->SetLEDEffect(zones[zone].leds[led_idx].value, mode_value, modes[active_mode].speed, modes[active_mode].brightness, random, red, grn, blu);
        }
-        
+
        controller->ApplyEffect();
    }
    /*---------------------------------------------------------*\
@ -658,7 +659,7 @@ void RGBController_RGBFusion2USB::UpdateSingleLED(int led)
        unsigned char red = 0;
        unsigned char grn = 0;
        unsigned char blu = 0;
-        
+
        /*---------------------------------------------------------*\
        | Motherboard LEDs always use effect mode, so use static for|
        | direct mode but get colors from zone                      |
--- a/Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.cpp
+++ b/Controllers/GigabyteRGBFusionController/RGBController_GigabyteRGBFusion.cpp
@ -17,6 +17,7 @@ static const char* rgb_fusion_zone_names[] =

 /**------------------------------------------------------------------*\
    @name Gigabyte Fusion SMBus
+    @category Motherboard
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp
+++ b/Controllers/GigabyteRGBFusionGPUController/RGBController_GigabyteRGBFusionGPU.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Gigabyte Fusion GPU
+    @category GPU
    @type I2C
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/HPOmen30LController/RGBController_HPOmen30L.cpp
+++ b/Controllers/HPOmen30LController/RGBController_HPOmen30L.cpp
@ -8,6 +8,7 @@

 /**------------------------------------------------------------------*\
    @name HP Omen 30L
+    @category Motherboard
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -208,6 +209,6 @@ void RGBController_HPOmen30L::DeviceUpdateMode()
    {
        controller->SetZoneMode(i, modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness);
    }
- 
+
    DeviceUpdateLEDs();
 }
--- a/Controllers/HoltekController/RGBController_HoltekA070.cpp
+++ b/Controllers/HoltekController/RGBController_HoltekA070.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Holtek A070
+    @category Mouse
    @type USB
    @save :x:
    @direct :x:
--- a/Controllers/HoltekController/RGBController_HoltekA1FA.cpp
+++ b/Controllers/HoltekController/RGBController_HoltekA1FA.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Holtek A1FA
+    @category Mouse
    @type USB
    @save :x:
    @direct :x:
--- a/Controllers/HyperXDRAMController/RGBController_HyperXDRAM.cpp
+++ b/Controllers/HyperXDRAMController/RGBController_HyperXDRAM.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name HyperX DRAM
+    @category RAM
    @type I2C
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite.cpp
+++ b/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite.cpp
@ -178,6 +178,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name HyperX Alloy Elite
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite2.cpp
+++ b/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyElite2.cpp
@ -195,6 +195,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name HyperX Alloy Elite 2
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyFPS.cpp
+++ b/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyFPS.cpp
@ -150,6 +150,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name HyperX Alloy FPS
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.cpp
+++ b/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOrigins.cpp
@ -170,6 +170,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name HyperX Alloy Origins
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -276,7 +277,7 @@ void RGBController_HyperXAlloyOrigins::ResizeZone(int /*zone*/, int /*new_size*/
    | This device does not support resizing zones               |
    \*---------------------------------------------------------*/
 }
-    
+
 void RGBController_HyperXAlloyOrigins::DeviceUpdateLEDs()
 {
    controller->SetLEDsDirect(colors);
--- a/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.cpp
+++ b/Controllers/HyperXKeyboardController/RGBController_HyperXAlloyOriginsCore.cpp
@ -17,12 +17,12 @@ using namespace std::chrono_literals;

 static unsigned int matrix_map[6][19] =
 {
-		{   0,  NA,   1,   2,   3,   4,   5,   6,   7,  44,  NA,  45,  46,  47,  48,  NA,  49,  50,  51 },
-		{   8,   9,  10,  11,  12,  13,  14,  15,  16,  52,  53,  54,  55,  56,  NA,  NA,  57,  58,  59 },
-		{  17,  NA,  18,  19,  20,  21,  22,  23,  24,  60,  61,  62,  63,  64,  65,  NA,  66,  67,  68 },
-		{  25,  NA,  26,  27,  28,  29,  30,  31,  32,  69,  70,  71,  72,  73,  NA,  NA,  NA,  NA,  NA },
-		{  33,  NA,  34,  35,  36,  37,  38,  NA,  39,  74,  75,  76,  77,  78,  NA,  NA,  NA,  79,  NA },
-		{  40,  41,  42,  NA,  NA,  NA,  43,  NA,  NA,  NA,  NA,  80,  81,  82,  83,  NA,  84,  85,  86 }
+        {   0,  NA,   1,   2,   3,   4,   5,   6,   7,  44,  NA,  45,  46,  47,  48,  NA,  49,  50,  51 },
+        {   8,   9,  10,  11,  12,  13,  14,  15,  16,  52,  53,  54,  55,  56,  NA,  NA,  57,  58,  59 },
+        {  17,  NA,  18,  19,  20,  21,  22,  23,  24,  60,  61,  62,  63,  64,  65,  NA,  66,  67,  68 },
+        {  25,  NA,  26,  27,  28,  29,  30,  31,  32,  69,  70,  71,  72,  73,  NA,  NA,  NA,  NA,  NA },
+        {  33,  NA,  34,  35,  36,  37,  38,  NA,  39,  74,  75,  76,  77,  78,  NA,  NA,  NA,  79,  NA },
+        {  40,  41,  42,  NA,  NA,  NA,  43,  NA,  NA,  NA,  NA,  80,  81,  82,  83,  NA,  84,  85,  86 }
 };

 static const char* zone_names[] =
@ -92,7 +92,7 @@ static const char *led_names[] =
    KEY_EN_LEFT_ALT,
    KEY_EN_SPACE,

-	// End of first section
+    // End of first section

    KEY_EN_F8,
    KEY_EN_F9,
@ -148,6 +148,7 @@ static const char *led_names[] =

 /**------------------------------------------------------------------*\
    @name HyperX Alloy Origins Core
+    @category Keyboard
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.cpp
+++ b/Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name HyoerX Pulsefire Dart
+    @category Mouse
    @type USB
    @save :white_check_mark:
    @direct :white_check_mark:
--- a/Controllers/HyperXMouseController/RGBController_HyperXPulsefireFPSPro.cpp
+++ b/Controllers/HyperXMouseController/RGBController_HyperXPulsefireFPSPro.cpp
@ -13,6 +13,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name HyperX Pulsefire FPS
+    @category Mouse
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -76,14 +77,14 @@ void RGBController_HyperXPulsefireFPSPro::SetupZones()
        for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
        {
            led new_led;
-            
+
            new_led.name = zones[zone_idx].name;

            if(zones[zone_idx].leds_count > 1)
            {
                new_led.name.append(" LED ");
                new_led.name.append(std::to_string(led_idx + 1));
-            }  
+            }

            leds.push_back(new_led);
        }
--- a/Controllers/HyperXMouseController/RGBController_HyperXPulsefireHaste.cpp
+++ b/Controllers/HyperXMouseController/RGBController_HyperXPulsefireHaste.cpp
@ -13,6 +13,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name HyperX Pulsefire Haste
+    @category Mouse
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -76,14 +77,14 @@ void RGBController_HyperXPulsefireHaste::SetupZones()
        for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
        {
            led new_led;
-            
+
            new_led.name = zones[zone_idx].name;

            if(zones[zone_idx].leds_count > 1)
            {
                new_led.name.append(" LED ");
                new_led.name.append(std::to_string(led_idx + 1));
-            }  
+            }

            leds.push_back(new_led);
        }
--- a/Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.cpp
+++ b/Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.cpp
@ -13,6 +13,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name HyperX Pulsefire Surge
+    @category Mouse
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -85,14 +86,14 @@ void RGBController_HyperXPulsefireSurge::SetupZones()
        for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
        {
            led new_led;
-            
+
            new_led.name = zones[zone_idx].name;

            if(zones[zone_idx].leds_count > 1)
            {
                new_led.name.append(" LED ");
                new_led.name.append(std::to_string(led_idx + 1));
-            }  
+            }

            leds.push_back(new_led);
        }
--- a/Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp
+++ b/Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp
@ -13,6 +13,7 @@ using namespace std::chrono_literals;

 /**------------------------------------------------------------------*\
    @name HyperX Mousemat
+    @category Mousemat
    @type USB
    @save :x:
    @direct :white_check_mark:
@ -85,14 +86,14 @@ void RGBController_HyperXMousemat::SetupZones()
        for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
        {
            led new_led;
-            
+
            new_led.name = zones[zone_idx].name;

            if(zones[zone_idx].leds_count > 1)
            {
                new_led.name.append(" LED ");
                new_led.name.append(std::to_string(led_idx + 1));
-            }  
+            }

            leds.push_back(new_led);
        }
--- a/Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.cpp
+++ b/Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.cpp
@ -416,6 +416,7 @@ typedef struct

 /**------------------------------------------------------------------*\
    @name Keychron Keyboard
+    @category Keyboard
    @type USB
    @save :x:
    @direct :x:
--- a/Controllers/LEDStripController/RGBController_LEDStrip.cpp
+++ b/Controllers/LEDStripController/RGBController_LEDStrip.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Serial LED Strip
+    @category LEDStrip
    @type Serial
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/LIFXController/RGBController_LIFX.cpp
+++ b/Controllers/LIFXController/RGBController_LIFX.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name LIFX Globes
+    @category Light
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/LexipMouseController/RGBController_LexipMouse.cpp
+++ b/Controllers/LexipMouseController/RGBController_LexipMouse.cpp
@ -14,6 +14,7 @@

 /**------------------------------------------------------------------*\
    @name Lexip Mouse
+    @category Mouse
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/LianLiController/RGBController_LianLiUniHub.cpp
+++ b/Controllers/LianLiController/RGBController_LianLiUniHub.cpp
@ -30,6 +30,7 @@ mode makeMode()

 /**------------------------------------------------------------------*\
    @name Lian Li Uni Hub
+    @category Cooler
    @type USB
    @save :x:
    @direct :warning:
--- a/Controllers/LinuxLEDController/RGBController_LinuxLED.cpp
+++ b/Controllers/LinuxLEDController/RGBController_LinuxLED.cpp
@ -10,6 +10,7 @@

 /**------------------------------------------------------------------*\
    @name Dummy
+    @category LEDStrip
    @type File Stream
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechG203L.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG203L.cpp
@ -2,6 +2,7 @@

 /**------------------------------------------------------------------*\
    @name Logitech G203L
+    @category Mouse
    @type USB
    @save :warning:
    @direct :white_check_mark:
@ -165,7 +166,7 @@ void RGBController_LogitechG203L::DeviceUpdateMode()
        blu = RGBGetBValue(modes[active_mode].colors[0]);
    }

-    if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) 
+    if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
    {
        dir = (unsigned char)modes[active_mode].direction;
    }
--- a/Controllers/LogitechController/RGBController_LogitechG213.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG213.cpp
@ -30,6 +30,7 @@ static const unsigned char led_values[] =

 /**------------------------------------------------------------------*\
    @name Logitech G213
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechG560.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG560.cpp
@ -13,6 +13,7 @@

 /**------------------------------------------------------------------*\
    @name Logitech G560
+    @category Speaker
    @type USB
    @save :x:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechG810.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG810.cpp
@ -168,6 +168,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Logitech G810
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
@ -202,7 +203,7 @@ RGBController_LogitechG810::RGBController_LogitechG810(LogitechG810Controller* c
    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
    Static.colors.resize(1);
    modes.push_back(Static);
-    
+
    mode Off;
    Off.name                        = "Off";
    Off.value                       = LOGITECH_G810_MODE_OFF;
@ -330,7 +331,7 @@ void RGBController_LogitechG810::DeviceUpdateLEDs()
        frame_buf[(frame_cnt * 4) + 1] = RGBGetRValue(colors[led_idx]);
        frame_buf[(frame_cnt * 4) + 2] = RGBGetGValue(colors[led_idx]);
        frame_buf[(frame_cnt * 4) + 3] = RGBGetBValue(colors[led_idx]);
-        
+
        frame_cnt++;
        prev_zone = zone;

--- a/Controllers/LogitechController/RGBController_LogitechG815.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG815.cpp
@ -172,6 +172,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Logitech G815
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechG910.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG910.cpp
@ -169,6 +169,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Logitech G910
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
@ -203,7 +204,7 @@ RGBController_LogitechG910::RGBController_LogitechG910(LogitechG910Controller* c
    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
    Static.colors.resize(1);
    modes.push_back(Static);
-    
+
    mode Off;
    Off.name                        = "Off";
    Off.value                       = LOGITECH_G910_MODE_OFF;
@ -331,7 +332,7 @@ void RGBController_LogitechG910::DeviceUpdateLEDs()
        frame_buf[(frame_cnt * 4) + 1] = RGBGetRValue(colors[led_idx]);
        frame_buf[(frame_cnt * 4) + 2] = RGBGetGValue(colors[led_idx]);
        frame_buf[(frame_cnt * 4) + 3] = RGBGetBValue(colors[led_idx]);
-        
+
        frame_cnt++;
        prev_zone = zone;

--- a/Controllers/LogitechController/RGBController_LogitechG915.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG915.cpp
@ -184,6 +184,7 @@ static const led_type led_names[] =

 /**------------------------------------------------------------------*\
    @name Logitech G915
+    @category Keyboard
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechG933.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechG933.cpp
@ -12,8 +12,9 @@
 #include "RGBController_LogitechG933.h"

 /**------------------------------------------------------------------*\
-    @name Dummy
-    @type I2C or Serial or WMI or USB
+    @name Logitech G933
+    @category Headset
+    @type USB
    @save :x:
    @direct :white_check_mark:
    @effects :x:
--- a/Controllers/LogitechController/RGBController_LogitechGLightsync.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechGLightsync.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Logitech Lightsync Mouse
+    @category Mouse
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Controllers/LogitechController/RGBController_LogitechGLightsync1zone.cpp
+++ b/Controllers/LogitechController/RGBController_LogitechGLightsync1zone.cpp
@ -11,6 +11,7 @@

 /**------------------------------------------------------------------*\
    @name Logitech Lightsync Mouse (1 Zone)
+    @category Mouse
    @type USB
    @save :warning:
    @direct :white_check_mark:
--- a/Show More
+++ b/Show More