Started some fixes for Windows

include/SFML/Window/Window.hpp

@@ -34,6 +34,7 @@
 #include <SFML/Window/GlResource.hpp>
 #include <SFML/Window/VideoMode.hpp>
 #include <SFML/Window/WindowHandle.hpp>
+#include <SFML/Window/WindowState.hpp>
 #include <SFML/Window/WindowStyle.hpp>
 #include <SFML/System/Clock.hpp>
 #include <SFML/System/NonCopyable.hpp>
@@ -472,6 +473,30 @@ public:
     ////////////////////////////////////////////////////////////
     bool hasFocus() const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Set the window state
+    ///
+    /// Set the window state.
+    ///
+    /// \param state The new state
+    ///
+    /// \see getState
+    ///
+    ////////////////////////////////////////////////////////////
+    void setState(State state);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the windows state
+    ///
+    /// Get the window state.
+    ///
+    /// \return The window state
+    ///
+    /// \see setState
+    ///
+    ////////////////////////////////////////////////////////////
+    State getState() const;
+
     ////////////////////////////////////////////////////////////
     /// \brief Display on screen what has been rendered to the window so far
     ///
@@ -537,7 +562,7 @@ private:
     /// \brief Perform some common internal initializations
     ///
     ////////////////////////////////////////////////////////////
-    void initialize();
+    void initialize(Uint32 style);
 
     ////////////////////////////////////////////////////////////
     // Member data

include/SFML/Window/WindowState.hpp

@@ -0,0 +1,47 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2018 Foaly (foaly@posteo.de)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_WINDOWSTATE_HPP
+#define SFML_WINDOWSTATE_HPP
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \ingroup window
+/// \brief Enumeration of the window states
+///
+////////////////////////////////////////////////////////////
+enum State
+{
+    Windowed,
+    Minimized,
+    Maximized,
+    Fullscreen
+};
+
+} // namespace sf
+
+
+#endif // SFML_WINDOWSTATE_HPP

include/SFML/Window/WindowStyle.hpp

@@ -42,6 +42,7 @@ namespace Style
         Resize     = 1 << 1, ///< Title bar + resizable border + maximize button
         Close      = 1 << 2, ///< Title bar + close button
         Fullscreen = 1 << 3, ///< Fullscreen mode (this flag and all others are mutually exclusive)
+        Hidden     = 1 << 4, ///< Hidden window
 
         Default = Titlebar | Resize | Close ///< Default window style
     };

src/SFML/Window/CMakeLists.txt

@@ -45,6 +45,7 @@ set(SRC
     ${SRCROOT}/WindowImpl.cpp
     ${SRCROOT}/WindowImpl.hpp
     ${INCROOT}/WindowStyle.hpp
+    ${INCROOT}/WindowState.hpp
 )
 if(SFML_OPENGL_ES AND NOT SFML_OS_IOS)
     list(APPEND SRC ${SRCROOT}/EGLCheck.cpp)

src/SFML/Window/OSX/SFWindowController.mm

@@ -158,6 +158,9 @@
             [self setupWindowWithMode:mode andStyle:style];
 
         [m_oglView finishInit];
+
+        if (style & sf::Style::Hidden)
+            [m_window orderOut:self];
     }
     return self;
 }
@@ -492,7 +495,7 @@
 ////////////////////////////////////////////////////////
 -(void)hideWindow
 {
-    [m_window orderOut:nil];
+    [m_window orderOut:self];
 }
 
 
@@ -530,6 +533,54 @@
 }
 
 
