Refactor the sleep suppress. Rearrange some options.

Author: Mysticial

SerialPrograms/Source/CommonFramework/Environment/SystemSleep.cpp

@@ -13,12 +13,10 @@
 #include "SystemSleep_Apple.tpp"
 #else
 namespace PokemonAutomation{
-    SystemSleepController(){}
-    ~SystemSleepController(){}
-    void push_screen_on(){}
-    void pop_screen_on(){}
-    void push_no_sleep(){}
-    void pop_no_sleep(){}
+    SystemSleepController& SystemSleepController::instance(){
+        static SystemSleepController controller;
+        return controller;
+    }
 }
 #endif
 

SerialPrograms/Source/CommonFramework/Environment/SystemSleep.h

@@ -26,31 +26,25 @@ namespace PokemonAutomation{
 //  Useful for running some programs like PokemonSV_VideoFastCodeEntry that require
 //  the screen to be constantly on.
 class SystemSleepController{
-    SystemSleepController();
-    ~SystemSleepController();
+protected:
+    virtual ~SystemSleepController() = default;
+    SystemSleepController() = default;
 
 public:
-    static SystemSleepController& instance(){
-        static SystemSleepController controller;
-        return controller;
-    }
+    static SystemSleepController& instance();
 
     //  Push: Add a request for this type of sleep-disable.
     //  Pop: Remove a request for this type of sleep-disable.
     //  The sleep-disable will be active as long as there is at least one
     //  request is active for that type.
 
     //  Keep the screen on and prevent sleep.
-    void push_screen_on();
-    void pop_screen_on();
+    virtual void push_screen_on(){}
+    virtual void pop_screen_on(){}
 
     //  Allow the screen to turn off, but don't sleep.
-    void push_no_sleep();
-    void pop_no_sleep();
-
-private:
-    struct InternalController;
-    std::unique_ptr<InternalController> m_data;
+    virtual void push_no_sleep(){}
+    virtual void pop_no_sleep(){}
 };
 
 

SerialPrograms/Source/CommonFramework/Environment/SystemSleep_Apple.tpp

@@ -14,49 +14,66 @@ namespace PokemonAutomation{
 
 
 
-struct SystemSleepController::InternalController{
-//public:
-    InternalController();
-    ~InternalController();
+class AppleSleepController : public SystemSleepController{
+public:
+    virtual ~AppleSleepController(){
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests = 0;
+        m_no_sleep_requests = 0;
+        update_state();
+    }
+    virtual void push_screen_on() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests++;
+        update_state();
+    }
+    virtual void pop_screen_on() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests--;
+        update_state();
+    }
+    virtual void push_no_sleep() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_no_sleep_requests++;
+        update_state();
+    }
+    virtual void pop_no_sleep() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_no_sleep_requests--;
+        update_state();
+    }
 
+
+private:
     //  Disable/Enable screen saver and OS sleep.
     //  Return whether the setting is successful.
     bool prevent_sleep(bool prevent);
-
     void update_state();
 
-//private:
     bool disable_sleep();
     bool enable_sleep();
 
-    IOReturn m_prevention_succeeded;
-    IOPMAssertionID m_session_id;
+    IOReturn m_prevention_succeeded = kIOReturnError;
+    IOPMAssertionID m_session_id = 0;
 
-
-    std::mutex lock;
-    size_t screen_on_requests = 0;
-    size_t no_sleep_requests = 0;
+    std::mutex m_lock;
+    size_t m_screen_on_requests = 0;
+    size_t m_no_sleep_requests = 0;
 };
 
 
 // Code from https://stackoverflow.com/questions/5596319/how-to-programmatically-prevent-a-mac-from-going-to-sleep/8461182#8461182
 
-SystemSleepController::InternalController::InternalController()
-    : m_prevention_succeeded(kIOReturnError), m_session_id(0) {}
 
