Enable non-resizable windows (SDL2 only)

Add a hidden setting to control whether the window is resizable.

Fixes #1512

Author: falbrechtskirchinger

extras/videoDrivers/SDL2/VideoSDL2.cpp

@@ -132,7 +132,7 @@ void VideoSDL2::UpdateCurrentSizes()
     SetNewSize(VideoMode(w, h), Extent(w2, h2));
 }
 
-bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, bool fullscreen)
+bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, DisplayMode displayMode)
 {
     if(!initialized)
         return false;
@@ -155,16 +155,18 @@ bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, bo
     CHECK_SDL(SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8));
     CHECK_SDL(SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1));
 
-    int wndPos = SDL_WINDOWPOS_CENTERED;
-
+    const int wndPos = SDL_WINDOWPOS_CENTERED;
+    const auto fullscreen = (displayMode & DisplayMode::Fullscreen) != DisplayMode::None;
+    const auto resizable = (displayMode & DisplayMode::Resizable) != DisplayMode::None;
     const auto requestedSize = fullscreen ? FindClosestVideoMode(size) : size;
-    unsigned commonFlags = SDL_WINDOW_OPENGL;
+    const unsigned commonFlags = SDL_WINDOW_OPENGL | (resizable ? SDL_WINDOW_RESIZABLE : 0);
+    const unsigned fullscreenFlag = (fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
     // TODO: Fix GUI scaling with High DPI support enabled.
     // See https://github.com/Return-To-The-Roots/s25client/issues/1621
     // commonFlags |= SDL_WINDOW_ALLOW_HIGHDPI;
 
     window = SDL_CreateWindow(title.c_str(), wndPos, wndPos, requestedSize.width, requestedSize.height,
-                              commonFlags | (fullscreen ? SDL_WINDOW_FULLSCREEN : SDL_WINDOW_RESIZABLE));
+                              commonFlags | fullscreenFlag);
 
     // Fallback to non-fullscreen
     if(!window && fullscreen)
@@ -179,10 +181,12 @@ bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, bo
         return false;
     }
 