+////////////////////////////////////////////////////////
+-(void)minimize
+{
+    [m_window miniaturize:self];
+}
+
+
+////////////////////////////////////////////////////////
+-(void)unminimize
+{
+    [m_window deminiaturize:self];
+}
+
+
+////////////////////////////////////////////////////////
+-(void)toogleMaximize
+{
+    [m_window zoom:self];
+}
+
+
+////////////////////////////////////////////////////////
+-(BOOL)isMinimized
+{
+    return [m_window isMiniaturized];
+}
+
+
+////////////////////////////////////////////////////////
+-(BOOL)isMaximized
+{
+    // isZoomed is always true when the windows has the style NSBorderlessWindowMask or is fullscreen
+    // also the other SFML styles besides Resize can't be maximized, so we filter here
+    NSUInteger style = [m_window styleMask];
+    if ( !(style & NSResizableWindowMask) )
+        return NO;
+
+    return [m_window isZoomed];
+}
+
+
+////////////////////////////////////////////////////////
+-(BOOL)isFullscreen
+{
+    return m_fullscreen;
+}
+
+
 ////////////////////////////////////////////////////////
 -(void)enableKeyRepeat
 {

src/SFML/Window/OSX/WindowImplCocoa.hpp

@@ -352,6 +352,23 @@ public:
     ////////////////////////////////////////////////////////////
     virtual bool hasFocus() const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Set the window state
+    ///
+    /// \param state The new state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual void setState(State state);
+
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the window state
+    ///
+    /// \return The window state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual State getState() const;
+
 protected:
 
     ////////////////////////////////////////////////////////////

src/SFML/Window/OSX/WindowImplCocoa.mm

@@ -524,6 +524,53 @@ bool WindowImplCocoa::hasFocus() const
 }
 
 
+////////////////////////////////////////////////////////////
+void WindowImplCocoa::setState(State state)
+{
+    State currentState = getState();
+
+    switch(state)
+    {
+        case State::Minimized:
+            [m_delegate minimize];
+            break;
+
+        case State::Maximized:
+            if (currentState == State::Windowed)
+                [m_delegate toogleMaximize];
+            if (currentState == State::Minimized)
+            {
+                [m_delegate unminimize];
+                [m_delegate toogleMaximize];
+            }
+            break;
+
+        case State::Windowed:
+            if (currentState == State::Minimized)
+                [m_delegate unminimize];
+            else if (currentState == State::Maximized)
+                [m_delegate toogleMaximize];
+            break;
+
+        case Fullscreen:
+            sf::err() << "Switching to fullscreen is not implemtent on OSX yet." << std::endl;
+            break;
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+State WindowImplCocoa::getState() const
+{
+    if ([m_delegate isFullscreen])
+        return State::Fullscreen;
+    if ([m_delegate isMinimized])
+        return State::Minimized;
+    if ([m_delegate isMaximized])
+        return State::Maximized;
+    return State::Windowed;
+}
+
 } // namespace priv
 
 } // namespace sf

src/SFML/Window/OSX/WindowImplDelegateProtocol.h

@@ -195,6 +195,48 @@ namespace sf {
 ////////////////////////////////////////////////////////////
 -(BOOL)hasFocus;
 
+////////////////////////////////////////////////////////////
+/// \brief Minimize the window
+///
+////////////////////////////////////////////////////////////
+-(void)minimize;
+
+////////////////////////////////////////////////////////////
+/// \brief Unminimize the window
+///
+////////////////////////////////////////////////////////////
+-(void)unminimize;
+
+////////////////////////////////////////////////////////////
+/// \brief Maximize or unmaximizes the window
+///
+////////////////////////////////////////////////////////////
+-(void)toogleMaximize;
+
+////////////////////////////////////////////////////////////
+/// \brief Check whether the window is minimized
+///
+/// \return True if window is minimized, false otherwise
+///
+////////////////////////////////////////////////////////////
+-(BOOL)isMinimized;
+
+////////////////////////////////////////////////////////////
+/// \brief Check whether the window is maximized
+///
+/// \return True if window is maximized, false otherwise
+///
+////////////////////////////////////////////////////////////
+-(BOOL)isMaximized;
+
+////////////////////////////////////////////////////////////
+/// \brief Check whether the window is fullscreen
+///
+/// \return True if window is fullscreen, false otherwise
+///
+////////////////////////////////////////////////////////////
+-(BOOL)isFullscreen;
+
 ////////////////////////////////////////////////////////////
 /// \brief Enable key repeat
 ///

src/SFML/Window/Win32/WindowImplWin32.cpp

@@ -123,6 +123,28 @@ namespace
             FreeLibrary(user32Dll);
         }
     }
+
+    DWORD translateStyle(sf::Uint32 style)
+    {
+        // Choose the window style according to the Style parameter
+        DWORD win32Style = 0;
+        if (style == sf::Style::None)
+        {
+            win32Style |= WS_POPUP;
+        }
+        else
+        {
+            if (style & sf::Style::Titlebar) win32Style |= WS_CAPTION | WS_MINIMIZEBOX;
+            if (style & sf::Style::Resize)   win32Style |= WS_THICKFRAME | WS_MAXIMIZEBOX;
+            if (style & sf::Style::Close)    win32Style |= WS_SYSMENU;
+        }
+        if (!(style & sf::Style::Hidden))
+        {
+            win32Style |= WS_VISIBLE;
+        }
+
+        return win32Style;
+    }
 }
 
 namespace sf