-SystemSleepController::InternalController::~InternalController(){
-    enable_sleep();
-}
-
-bool SystemSleepController::InternalController::prevent_sleep(bool prevent){
+bool AppleSleepController::prevent_sleep(bool prevent){
     if (prevent){
         return disable_sleep();
     }else{
         return enable_sleep();
     }
 }
 
-bool SystemSleepController::InternalController::disable_sleep(){
+bool AppleSleepController::disable_sleep(){
     if (m_prevention_succeeded == kIOReturnSuccess){
         return true;
     }
@@ -81,7 +98,7 @@ bool SystemSleepController::InternalController::disable_sleep(){
     return true;
 }
 
-bool SystemSleepController::InternalController::enable_sleep(){
+bool AppleSleepController::enable_sleep(){
     if (m_prevention_succeeded == kIOReturnSuccess){
         IOPMAssertionRelease(m_session_id);
         m_session_id = 0;
@@ -93,47 +110,16 @@ bool SystemSleepController::InternalController::enable_sleep(){
 
 
 
-void SystemSleepController::InternalController::update_state(){
+void AppleSleepController::update_state(){
     //  Must call under lock.
 
     //  TODO: Distiguish these two.
-    prevent_sleep(screen_on_requests > 0 || no_sleep_requests > 0);
+    prevent_sleep(m_screen_on_requests > 0 || m_no_sleep_requests > 0);
 }
 
 
 
 
-SystemSleepController::SystemSleepController()
-    : m_data(new InternalController())
-{}
-SystemSleepController::~SystemSleepController(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests = 0;
-    m_data->no_sleep_requests = 0;
-    m_data->update_state();
-}
-void SystemSleepController::push_screen_on(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests++;
-    m_data->update_state();
-}
-void SystemSleepController::pop_screen_on(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests--;
-    m_data->update_state();
-}
-void SystemSleepController::push_no_sleep(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->no_sleep_requests++;
-    m_data->update_state();
-}
-void SystemSleepController::pop_no_sleep(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->no_sleep_requests--;
-    m_data->update_state();
-}
-
-
 
 
 

SerialPrograms/Source/CommonFramework/Environment/SystemSleep_Windows.tpp

@@ -13,17 +13,42 @@
 namespace PokemonAutomation{
 
 
-struct SystemSleepController::InternalController{
-    std::mutex lock;
-    size_t screen_on_requests = 0;
-    size_t no_sleep_requests = 0;
+class WindowsSleepController : public SystemSleepController{
+public:
+    virtual ~WindowsSleepController(){
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests = 0;
+        m_no_sleep_requests = 0;
+        update_state();
+    }
+    virtual void push_screen_on() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests++;
+        update_state();
+    }
+    virtual void pop_screen_on() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_screen_on_requests--;
+        update_state();
+    }
+    virtual void push_no_sleep() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_no_sleep_requests++;
+        update_state();
+    }
+    virtual void pop_no_sleep() override{
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_no_sleep_requests--;
+        update_state();
+    }
 
+private:
     void update_state(){
         //  SetThreadExecutionState(ES_CONTINUOUS) only lasts as long as the
         //  thread is alive. So we redispatch to the main thread.
         queue_on_main_thread([
-            screen_on_requests = screen_on_requests,
-            no_sleep_requests = no_sleep_requests
+            screen_on_requests = m_screen_on_requests,
+            no_sleep_requests = m_no_sleep_requests
         ]{
             EXECUTION_STATE flags = ES_CONTINUOUS;
             if (screen_on_requests > 0){
@@ -44,42 +69,22 @@ struct SystemSleepController::InternalController{
             }
         });
     }
-};
 
+private:
+    std::mutex m_lock;
+    size_t m_screen_on_requests = 0;
+    size_t m_no_sleep_requests = 0;
+};
 
 
-SystemSleepController::SystemSleepController()
-    : m_data(new InternalController())
-{}
-SystemSleepController::~SystemSleepController(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests = 0;
-    m_data->no_sleep_requests = 0;
-    m_data->update_state();
-}
-void SystemSleepController::push_screen_on(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests++;
-    m_data->update_state();
-}
-void SystemSleepController::pop_screen_on(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->screen_on_requests--;
-    m_data->update_state();
-}
-void SystemSleepController::push_no_sleep(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->no_sleep_requests++;
-    m_data->update_state();
-}
-void SystemSleepController::pop_no_sleep(){
-    std::lock_guard<std::mutex> lg(m_data->lock);
-    m_data->no_sleep_requests--;
-    m_data->update_state();
+SystemSleepController& SystemSleepController::instance(){
+    static WindowsSleepController controller;
+    return controller;
 }
 
 
 
 
 
+
 }

SerialPrograms/Source/CommonFramework/GlobalSettingsPanel.cpp

@@ -100,6 +100,11 @@ GlobalSettings::~GlobalSettings(){
 }
 GlobalSettings::GlobalSettings()
     : BatchOption(LockMode::LOCK_WHILE_RUNNING)
+    , CHECK_FOR_UPDATES(
+        "<b>Check for Updates:</b><br>Automatically check for updates.",
+        LockMode::UNLOCK_WHILE_RUNNING,
+        true
+    )
     , SEND_ERROR_REPORTS(
         "<b>Send Error Reports:</b><br>"
         "Send error reports to the " + PROGRAM_NAME + " server to help them resolve issues and improve the program.",
@@ -118,11 +123,6 @@ GlobalSettings::GlobalSettings()
         LockMode::UNLOCK_WHILE_RUNNING,
         true
     )
-    , CHECK_FOR_UPDATES(
-        "<b>Check for Updates:</b><br>Automatically check for updates.",
-        LockMode::UNLOCK_WHILE_RUNNING,
-        true
-    )
     , WINDOW_SIZE(
         "Window Size:",
         "Set the size of the window. Takes effect immediately.<br>"
@@ -231,10 +231,10 @@ GlobalSettings::GlobalSettings()
         "", ""
     )
 {
+    PA_ADD_OPTION(CHECK_FOR_UPDATES);
     PA_ADD_OPTION(SEND_ERROR_REPORTS);
     PA_ADD_OPTION(STATS_FILE);
     PA_ADD_OPTION(ALL_STATS);
-    PA_ADD_OPTION(CHECK_FOR_UPDATES);
     PA_ADD_OPTION(WINDOW_SIZE);
     PA_ADD_OPTION(THEME);
 #ifdef PA_ENABLE_SLEEP_SUPPRESS

SerialPrograms/Source/CommonFramework/GlobalSettingsPanel.h

@@ -82,11 +82,11 @@ class GlobalSettings : public BatchOption, private ConfigOption::Listener{
     virtual void value_changed(void* object) override;
 
 public:
+    BooleanCheckBoxOption CHECK_FOR_UPDATES;
     BooleanCheckBoxOption SEND_ERROR_REPORTS;
 
     StringOption STATS_FILE;
     BooleanCheckBoxOption ALL_STATS;
-    BooleanCheckBoxOption CHECK_FOR_UPDATES;
 
     ResolutionOption WINDOW_SIZE;
     ThemeSelectorOption THEME;

SerialPrograms/Source/CommonFramework/Options/Environment/SleepSuppressOption.cpp

@@ -31,7 +31,7 @@ SleepSuppressOptions::~SleepSuppressOptions(){
 }
 SleepSuppressOptions::SleepSuppressOptions()
     : GroupOption(
-        "Suppress Screensaver/Sleep",
+        "Suppress Screensaver/Sleep:",
         LockMode::UNLOCK_WHILE_RUNNING,
         false, true
     )