Added parameter to configure fullscreen detection

Signed-off-by: Alexis Maiquez <almamu@almamu.com>

src/WallpaperEngine/Application/CApplicationContext.cpp

@@ -26,6 +26,7 @@ struct option long_options[] = {
     { "list-properties", no_argument,    nullptr, 'l' },
     { "set-property", required_argument, nullptr, 'o' },
     { "noautomute", no_argument,         nullptr, 'm' },
+    { "no-fullscreen-pause", no_argument,nullptr, 'n' },
     { nullptr, 0,                        nullptr, 0 }
 };
 
@@ -62,6 +63,7 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
         {
             .mode = NORMAL_WINDOW,
             .maximumFPS = 30,
+            .pauseOnFullscreen = true,
             .window = { .geometry = {}},
         },
         .audio =
@@ -82,105 +84,110 @@ CApplicationContext::CApplicationContext (int argc, char* argv[])
 
     std::string lastScreen;
 
-    while ((c = getopt_long (argc, argv, "b:r:p:d:shf:a:w:m", long_options, nullptr)) != -1)
+    while ((c = getopt_long (argc, argv, "b:r:p:d:shf:a:w:mn", long_options, nullptr)) != -1)
     {
         switch (c)
         {
-        case 'b':
+            case 'n':
-            if (lastScreen.empty ())
+                this->settings.render.pauseOnFullscreen = false;
-                sLog.exception ("--bg has to go after a --screen-root argument");
+                break;
 
-            // no need to check for previous screen being in the list, as it's the only way for this variable
+            case 'b':
-            // to have any value
+                if (lastScreen.empty ())
-            this->settings.general.screenBackgrounds[lastScreen] = translateBackground (optarg);
+                    sLog.exception ("--bg has to go after a --screen-root argument");
-            break;
 
-        case 'o':
+                // no need to check for previous screen being in the list, as it's the only way for this variable
-        {
+                // to have any value
-            std::string value = optarg;
+                this->settings.general.screenBackgrounds[lastScreen] = translateBackground (optarg);
-            std::string::size_type equals = value.find ('=');
+                break;
 
-            // properties without value are treated as booleans for now
+            case 'o':
-            if (equals == std::string::npos)
+                {
-                this->settings.general.properties[value] = "1";
+                    std::string value = optarg;
-            else
+                    std::string::size_type equals = value.find ('=');
-                this->settings.general.properties[value.substr (0, equals)] = value.substr (equals + 1);
-        }
-            break;
 
-        case 'l':
+                    // properties without value are treated as booleans for now
-            this->settings.general.onlyListProperties = true;
+                    if (equals == std::string::npos)
-            break;
+                        this->settings.general.properties[value] = "1";
+                    else
+                        this->settings.general.properties[value.substr (0, equals)] = value.substr (equals + 1);
+                }
+                break;
 
-        case 'r':
+            case 'l':
-            if (this->settings.general.screenBackgrounds.find (optarg) != this->settings.general.screenBackgrounds.end ())
+                this->settings.general.onlyListProperties = true;
-                sLog.exception ("Cannot specify the same screen more than once: ", optarg);
+                break;
-            if (this->settings.render.mode == EXPLICIT_WINDOW)
-                sLog.exception ("Cannot run in both background and window mode");
 
-            this->settings.render.mode = X11_BACKGROUND;
+            case 'r':
-            lastScreen = optarg;
+                if (this->settings.general.screenBackgrounds.find (optarg) != this->settings.general.screenBackgrounds.end ())
-            this->settings.general.screenBackgrounds[lastScreen] = "";
+                    sLog.exception ("Cannot specify the same screen more than once: ", optarg);
-            break;
+                if (this->settings.render.mode == EXPLICIT_WINDOW)
+                    sLog.exception ("Cannot run in both background and window mode");
 
-        case 'w':
+                this->settings.render.mode = X11_BACKGROUND;
-            if (this->settings.render.mode == X11_BACKGROUND)
+                lastScreen = optarg;
-                sLog.exception ("Cannot run in both background and window mode");
+                this->settings.general.screenBackgrounds[lastScreen] = "";
+                break;
 
-            if (optarg != nullptr)
+            case 'w':
-            {
+                if (this->settings.render.mode == X11_BACKGROUND)
-                this->settings.render.mode = EXPLICIT_WINDOW;
+                    sLog.exception ("Cannot run in both background and window mode");
-                // read window geometry
-                char* pos = optarg;
 
-                if (pos != nullptr)
+                if (optarg != nullptr)
-                    this->settings.render.window.geometry.x = atoi (pos);
+                {
-                if ((pos = strchr (pos, 'x')) != nullptr)
+                    this->settings.render.mode = EXPLICIT_WINDOW;
-                    this->settings.render.window.geometry.y = atoi (pos + 1);
+                    // read window geometry
-                if ((pos = strchr (pos + 1, 'x')) != nullptr)
+                    char* pos = optarg;
-                    this->settings.render.window.geometry.z = atoi (pos + 1);
-                if ((pos = strchr (pos + 1, 'x')) != nullptr)
-                    this->settings.render.window.geometry.w = atoi (pos + 1);
-            }
-            break;
 
-        case 'p':
+                    if (pos != nullptr)
-        case 'd':
+                        this->settings.render.window.geometry.x = atoi (pos);
-            sLog.error ("--dir/--pkg is deprecated and not used anymore");
+                    if ((pos = strchr (pos, 'x')) != nullptr)
-            this->settings.general.defaultBackground = translateBackground (stringPathFixes (optarg));
+                        this->settings.render.window.geometry.y = atoi (pos + 1);
-            break;
+                    if ((pos = strchr (pos + 1, 'x')) != nullptr)
+                        this->settings.render.window.geometry.z = atoi (pos + 1);
+                    if ((pos = strchr (pos + 1, 'x')) != nullptr)
+                        this->settings.render.window.geometry.w = atoi (pos + 1);
+                }
+                break;
 
-        case 's':
+            case 'p':
-            this->settings.audio.enabled = false;
+            case 'd':
-            break;
+                sLog.error ("--dir/--pkg is deprecated and not used anymore");
+                this->settings.general.defaultBackground = translateBackground (stringPathFixes (optarg));
+                break;
 
-        case 'h':
+            case 's':
-            printHelp (argv[0]);
+                this->settings.audio.enabled = false;
-            break;
+                break;
 
-        case 'f':
+            case 'h':
-            this->settings.render.maximumFPS = atoi (optarg);
+                printHelp (argv[0]);
-            break;
+                break;
 
-        case 'a':
+            case 'f':
-            this->settings.general.assets = stringPathFixes (optarg);
+                this->settings.render.maximumFPS = atoi (optarg);
-            break;
+                break;
 
-        case 'v':
+            case 'a':
-            this->settings.audio.volume = std::max (atoi (optarg), 128);
+                this->settings.general.assets = stringPathFixes (optarg);
-            break;
+                break;
 
-        case 'c':
+            case 'v':
-            this->settings.screenshot.take = true;
+                this->settings.audio.volume = std::max (atoi (optarg), 128);
-            this->settings.screenshot.path = stringPathFixes (optarg);
+                break;
-            break;
 
-        case 'm':
+            case 'c':
-            this->settings.audio.automute = false;
+                this->settings.screenshot.take = true;
-            break;
+                this->settings.screenshot.path = stringPathFixes (optarg);
-        default:
+                break;
-            sLog.out ("Default on path parsing: ", optarg);
+
-            break;
+            case 'm':
+                this->settings.audio.automute = false;
+                break;
+
+            default:
+                sLog.out ("Default on path parsing: ", optarg);
+                break;
         }
     }
 