@@ -141,8 +163,9 @@ m_lastSize        (0, 0),
 m_resizing        (false),
 m_surrogate       (0),
 m_mouseInside     (false),
-m_fullscreen      (false),
-m_cursorGrabbed   (false)
+m_cursorGrabbed   (false),
+m_win32Style      (translateStyle(Style::None)),
+m_mode            (VideoMode::getDesktopMode())
 {
     // Set that this process is DPI aware and can handle DPI scaling
     setProcessDpiAware();
@@ -174,8 +197,9 @@ m_lastSize        (mode.width, mode.height),
 m_resizing        (false),
 m_surrogate       (0),
 m_mouseInside     (false),
-m_fullscreen      ((style & Style::Fullscreen) != 0),
-m_cursorGrabbed   (m_fullscreen)
+m_cursorGrabbed   ((style & Style::Fullscreen) != 0),
+m_win32Style      (translateStyle(style)),
+m_mode            (mode)
 {
     // Set that this process is DPI aware and can handle DPI scaling
     setProcessDpiAware();
@@ -192,30 +216,17 @@ m_cursorGrabbed   (m_fullscreen)
     int height = mode.height;
     ReleaseDC(NULL, screenDC);
 
-    // Choose the window style according to the Style parameter
-    DWORD win32Style = WS_VISIBLE;
-    if (style == Style::None)
-    {
-        win32Style |= WS_POPUP;
-    }
-    else
-    {
-        if (style & Style::Titlebar) win32Style |= WS_CAPTION | WS_MINIMIZEBOX;
-        if (style & Style::Resize)   win32Style |= WS_THICKFRAME | WS_MAXIMIZEBOX;
-        if (style & Style::Close)    win32Style |= WS_SYSMENU;
-    }
-
     // In windowed mode, adjust width and height so that window will have the requested client area
-    if (!m_fullscreen)
+    if (!(style & Style::Fullscreen))
     {
         RECT rectangle = {0, 0, width, height};
-        AdjustWindowRect(&rectangle, win32Style, false);
+        AdjustWindowRect(&rectangle, m_win32Style, false);
         width  = rectangle.right - rectangle.left;
         height = rectangle.bottom - rectangle.top;
     }
 
     // Create the window
-    m_handle = CreateWindowW(className, title.toWideString().c_str(), win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this);
+    m_handle = CreateWindowW(className, title.toWideString().c_str(), m_win32Style, left, top, width, height, NULL, NULL, GetModuleHandle(NULL), this);
 
     // Register to receive device interface change notifications (used for joystick connection handling)
     DEV_BROADCAST_DEVICEINTERFACE deviceInterface = {sizeof(DEV_BROADCAST_DEVICEINTERFACE), DBT_DEVTYP_DEVICEINTERFACE, 0, GUID_DEVINTERFACE_HID, 0};
@@ -230,13 +241,13 @@ m_cursorGrabbed   (m_fullscreen)
         ++handleCount;
     }
 
-    // By default, the OS limits the size of the window the the desktop size,
+    // By default, the OS limits the size of the window to the desktop size,
     // we have to resize it after creation to apply the real size
     setSize(Vector2u(mode.width, mode.height));
 
     // Switch to fullscreen if requested
-    if (m_fullscreen)
-        switchToFullscreen(mode);
+    if (style & Style::Fullscreen)
+        switchToFullscreen();
 
     // Increment window count
     windowCount++;
@@ -467,6 +478,51 @@ bool WindowImplWin32::hasFocus() const
 }
 
 
