Test saving on RazerController

Controllers/RazerController/RGBController_Razer.cpp

@@ -56,14 +56,14 @@ RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
     mode Off;
     Off.name                = "Off";
     Off.value               = RAZER_MODE_OFF;
-    Off.flags               = 0;
+    Off.flags               = MODE_FLAG_MANUAL_SAVE;
     Off.color_mode          = MODE_COLORS_NONE;
     modes.push_back(Off);
 
     mode Static;
     Static.name             = "Static";
     Static.value            = RAZER_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Static.flags            = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     Static.color_mode       = MODE_COLORS_MODE_SPECIFIC;
     Static.colors_min       = 1;
     Static.colors_max       = 1;
@@ -78,7 +78,7 @@ RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
         mode Breathing;
         Breathing.name           = "Breathing";
         Breathing.value          = RAZER_MODE_BREATHING;
-        Breathing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.flags          = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
         Breathing.color_mode     = MODE_COLORS_MODE_SPECIFIC;
         Breathing.colors_min     = 1;
         Breathing.colors_max     = 2;
@@ -92,7 +92,7 @@ RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
     mode SpectrumCycle;
     SpectrumCycle.name           = "Spectrum Cycle";
     SpectrumCycle.value          = RAZER_MODE_SPECTRUM_CYCLE;
-    SpectrumCycle.flags          = MODE_FLAG_HAS_BRIGHTNESS;
+    SpectrumCycle.flags          = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
     SpectrumCycle.color_mode     = MODE_COLORS_NONE;
     SpectrumCycle.brightness_min = 0;
     SpectrumCycle.brightness_max = max_brightness;
@@ -104,7 +104,7 @@ RGBController_Razer::RGBController_Razer(RazerController* controller_ptr)
         mode Wave;
         Wave.name               = "Wave";
         Wave.value              = RAZER_MODE_WAVE;
-        Wave.flags              = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS;
+        Wave.flags              = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
         Wave.direction          = MODE_DIRECTION_RIGHT;
         Wave.color_mode         = MODE_COLORS_NONE;
         Wave.brightness_min     = 0;
@@ -374,11 +374,21 @@ void RGBController_Razer::UpdateSingleLED(int /*led*/)
 }
 
 void RGBController_Razer::DeviceUpdateMode()
+{
+    SendMode(false);
+}
+
+void RGBController_Razer::DeviceSaveMode()
+{
+    SendMode(true);
+}
+
+void RGBController_Razer::SendMode(bool save)
 {
     switch(modes[active_mode].value)
     {
         case RAZER_MODE_OFF:
-            controller->SetModeOff();
+            controller->SetModeOff(save);
             break;
 
         case RAZER_MODE_STATIC:
@@ -388,14 +398,14 @@ void RGBController_Razer::DeviceUpdateMode()
                 unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
                 unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
 
-                controller->SetModeStatic(red, grn, blu);
+                controller->SetModeStatic(red, grn, blu, save);
             }
             break;
 
         case RAZER_MODE_BREATHING:
             if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
             {
-                controller->SetModeBreathingRandom();
+                controller->SetModeBreathingRandom(save);
             }
             else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
             {
@@ -405,7 +415,7 @@ void RGBController_Razer::DeviceUpdateMode()
                     unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
                     unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
 
-                    controller->SetModeBreathingOneColor(red, grn, blu);
+                    controller->SetModeBreathingOneColor(red, grn, blu, save);
                 }
                 else if(modes[active_mode].colors.size() == 2)
                 {
@@ -416,24 +426,24 @@ void RGBController_Razer::DeviceUpdateMode()
                     unsigned char grn2 = RGBGetGValue(modes[active_mode].colors[1]);
                     unsigned char blu2 = RGBGetBValue(modes[active_mode].colors[1]);
 
-                    controller->SetModeBreathingTwoColors(red1, grn1, blu1, red2, grn2, blu2);
+                    controller->SetModeBreathingTwoColors(red1, grn1, blu1, red2, grn2, blu2, save);
                 }
             }
             break;
 
         case RAZER_MODE_SPECTRUM_CYCLE:
