FIX: debounce app_config->save() in wxEVT_IDLE handler (F-015)

The idle handler fired app_config->save() on every dirty idle event.
On a busy loop this produces dozens of synchronous disk writes per second.

Add a 5-second rate limit via debounce_elapsed() (Debounce.hpp, pure C++,
no wx dependency). OnExit() flushes any remaining dirty state so no
settings are lost on clean shutdown.

Extract debounce_elapsed() to src/libslic3r/Debounce.hpp and add
tests/libslic3r/test_debounce.cpp with 5 Catch2 scenarios covering
first-call, suppression, expiry, zero-interval, and no-mutation-on-suppress.
All tests passed (7 assertions in 5 test cases).

Ref: #10289

Author: tinezivic

src/libslic3r/Debounce.hpp

@@ -0,0 +1,39 @@
+///|/ Copyright (c) Prusa Research 2023 Vojtěch Bubník @bubnikv
+///|/
+///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
+///|/
+#ifndef slic3r_Debounce_hpp_
+#define slic3r_Debounce_hpp_
+
+#include <chrono>
+
+namespace Slic3r {
+
+// Rate-limit a recurring action.
+//
+// Returns true and updates `last_tp` when at least `interval` has elapsed
+// since the last accepted call.  On the very first call (last_tp ==
+// time_point{}) the action is always accepted.
+//
+// Usage:
+//   static auto s_last = std::chrono::steady_clock::time_point{};
+//   if (debounce_elapsed(s_last, std::chrono::seconds(5)))
+//       do_expensive_thing();
+//
+// The function is intentionally free of wx / GUI dependencies so it can be
+// exercised by the plain libslic3r unit-test suite.
+inline bool debounce_elapsed(
+    std::chrono::steady_clock::time_point &last_tp,
+    std::chrono::steady_clock::duration    interval)
+{
+    const auto now = std::chrono::steady_clock::now();
+    if (now - last_tp >= interval) {
+        last_tp = now;
+        return true;
+    }
+    return false;
+}
+
+} // namespace Slic3r
+
+#endif // slic3r_Debounce_hpp_

src/slic3r/GUI/GUI_App.cpp

@@ -21,6 +21,7 @@
 #include <iterator>
 #include <exception>
 #include <cstdlib>
+#include <chrono>
 #include <regex>
 #include <thread>
 #include <string_view>
@@ -55,6 +56,7 @@
 #include <wx/glcanvas.h>
 
 #include "libslic3r/Utils.hpp"
+#include "libslic3r/Debounce.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/I18N.hpp"
 #include "libslic3r/LogSink.hpp"
@@ -2774,6 +2776,10 @@ int GUI_App::OnExit()
         m_agent = nullptr;
     }
 
+    // Flush any config changes that were deferred by the idle-handler debounce.
+    if (app_config && app_config->dirty())
+        app_config->save();
+
     return wxApp::OnExit();
 }
 
@@ -3314,8 +3320,13 @@ bool GUI_App::on_init_inner()
         if (! plater_)
             return;
 
-        if (app_config->dirty())
-            app_config->save();
+        if (app_config->dirty()) {
+            // Debounce: avoid synchronous disk writes on every idle event.
+            // Save at most once per 5 seconds; OnExit() flushes any remaining dirty state.
+            static auto s_last_config_save = std::chrono::steady_clock::time_point{};
+            if (Slic3r::debounce_elapsed(s_last_config_save, std::chrono::seconds(5)))
+                app_config->save();
+        }
 
         // BBS
         //this->obj_manipul()->update_if_dirty();

tests/libslic3r/CMakeLists.txt

@@ -22,6 +22,7 @@ add_executable(${_TEST_NAME}_tests
     test_png_io.cpp
     test_timeutils.cpp
     test_indexed_triangle_set.cpp
+    test_debounce.cpp
     ../libnest2d/printer_parts.cpp
 	)
 

tests/libslic3r/test_debounce.cpp

@@ -0,0 +1,83 @@
+#include <catch2/catch.hpp>
+
+#include "libslic3r/Debounce.hpp"
+
+#include <thread>
+
+using namespace Slic3r;
+using namespace std::chrono;
+
+// ---------------------------------------------------------------------------
+// debounce_elapsed() — unit tests
+// ---------------------------------------------------------------------------
+
+SCENARIO("debounce_elapsed: first call always fires", "[Debounce]") {
+    GIVEN("A default-initialised time_point (epoch)") {
+        steady_clock::time_point last{};
+        WHEN("debounce_elapsed is called with a 5-second interval") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+            THEN("last_tp is updated to a non-epoch value") {
+                REQUIRE(last != steady_clock::time_point{});
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: second immediate call is suppressed", "[Debounce]") {
+    GIVEN("A time_point primed by a first accepted call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(5)); // prime
+        WHEN("debounce_elapsed is called again immediately") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns false") {
+                REQUIRE_FALSE(fired);
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: call fires again after interval expires", "[Debounce]") {
+    GIVEN("A time_point set to 10 seconds in the past") {
+        // Simulate 'last' being 10 seconds old without sleeping.
+        steady_clock::time_point last = steady_clock::now() - seconds(10);
+        WHEN("debounce_elapsed is called with a 5-second interval") {
+            const bool fired = debounce_elapsed(last, seconds(5));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+            THEN("last_tp is updated") {
+                REQUIRE(last >= steady_clock::now() - milliseconds(100));
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: zero interval fires every time", "[Debounce]") {
+    GIVEN("A time_point primed by a first call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(0));
+        WHEN("debounce_elapsed is called immediately again with zero interval") {
+            const bool fired = debounce_elapsed(last, seconds(0));
+            THEN("It returns true") {
+                REQUIRE(fired);
+            }
+        }
+    }
+}
+
+SCENARIO("debounce_elapsed: last_tp is not modified on suppressed calls", "[Debounce]") {
+    GIVEN("A time_point primed by a first accepted call") {
+        steady_clock::time_point last{};
+        debounce_elapsed(last, seconds(5));
+        const auto snapshot = last;
+        WHEN("A suppressed call is made") {
+            debounce_elapsed(last, seconds(5));
+            THEN("last_tp is unchanged") {
+                REQUIRE(last == snapshot);
+            }
+        }
+    }
+}