+////////////////////////////////////////////////////////////
+void WindowImplWin32::setState(State state)
+{
+    State currentState = getState();
+
+    switch (state)
+    {
+        case State::Windowed:
+            if (currentState == State::Fullscreen)
+                switchToWindowed();
+            else
+                ShowWindow(m_handle, SW_RESTORE);
+            break;
+        case State::Minimized:
+            ShowWindow(m_handle, SW_MINIMIZE);
+            break;
+        case State::Maximized:
+            ShowWindow(m_handle, SW_MAXIMIZE);
+            break;
+        case State::Fullscreen:
+            if (currentState != State::Fullscreen)
+                switchToFullscreen();
+            break;
+
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+State WindowImplWin32::getState() const
+{
+    WINDOWPLACEMENT currentState;
+    currentState.length = sizeof(WINDOWPLACEMENT);
+    GetWindowPlacement(m_handle, &currentState);
+
+    if ((currentState.showCmd == SW_MINIMIZE) || (currentState.showCmd == SW_SHOWMINIMIZED))
+        return State::Minimized;
+    if ((currentState.showCmd == SW_MAXIMIZE) || (currentState.showCmd == SW_SHOWMAXIMIZED))
+        return State::Maximized;
+    if (fullscreenWindow == this)
+        return State::Fullscreen;
+
+    return State::Windowed;
+}
+
 ////////////////////////////////////////////////////////////
 void WindowImplWin32::registerWindowClass()
 {
@@ -486,13 +542,13 @@ void WindowImplWin32::registerWindowClass()
 
 
 ////////////////////////////////////////////////////////////
-void WindowImplWin32::switchToFullscreen(const VideoMode& mode)
+void WindowImplWin32::switchToFullscreen()
 {
     DEVMODE devMode;
     devMode.dmSize       = sizeof(devMode);
-    devMode.dmPelsWidth  = mode.width;
-    devMode.dmPelsHeight = mode.height;
-    devMode.dmBitsPerPel = mode.bitsPerPixel;
+    devMode.dmPelsWidth  = m_mode.width;
+    devMode.dmPelsHeight = m_mode.height;
+    devMode.dmBitsPerPel = m_mode.bitsPerPixel;
     devMode.dmFields     = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
 
     // Apply fullscreen mode
@@ -507,7 +563,7 @@ void WindowImplWin32::switchToFullscreen(const VideoMode& mode)
     SetWindowLongW(m_handle, GWL_EXSTYLE, WS_EX_APPWINDOW);
 
     // Resize the window so that it fits the entire screen
-    SetWindowPos(m_handle, HWND_TOP, 0, 0, mode.width, mode.height, SWP_FRAMECHANGED);
+    SetWindowPos(m_handle, HWND_TOP, 0, 0, m_mode.width, m_mode.height, SWP_FRAMECHANGED);
     ShowWindow(m_handle, SW_SHOW);
 
     // Set "this" as the current fullscreen window
@@ -515,6 +571,32 @@ void WindowImplWin32::switchToFullscreen(const VideoMode& mode)
 }
 
 
+////////////////////////////////////////////////////////////
+void WindowImplWin32::switchToWindowed()
+{
+    // Restore the graphics mode of the display device back to the values from the registry
+    ChangeDisplaySettings(NULL, 0);
+
+    // Set the window flags to what the user requested before switching to fullscreen
+    SetWindowLongW(m_handle, GWL_STYLE, m_win32Style);
+
+    // Compute position and size
+    HDC screenDC = GetDC(NULL);
+    int left   = (GetDeviceCaps(screenDC, HORZRES) - static_cast<int>(m_mode.width))  / 2;
+    int top    = (GetDeviceCaps(screenDC, VERTRES) - static_cast<int>(m_mode.height)) / 2;
+    ReleaseDC(NULL, screenDC);
+
+    RECT rectangle = {0, 0, static_cast<LONG>(m_mode.width), static_cast<LONG>(m_mode.height)};
+    AdjustWindowRect(&rectangle, m_win32Style, false);
+    int width  = rectangle.right - rectangle.left;
+    int height = rectangle.bottom - rectangle.top;
+
+    SetWindowPos(m_handle, HWND_TOP, left, top, width, height, SWP_FRAMECHANGED);
+
+    fullscreenWindow = NULL;
+}
+
+
 ////////////////////////////////////////////////////////////
 void WindowImplWin32::cleanup()
 {

src/SFML/Window/Win32/WindowImplWin32.hpp

@@ -184,6 +184,22 @@ public:
     ////////////////////////////////////////////////////////////
     virtual bool hasFocus() const;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Set the window state
+    ///
+    /// \param state The new state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual void setState(State state);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the window state
+    ///
+    /// \return The window state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual State getState() const;
+
 protected:
 
     ////////////////////////////////////////////////////////////
@@ -201,12 +217,16 @@ private:
     void registerWindowClass();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Switch to fullscreen mode
-    ///
-    /// \param mode Video mode to switch to
+    /// \brief Switch to fullscreen state
     ///
     ////////////////////////////////////////////////////////////
-    void switchToFullscreen(const VideoMode& mode);
+    void switchToFullscreen();
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Switch to windowed state
+    ///
+    ////////////////////////////////////////////////////////////
+    void switchToWindowed();
 
     ////////////////////////////////////////////////////////////
     /// \brief Free all the graphical resources attached to the window
@@ -282,8 +302,10 @@ private:
     bool     m_resizing;         ///< Is the window being resized?
     Uint16   m_surrogate;        ///< First half of the surrogate pair, in case we're receiving a Unicode character in two events
     bool     m_mouseInside;      ///< Mouse is inside the window?
-    bool     m_fullscreen;       ///< Is the window fullscreen?
     bool     m_cursorGrabbed;    ///< Is the mouse cursor trapped?
+
+    const DWORD     m_win32Style;      ///< Window style in the windows format
+    const VideoMode m_mode;            ///< Video mode of the window
 };
 
 } // namespace priv

src/SFML/Window/Window.cpp

@@ -31,6 +31,8 @@
 #include <SFML/System/Sleep.hpp>
 #include <SFML/System/Err.hpp>
 
+#include <iostream>
+
 
 namespace
 {
@@ -127,7 +129,7 @@ void Window::create(VideoMode mode, const String& title, Uint32 style, const Con
     m_context = priv::GlContext::create(settings, m_impl, mode.bitsPerPixel);
 
     // Perform common initializations
-    initialize();
+    initialize(style);
 }
 
 
@@ -144,7 +146,7 @@ void Window::create(WindowHandle handle, const ContextSettings& settings)
     m_context = priv::GlContext::create(settings, m_impl, VideoMode::getDesktopMode().bitsPerPixel);
 
     // Perform common initializations
-    initialize();
+    initialize(sf::Style::Default);
 }
 
 
@@ -368,7 +370,42 @@ bool Window::hasFocus() const
 
 
 ////////////////////////////////////////////////////////////
+void Window::setState(State state)
+{
+    if (m_impl)
+    {
+        // TODO: this if never evaluates to true, even if state IS State::Windowed
+        //       I can't figure out why. This is ehy you can only switch to fullscreen once
+        if (state == State::Windowed)
+        {
+            if (this == fullscreenWindow)
+                fullscreenWindow = NULL;
+        }
 
+        if (state == State::Fullscreen)
+            if (fullscreenWindow != NULL)
+            {
+                err() << "Creating more than one fullscreen window is not allowed" << std::endl;
+                return;
+            }
+            else
+            {
+                fullscreenWindow = this;
+            }
+
+        m_impl->setState(state);
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+State Window::getState() const
+{
+    return m_impl ? m_impl->getState() : State::Windowed;
+}
+
+
+////////////////////////////////////////////////////////////
 void Window::display()
 {
     // Display the backbuffer on screen
@@ -424,15 +461,16 @@ bool Window::filterEvent(const Event& event)
 
 
 ////////////////////////////////////////////////////////////
-void Window::initialize()
+void Window::initialize(Uint32 style)
 {
     // Setup default behaviors (to get a consistent behavior across different implementations)
-    setVisible(true);
-    setMouseCursorVisible(true);
     setVerticalSyncEnabled(false);
     setKeyRepeatEnabled(true);
     setFramerateLimit(0);
 
+    if (!(style & Style::Hidden))
+        setVisible(true);
+
     // Get and cache the initial size of the window
     m_size = m_impl->getSize();
 

src/SFML/Window/WindowImpl.hpp

@@ -39,8 +39,9 @@
 #include <SFML/Window/Sensor.hpp>
 #include <SFML/Window/SensorImpl.hpp>
 #include <SFML/Window/VideoMode.hpp>
-#include <SFML/Window/WindowHandle.hpp>
 #include <SFML/Window/Window.hpp>
+#include <SFML/Window/WindowHandle.hpp>
+#include <SFML/Window/WindowState.hpp>
 #include <queue>
 #include <set>
 
@@ -227,6 +228,22 @@ public:
     ////////////////////////////////////////////////////////////
     virtual bool hasFocus() const = 0;
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Set the window state
+    ///
+    /// \param state The new state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual void setState(State state) = 0;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the window state
+    ///
+    /// \return The window state
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual State getState() const = 0;
+
 protected:
 
     ////////////////////////////////////////////////////////////