-            controller->SetModeSpectrumCycle();
+            controller->SetModeSpectrumCycle(save);
             break;
 
         case RAZER_MODE_WAVE:
             switch(modes[active_mode].direction)
             {
                 case MODE_DIRECTION_LEFT:
-                    controller->SetModeWave(2);
+                    controller->SetModeWave(2, save);
                     break;
 
                 default:
-                    controller->SetModeWave(1);
+                    controller->SetModeWave(1, save);
                     break;
             }
             break;

Controllers/RazerController/RGBController_Razer.h

@@ -38,7 +38,10 @@ public:
     void        UpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     RazerController*    controller;
+
+    void        SendMode(bool save);
 };

Controllers/RazerController/RazerController.cpp

@@ -269,39 +269,39 @@ void RazerController::SetLEDs(RGBColor* colors)
     delete[] output_array;
 }
 
-void RazerController::SetModeBreathingOneColor(unsigned char red, unsigned char grn, unsigned char blu)
+void RazerController::SetModeBreathingOneColor(unsigned char red, unsigned char grn, unsigned char blu, bool save)
 {
-    razer_set_mode_breathing_one_color(red, grn, blu);
+    razer_set_mode_breathing_one_color(red, grn, blu, save);
 }
 
-void RazerController::SetModeBreathingRandom()
+void RazerController::SetModeBreathingRandom(bool save)
 {
-    razer_set_mode_breathing_random();
+    razer_set_mode_breathing_random(save);
 }
 
-void RazerController::SetModeBreathingTwoColors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2)
+void RazerController::SetModeBreathingTwoColors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2, bool save)
 {
-    razer_set_mode_breathing_two_colors(r1, g1, b1, r2, g2, b2);
+    razer_set_mode_breathing_two_colors(r1, g1, b1, r2, g2, b2, save);
 }
 
-void RazerController::SetModeOff()
+void RazerController::SetModeOff(bool save)
 {
-    razer_set_mode_none();
+    razer_set_mode_none(save);
 }
 
-void RazerController::SetModeSpectrumCycle()
+void RazerController::SetModeSpectrumCycle(bool save)
 {
-    razer_set_mode_spectrum_cycle();
+    razer_set_mode_spectrum_cycle(save);
 }
 
-void RazerController::SetModeStatic(unsigned char red, unsigned char grn, unsigned char blu)
+void RazerController::SetModeStatic(unsigned char red, unsigned char grn, unsigned char blu, bool save)
 {
-    razer_set_mode_static(red, grn, blu);
+    razer_set_mode_static(red, grn, blu, save);
 }
 
-void RazerController::SetModeWave(unsigned char direction)
+void RazerController::SetModeWave(unsigned char direction, bool save)
 {
-    razer_set_mode_wave(direction);
+    razer_set_mode_wave(direction, save);
 }
 
 bool RazerController::SupportsBreathing()
@@ -1250,21 +1250,27 @@ void RazerController::razer_set_device_mode(unsigned char device_mode)
     razer_usb_send(&report);
 }
 
-void RazerController::razer_set_mode_breathing_one_color(unsigned char red, unsigned char grn, unsigned char blu)
+void RazerController::razer_set_mode_breathing_one_color(unsigned char red, unsigned char grn, unsigned char blu, bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_breathing_one_color_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+            report                          = razer_create_mode_breathing_one_color_standard_matrix_report(storage_mode, dev_led_id, red, grn, blu);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_breathing_one_color_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+            report                          = razer_create_mode_breathing_one_color_extended_matrix_report(storage_mode, dev_led_id, red, grn, blu);
             razer_usb_send(&report);
             break;
 
@@ -1283,41 +1289,41 @@ void RazerController::razer_set_mode_breathing_one_color(unsigned char red, unsi
                 | These devices use individual LED effect reports   |
                 \*-------------------------------------------------*/
                 case RAZER_TARTARUS_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 2);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 2);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_DEATHADDER_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 2);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 2);
                     razer_usb_send(&report);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_LOGO, &rgb_data[3]);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, 2);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_LOGO, 2);
                     razer_usb_send(&report);
                 break;
 
                 case RAZER_NAGA_EPIC_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 2);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 2);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 2);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 2);
                     razer_usb_send(&report);
                     break;
 