@@ -272,4 +279,5 @@ void CApplicationContext::printHelp (const char* route)
     sLog.out ("\t--screenshot\t\t\t\tTakes a screenshot of the background");
     sLog.out ("\t--list-properties\t\t\tList all the available properties and their possible values");
     sLog.out ("\t--set-property <name=value>\tOverrides the default value of the given property");
+    sLog.out ("\t--no-fullscreen-pause\tPrevents the background pausing when an app is fullscreen");
 }

src/WallpaperEngine/Application/CApplicationContext.h

@@ -61,6 +61,8 @@ namespace WallpaperEngine::Application
                 WINDOW_MODE mode;
                 /** Maximum FPS */
                 int maximumFPS;
+                /** Indicates if pausing should happen when something goes fullscreen */
+                bool pauseOnFullscreen;
 
                 struct
                 {

src/WallpaperEngine/Application/CWallpaperApplication.cpp

@@ -273,7 +273,7 @@ namespace WallpaperEngine::Application
         // output requested
         WallpaperEngine::Render::Drivers::Output::COutput* output;
         // fullscreen detector is common for the different render modes
-        WallpaperEngine::Render::Drivers::Detectors::CX11FullScreenDetector fullscreenDetector (videoDriver);
+        WallpaperEngine::Render::Drivers::Detectors::CX11FullScreenDetector fullscreenDetector (this->m_context, videoDriver);
         // stereo mix recorder for audio processing
         WallpaperEngine::Audio::Drivers::Recorders::CPulseAudioPlaybackRecorder audioRecorder;
         // audio playing detector

src/WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.cpp

@@ -1 +1,14 @@
 #include "CFullScreenDetector.h"
+
+using namespace WallpaperEngine;
+using namespace WallpaperEngine::Render::Drivers::Detectors;
+
+CFullScreenDetector::CFullScreenDetector (Application::CApplicationContext& appContext) :
+    m_applicationContext (appContext)
+{
+}
+
+Application::CApplicationContext& CFullScreenDetector::getApplicationContext () const
+{
+    return this->m_applicationContext;
+}

src/WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h

@@ -1,10 +1,14 @@
 #pragma once
 
+#include "WallpaperEngine/Application/CApplicationContext.h"
+
 namespace WallpaperEngine::Render::Drivers::Detectors
 {
     class CFullScreenDetector
     {
     public:
+        CFullScreenDetector (Application::CApplicationContext& appContext);
+
         /**
          * @return If anything is fullscreen
          */
@@ -14,5 +18,12 @@ namespace WallpaperEngine::Render::Drivers::Detectors
          * Restarts the fullscreen detector, specially useful if there's any resources tied to the output driver
          */
         virtual void reset () = 0;
+        /**
+         * @return The application context using this detector
+         */
+        [[nodiscard]] Application::CApplicationContext& getApplicationContext () const;
+
+    private:
+        Application::CApplicationContext& m_applicationContext;
     };
 }

src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp

@@ -31,7 +31,8 @@ namespace WallpaperEngine::Render::Drivers::Detectors
         return 0;
     }
 