-    isFullscreen_ = (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0;
+    const auto flags = SDL_GetWindowFlags(window);
+    SetFullscreenFlag((flags & SDL_WINDOW_FULLSCREEN) != 0);
+    SetResizableFlag((flags & SDL_WINDOW_RESIZABLE) != 0);
     UpdateCurrentSizes();
 
-    if(!isFullscreen_)
+    if(!IsFullscreen())
         MoveWindowToCenter();
 
     SDL_Surface* iconSurf =
@@ -207,25 +211,32 @@ bool VideoSDL2::CreateScreen(const std::string& title, const VideoMode& size, bo
     return true;
 }
 
-bool VideoSDL2::ResizeScreen(const VideoMode& newSize, bool fullscreen)
+bool VideoSDL2::ResizeScreen(const VideoMode& newSize, DisplayMode displayMode)
 {
     if(!initialized)
         return false;
 
-    if(isFullscreen_ != fullscreen)
+    const auto fullscreen = (displayMode & DisplayMode::Fullscreen) != DisplayMode::None;
+    const auto resizable = (displayMode & DisplayMode::Resizable) != DisplayMode::None;
+
+    if(IsFullscreen() != fullscreen)
     {
         SDL_SetWindowFullscreen(window, fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
-        isFullscreen_ = (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0;
-        if(!isFullscreen_)
-        {
-            SDL_SetWindowResizable(window, SDL_TRUE);
+        SetFullscreenFlag((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0);
+        if(!IsFullscreen())
             MoveWindowToCenter();
-        }
+    }
+
+    if(displayMode_ != displayMode)
+    {
+        if(!IsFullscreen())
+            SDL_SetWindowResizable(window, static_cast<SDL_bool>(resizable));
+        SetResizableFlag((SDL_GetWindowFlags(window) & SDL_WINDOW_RESIZABLE) != 0);
     }
 
     if(newSize != GetWindowSize())
     {
-        if(isFullscreen_)
+        if(IsFullscreen())
         {
             auto const targetMode = FindClosestVideoMode(newSize);
             SDL_DisplayMode target;
@@ -247,6 +258,7 @@ bool VideoSDL2::ResizeScreen(const VideoMode& newSize, bool fullscreen)
         }
         UpdateCurrentSizes();
     }
+
     return true;
 }
 
@@ -308,7 +320,7 @@ bool VideoSDL2::MessageLoop()
                 {
                     case SDL_WINDOWEVENT_RESIZED:
                     {
-                        isFullscreen_ = (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0;
+                        SetFullscreenFlag((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0);
                         VideoMode newSize(ev.window.data1, ev.window.data2);
                         if(newSize != GetWindowSize())
                         {

extras/videoDrivers/SDL2/VideoSDL2.h

@@ -24,8 +24,8 @@ class VideoSDL2 final : public VideoDriver
 
     bool Initialize() override;
 
-    bool CreateScreen(const std::string& title, const VideoMode& size, bool fullscreen) override;
-    bool ResizeScreen(const VideoMode& newSize, bool fullscreen) override;
+    bool CreateScreen(const std::string& title, const VideoMode& size, DisplayMode displayMode) override;
+    bool ResizeScreen(const VideoMode& newSize, DisplayMode displayMode) override;
 
     void DestroyScreen() override;
 

extras/videoDrivers/WinAPI/WinAPI.cpp

@@ -139,26 +139,25 @@ void VideoWinAPI::CleanUp()
 /**
  *  Erstellt das Fenster mit entsprechenden Werten.
  *
- *  @param[in] width      Breite des Fensters
- *  @param[in] height     Höhe des Fensters
- *  @param[in] fullscreen Vollbildmodus ja oder nein
+ *  @param[in] width       Breite des Fensters
+ *  @param[in] height      Höhe des Fensters
+ *  @param[in] displayMode Fullscreen on/off, window resizable?
  *
  *  @return @p true bei Erfolg, @p false bei Fehler
  *
  *  @bug Hardwarecursor ist bei Fenstermodus sichtbar,
  *       Cursor deaktivieren ist fehlerhaft
  */
-bool VideoWinAPI::CreateScreen(const std::string& title, const VideoMode& newSize, bool fullscreen)
+bool VideoWinAPI::CreateScreen(const std::string& title, const VideoMode& newSize, DisplayMode displayMode)
 {
     if(!initialized)
         return false;
 
-    if(!RegisterAndCreateWindow(title, newSize, fullscreen))
+    if(!RegisterAndCreateWindow(title, newSize, displayMode))
         return false;
 
-    if(fullscreen && !MakeFullscreen(GetWindowSize()))
+    if(bitset::isSet(displayMode, DisplayMode::Fullscreen) && !MakeFullscreen(GetWindowSize()))
         return false;
-    isFullscreen_ = fullscreen;
 
     if(!InitOGL())
         return false;
@@ -184,30 +183,31 @@ bool VideoWinAPI::CreateScreen(const std::string& title, const VideoMode& newSiz
  *
  *  @todo Vollbildmodus ggf. wechseln
  */
-bool VideoWinAPI::ResizeScreen(const VideoMode& newSize, bool fullscreen)
+bool VideoWinAPI::ResizeScreen(const VideoMode& newSize, DisplayMode displayMode)
 {
     if(!initialized || !isWindowResizable)
         return false;
 
-    if(isFullscreen_ == fullscreen && newSize == GetWindowSize())
+    const auto fullscreen = bitset::isSet(displayMode, DisplayMode::Fullscreen);
+    if(IsFullscreen() == fullscreen && newSize == GetWindowSize())
         return true;
 
     ShowWindow(screen, SW_HIDE);
 
     VideoMode windowSize = fullscreen ? FindClosestVideoMode(newSize) : newSize;
     // Try to switch full screen first
-    if(isFullscreen_ && !fullscreen)
+    if(IsFullscreen() && !fullscreen)
     {
         if(ChangeDisplaySettings(nullptr, 0) != DISP_CHANGE_SUCCESSFUL)
             return false;
-    } else if(isFullscreen_ || fullscreen)
+    } else if(IsFullscreen() || fullscreen)
     {
         if(!MakeFullscreen(windowSize))
             return false;
     }
 
     // Fensterstyle ggf. ändern
-    std::pair<DWORD, DWORD> style = GetStyleFlags(isFullscreen_);
+    std::pair<DWORD, DWORD> style = GetStyleFlags(IsFullscreen());
     SetWindowLongPtr(screen, GWL_STYLE, style.first);
     SetWindowLongPtr(screen, GWL_EXSTYLE, style.second);
 
@@ -263,7 +263,7 @@ RECT VideoWinAPI::CalculateWindowRect(bool fullscreen, VideoMode& size) const
     return wRect;
 }
 
-bool VideoWinAPI::RegisterAndCreateWindow(const std::string& title, const VideoMode& wndSize, bool fullscreen)
+bool VideoWinAPI::RegisterAndCreateWindow(const std::string& title, const VideoMode& wndSize, DisplayMode displayMode)
 {
     std::wstring wTitle = boost::nowide::widen(title);
     windowClassName = wTitle.substr(0, wTitle.find(' '));
@@ -285,6 +285,7 @@ bool VideoWinAPI::RegisterAndCreateWindow(const std::string& title, const VideoM
         return false;
 
     // Create window
+    const auto fullscreen = bitset::isSet(displayMode, DisplayMode::Fullscreen);
     auto adjWindowSize = fullscreen ? FindClosestVideoMode(wndSize) : wndSize;
     RECT wRect = CalculateWindowRect(fullscreen, adjWindowSize);
 
@@ -415,7 +416,7 @@ void VideoWinAPI::DestroyScreen()
 
     UnregisterClassW(windowClassName.c_str(), GetModuleHandle(nullptr));
 
-    isFullscreen_ = false;
+    displayMode_ = bitset::set(displayMode_, DisplayMode::Fullscreen, false);
 }
 
 /**

extras/videoDrivers/WinAPI/WinAPI.h

@@ -30,10 +30,10 @@ class VideoWinAPI final : public VideoDriver
     bool Initialize() override;
 
     /// Erstellt das Fenster mit entsprechenden Werten.
-    bool CreateScreen(const std::string& title, const VideoMode& newSize, bool fullscreen) override;
+    bool CreateScreen(const std::string& title, const VideoMode& newSize, DisplayMode displayMode) override;
 
     /// Erstellt oder verändert das Fenster mit entsprechenden Werten.
-    bool ResizeScreen(const VideoMode& newSize, bool fullscreen) override;
+    bool ResizeScreen(const VideoMode& newSize, DisplayMode displayMode) override;
 
     /// Schliesst das Fenster.
     void DestroyScreen() override;
@@ -69,7 +69,7 @@ class VideoWinAPI final : public VideoDriver
     std::pair<DWORD, DWORD> GetStyleFlags(bool fullscreen) const;
     /// Calculate the rect for the window and adjusts the (usable) size if required
     RECT CalculateWindowRect(bool fullscreen, VideoMode& size) const;
-    bool RegisterAndCreateWindow(const std::string& title, const VideoMode& wndSize, bool fullscreen);
+    bool RegisterAndCreateWindow(const std::string& title, const VideoMode& wndSize, DisplayMode displayMode);
     bool InitOGL();
     static bool MakeFullscreen(const VideoMode& resolution);
 

libs/driver/include/driver/VideoDriver.h

@@ -32,7 +32,9 @@ class VideoDriver : public IVideoDriver
 
     VideoMode GetWindowSize() const override final { return windowSize_; }
     Extent GetRenderSize() const override final { return scaledRenderSize_; }
-    bool IsFullscreen() const override final { return isFullscreen_; }
+    DisplayMode GetDisplayMode() const override final { return displayMode_; }
+    bool IsFullscreen() const override final { return bitset::isSet(displayMode_, DisplayMode::Fullscreen); }
+    bool IsResizable() const override final { return bitset::isSet(displayMode_, DisplayMode::Fullscreen); }
 
     float getDpiScale() const override final { return dpiScale_; }
 
@@ -49,11 +51,21 @@ class VideoDriver : public IVideoDriver
     VideoMode FindClosestVideoMode(const VideoMode& mode) const;
     void SetNewSize(VideoMode windowSize, Extent renderSize);
 
+    void SetFullscreenFlag(bool fullscreen)
+    {
+        displayMode_ =
+          fullscreen ? (displayMode_ | DisplayMode::Fullscreen) : (displayMode_ & ~DisplayMode::Fullscreen);
+    }
+    void SetResizableFlag(bool resizable)
+    {
+        displayMode_ = bitset::set(displayMode_, DisplayMode::Resizable, resizable);
+    }
+
     VideoDriverLoaderInterface* CallBack; /// Das DriverCallback für Rückmeldungen.
     bool initialized;                     /// Initialisierungsstatus.
     MouseCoords mouse_xy;                 /// Status der Maus.
     std::array<bool, 512> keyboard;       /// Status der Tastatur;
-    bool isFullscreen_;                   /// Vollbild an/aus?
+    DisplayMode displayMode_;             /// Fullscreen/resizable?
 private:
     // cached as possibly used often
     VideoMode windowSize_;    ///< Size of the window or fullscreen resolution

libs/driver/include/driver/VideoInterface.h

@@ -9,12 +9,96 @@
 #include "Point.h"
 #include "VideoMode.h"
 #include "exportImport.h"
+// #include "s25util/enumUtils.h"
 #include <string>
+#include <type_traits>
 #include <vector>
 
 /// Function type for loading OpenGL methods
 using OpenGL_Loader_Proc = void* (*)(const char*);
 
+template<typename Enum>
+struct IsBitset : std::false_type
+{};
+
+template<typename Enum>
+using IsValidBitset =
+  std::integral_constant<bool, IsBitset<Enum>::value && std::is_unsigned<std::underlying_type_t<Enum>>::value>;
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator~(Enum val) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(~static_cast<T>(val));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator&(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) & static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator|(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) | static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator^(Enum lhs, Enum rhs) noexcept
+{
+    using T = std::underlying_type_t<Enum>;
+    return Enum(static_cast<T>(lhs) ^ static_cast<T>(rhs));
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator&=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs & rhs;
+    return lhs;
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator|=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs | rhs;
+    return lhs;
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr auto operator^=(Enum& lhs, Enum rhs) noexcept
+{
+    lhs = lhs ^ rhs;
+    return lhs;
+}
+
+namespace bitset {
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+constexpr bool isSet(Enum val, Enum flag)
+{
+    return (val & flag) != Enum(0);
+}
+
+template<typename Enum, std::enable_if_t<IsValidBitset<Enum>::value, int> = 0>
+[[nodiscard]] constexpr Enum set(Enum val, Enum flag, bool state)
+{
+    return state ? (val | flag) : (val & ~flag);
+}
+} // namespace bitset
+
+enum class DisplayMode : unsigned
+{
+    None,
+    Fullscreen = (1 << 0),
+    Resizable = (1 << 1)
+};
+
+template<>
+struct IsBitset<DisplayMode> : std::true_type
+{};
+
 class BOOST_SYMBOL_VISIBLE IVideoDriver
 {
 public:
@@ -26,9 +110,9 @@ class BOOST_SYMBOL_VISIBLE IVideoDriver
     virtual bool Initialize() = 0;
 
     /// Erstellt das Fenster mit entsprechenden Werten.
-    virtual bool CreateScreen(const std::string& title, const VideoMode& newSize, bool fullscreen) = 0;
+    virtual bool CreateScreen(const std::string& title, const VideoMode& newSize, DisplayMode displayMode) = 0;
 
-    virtual bool ResizeScreen(const VideoMode& newSize, bool fullscreen) = 0;
+    virtual bool ResizeScreen(const VideoMode& newSize, DisplayMode displayMode) = 0;
 
     /// Schliesst das Fenster.
     virtual void DestroyScreen() = 0;
@@ -64,7 +148,9 @@ class BOOST_SYMBOL_VISIBLE IVideoDriver
     virtual VideoMode GetWindowSize() const = 0;
     /// Get the size of the render region in pixels
     virtual Extent GetRenderSize() const = 0;
+    virtual DisplayMode GetDisplayMode() const = 0;
     virtual bool IsFullscreen() const = 0;
+    virtual bool IsResizable() const = 0;
 
     /// Get the factor required to scale "normal" DPI to the display DPI
     virtual float getDpiScale() const = 0;

libs/driver/src/VideoDriver.cpp

@@ -19,8 +19,8 @@ IVideoDriver::~IVideoDriver() = default;
  *  @param[in] CallBack DriverCallback für Rückmeldungen.
  */
 VideoDriver::VideoDriver(VideoDriverLoaderInterface* CallBack)
-    : CallBack(CallBack), initialized(false), isFullscreen_(false), renderSize_(0, 0), scaledRenderSize_(0, 0),
-      dpiScale_(1.f), guiScale_(100), autoGuiScale_(false)
+    : CallBack(CallBack), initialized(false), displayMode_(DisplayMode::Resizable), renderSize_(0, 0),
+      scaledRenderSize_(0, 0), dpiScale_(1.f), guiScale_(100), autoGuiScale_(false)
 {
     std::fill(keyboard.begin(), keyboard.end(), false);
 }