@@ -1325,7 +1331,7 @@ void RazerController::razer_set_mode_breathing_one_color(unsigned char red, unsi
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_breathing_one_color_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+                    report                  = razer_create_mode_breathing_one_color_standard_matrix_report(storage_mode, dev_led_id, red, grn, blu);
                     razer_usb_send(&report);
                     break;
             }
@@ -1333,21 +1339,27 @@ void RazerController::razer_set_mode_breathing_one_color(unsigned char red, unsi
     }
 }
 
-void RazerController::razer_set_mode_breathing_random()
+void RazerController::razer_set_mode_breathing_random(bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_breathing_random_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_breathing_random_standard_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_breathing_random_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_breathing_random_extended_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
@@ -1358,7 +1370,7 @@ void RazerController::razer_set_mode_breathing_random()
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_breathing_random_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+                    report                  = razer_create_mode_breathing_random_standard_matrix_report(storage_mode, dev_led_id);
                     razer_usb_send(&report);
                     break;
             }
@@ -1366,21 +1378,27 @@ void RazerController::razer_set_mode_breathing_random()
     }
 }
 
-void RazerController::razer_set_mode_breathing_two_colors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2)
+void RazerController::razer_set_mode_breathing_two_colors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2, bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_breathing_two_colors_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, r1, g1, b1, r2, g2, b2);
+            report                          = razer_create_mode_breathing_two_colors_standard_matrix_report(storage_mode, dev_led_id, r1, g1, b1, r2, g2, b2);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_breathing_two_colors_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, r1, g1, b1, r2, g2, b2);
+            report                          = razer_create_mode_breathing_two_colors_extended_matrix_report(storage_mode, dev_led_id, r1, g1, b1, r2, g2, b2);
             razer_usb_send(&report);
             break;
 
@@ -1391,7 +1409,7 @@ void RazerController::razer_set_mode_breathing_two_colors(unsigned char r1, unsi
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_breathing_two_colors_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, r1, g1, b1, r2, g2, b2);
+                    report                  = razer_create_mode_breathing_two_colors_standard_matrix_report(storage_mode, dev_led_id, r1, g1, b1, r2, g2, b2);
                     razer_usb_send(&report);
                     break;
             }
@@ -1460,21 +1478,27 @@ void RazerController::razer_set_mode_custom()
     }
 }
 
-void RazerController::razer_set_mode_none()
+void RazerController::razer_set_mode_none(bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_none_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_none_standard_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_none_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_none_extended_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
@@ -1493,49 +1517,49 @@ void RazerController::razer_set_mode_none()
                 | These devices use individual LED effect reports   |
                 \*-------------------------------------------------*/
                 case RAZER_TARTARUS_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 0);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_DEATHADDER_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_LOGO, &rgb_data[3]);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_LOGO, 0);
                     razer_usb_send(&report);
                 break;
 
                 case RAZER_NAGA_EPIC_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 0);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_MAMBA_2012_WIRED_PID:
                 case RAZER_MAMBA_2012_WIRELESS_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
                     break;
 
@@ -1543,7 +1567,7 @@ void RazerController::razer_set_mode_none()
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_none_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+                    report                  = razer_create_mode_none_standard_matrix_report(storage_mode, dev_led_id);
                     razer_usb_send(&report);
                     break;
             }
@@ -1551,21 +1575,27 @@ void RazerController::razer_set_mode_none()
     }
 }
 