-    CX11FullScreenDetector::CX11FullScreenDetector (CVideoDriver& driver) :
+    CX11FullScreenDetector::CX11FullScreenDetector (Application::CApplicationContext& appContext, CVideoDriver& driver) :
+        CFullScreenDetector (appContext),
         m_driver (driver)
     {
         // do not use previous handler, it might stop the app under weird circumstances
@@ -51,6 +52,9 @@ namespace WallpaperEngine::Render::Drivers::Detectors
 
     bool CX11FullScreenDetector::anythingFullscreen () const
     {
+        if (!this->getApplicationContext ().settings.render.pauseOnFullscreen)
+            return false;
+
         // stop rendering if anything is fullscreen
         bool isFullscreen = false;
         XWindowAttributes attribs;

src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h

@@ -11,10 +11,10 @@
 
 namespace WallpaperEngine::Render::Drivers::Detectors
 {
-    class CX11FullScreenDetector : public  CFullScreenDetector
+    class CX11FullScreenDetector : public CFullScreenDetector
     {
     public:
-        CX11FullScreenDetector (CVideoDriver& driver);
+        CX11FullScreenDetector (Application::CApplicationContext& appContext, CVideoDriver& driver);
         ~CX11FullScreenDetector ();
 
         [[nodiscard]] bool anythingFullscreen () const override;