-void RazerController::razer_set_mode_spectrum_cycle()
+void RazerController::razer_set_mode_spectrum_cycle(bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_spectrum_cycle_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_spectrum_cycle_standard_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_spectrum_cycle_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+            report                          = razer_create_mode_spectrum_cycle_extended_matrix_report(storage_mode, dev_led_id);
             razer_usb_send(&report);
             break;
 
@@ -1576,31 +1606,31 @@ void RazerController::razer_set_mode_spectrum_cycle()
                 | These devices use individual LED effect reports   |
                 \*-------------------------------------------------*/
                 case RAZER_TARTARUS_CHROMA_PID:
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 4);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_DEATHADDER_CHROMA_PID:
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 4);
                     razer_usb_send(&report);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_LOGO, 4);
                     razer_usb_send(&report);
                 break;
 
                 case RAZER_NAGA_EPIC_CHROMA_PID:
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 4);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 4);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_MAMBA_2012_WIRED_PID:
                 case RAZER_MAMBA_2012_WIRELESS_PID:
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 4);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 4);
                     razer_usb_send(&report);
                     break;
 
@@ -1608,7 +1638,7 @@ void RazerController::razer_set_mode_spectrum_cycle()
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_spectrum_cycle_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id);
+                    report                  = razer_create_mode_spectrum_cycle_standard_matrix_report(storage_mode, dev_led_id);
                     razer_usb_send(&report);
                     break;
             }
@@ -1616,21 +1646,27 @@ void RazerController::razer_set_mode_spectrum_cycle()
     }
 }
 
-void RazerController::razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu)
+void RazerController::razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu, bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_static_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+            report                          = razer_create_mode_static_standard_matrix_report(storage_mode, dev_led_id, red, grn, blu);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_static_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+            report                          = razer_create_mode_static_extended_matrix_report(storage_mode, dev_led_id, red, grn, blu);
             razer_usb_send(&report);
             break;
 
@@ -1649,49 +1685,49 @@ void RazerController::razer_set_mode_static(unsigned char red, unsigned char grn
                 | These devices use individual LED effect reports   |
                 \*-------------------------------------------------*/
                 case RAZER_TARTARUS_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 0);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_DEATHADDER_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_LOGO, &rgb_data[3]);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_LOGO, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_LOGO, 0);
                     razer_usb_send(&report);
                 break;
 
                 case RAZER_NAGA_EPIC_CHROMA_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_BACKLIGHT, &rgb_data[3]);
                     razer_usb_send(&report);
 
                     std::this_thread::sleep_for(1ms);
 
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_BACKLIGHT, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_BACKLIGHT, 0);
                     razer_usb_send(&report);
                     break;
 
                 case RAZER_MAMBA_2012_WIRED_PID:
                 case RAZER_MAMBA_2012_WIRELESS_PID:
-                    report                  = razer_create_set_led_rgb_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
+                    report                  = razer_create_set_led_rgb_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, rgb_data);
                     razer_usb_send(&report);
-                    report                  = razer_create_set_led_effect_report(RAZER_STORAGE_NO_SAVE, RAZER_LED_ID_SCROLL_WHEEL, 0);
+                    report                  = razer_create_set_led_effect_report(storage_mode, RAZER_LED_ID_SCROLL_WHEEL, 0);
                     razer_usb_send(&report);
                     break;
 
@@ -1699,7 +1735,7 @@ void RazerController::razer_set_mode_static(unsigned char red, unsigned char grn
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_static_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, red, grn, blu);
+                    report                  = razer_create_mode_static_standard_matrix_report(storage_mode, dev_led_id, red, grn, blu);
                     razer_usb_send(&report);
                     break;
             }
@@ -1707,21 +1743,27 @@ void RazerController::razer_set_mode_static(unsigned char red, unsigned char grn
     }
 }
 
-void RazerController::razer_set_mode_wave(unsigned char direction)
+void RazerController::razer_set_mode_wave(unsigned char direction, bool save)
 {
-    razer_report report;
+    unsigned char   storage_mode = RAZER_STORAGE_NO_SAVE;
+    razer_report    report;
+
+    if(save)
+    {
+        storage_mode = RAZER_STORAGE_SAVE;
+    }
 
     switch(matrix_type)
     {
         case RAZER_MATRIX_TYPE_STANDARD:
         case RAZER_MATRIX_TYPE_LINEAR:
-            report                          = razer_create_mode_wave_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, direction);
+            report                          = razer_create_mode_wave_standard_matrix_report(storage_mode, dev_led_id, direction);
             razer_usb_send(&report);
             break;
 
         case RAZER_MATRIX_TYPE_EXTENDED:
         case RAZER_MATRIX_TYPE_EXTENDED_ARGB:
-            report                          = razer_create_mode_wave_extended_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, direction);
+            report                          = razer_create_mode_wave_extended_matrix_report(storage_mode, dev_led_id, direction);
             razer_usb_send(&report);
             break;
 
@@ -1732,7 +1774,7 @@ void RazerController::razer_set_mode_wave(unsigned char direction)
                 | These devices use standard matrix reports         |
                 \*-------------------------------------------------*/
                 case RAZER_ORBWEAVER_CHROMA_PID:
-                    report                  = razer_create_mode_wave_standard_matrix_report(RAZER_STORAGE_NO_SAVE, dev_led_id, direction);
+                    report                  = razer_create_mode_wave_standard_matrix_report(storage_mode, dev_led_id, direction);
                     razer_usb_send(&report);
                     break;
             }

Controllers/RazerController/RazerController.h

@@ -234,13 +234,13 @@ public:
     void                    SetLEDs(RGBColor* colors);
     void                    SetAddressableZoneSizes(unsigned char zone_1_size, unsigned char zone_2_size, unsigned char zone_3_size, unsigned char zone_4_size, unsigned char zone_5_size, unsigned char zone_6_size);
 
-    void                    SetModeBreathingRandom();
+    void                    SetModeBreathingRandom(bool save = false);
-    void                    SetModeBreathingOneColor(unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SetModeBreathingOneColor(unsigned char red, unsigned char grn, unsigned char blu, bool save = false);
-    void                    SetModeBreathingTwoColors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2);
+    void                    SetModeBreathingTwoColors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2, bool save = false);
-    void                    SetModeOff();
+    void                    SetModeOff(bool save = false);
-    void                    SetModeSpectrumCycle();
+    void                    SetModeSpectrumCycle(bool save = false);
-    void                    SetModeStatic(unsigned char red, unsigned char grn, unsigned char blu);
+    void                    SetModeStatic(unsigned char red, unsigned char grn, unsigned char blu, bool save = false);
-    void                    SetModeWave(unsigned char direction);
+    void                    SetModeWave(unsigned char direction, bool save = false);
 
     bool                    SupportsBreathing();
     bool                    SupportsReactive();
@@ -325,14 +325,14 @@ private:
 
     void                    razer_set_device_mode(unsigned char device_mode);
 
-    void                    razer_set_mode_breathing_random();
+    void                    razer_set_mode_breathing_random(bool save);
-    void                    razer_set_mode_breathing_one_color(unsigned char red, unsigned char grn, unsigned char blu);
+    void                    razer_set_mode_breathing_one_color(unsigned char red, unsigned char grn, unsigned char blu, bool save);
-    void                    razer_set_mode_breathing_two_colors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2);
+    void                    razer_set_mode_breathing_two_colors(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2, bool save);
     void                    razer_set_mode_custom();
-    void                    razer_set_mode_none();
+    void                    razer_set_mode_none(bool save);
-    void                    razer_set_mode_spectrum_cycle();
+    void                    razer_set_mode_spectrum_cycle(bool save);
-    void                    razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu);
+    void                    razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu, bool save);
-    void                    razer_set_mode_wave(unsigned char direction);
+    void                    razer_set_mode_wave(unsigned char direction, bool save);
 
     int                     razer_usb_receive(razer_report* report);
     int                     razer_usb_send(razer_report* report);