Add window states API

android/src/toga_android/app.py

@@ -11,6 +11,7 @@
 from org.beeware.android import IPythonApp, MainActivity
 
 from toga.command import Command, Group, Separator
+from toga.constants import WindowState
 
 from .libs import events
 from .screens import Screen as ScreenImpl
@@ -297,14 +298,14 @@ def set_current_window(self, window):
         pass
 
     ######################################################################
-    # Full screen control
+    # Presentation mode controls
     ######################################################################
 
-    def enter_full_screen(self, windows):
-        pass
+    def enter_presentation_mode(self, screen_window_dict):
+        self.interface.main_window.state = WindowState.PRESENTATION
 
-    def exit_full_screen(self, windows):
-        pass
+    def exit_presentation_mode(self):
+        self.interface.main_window.state = WindowState.NORMAL
 
     ######################################################################
     # Platform-specific APIs

android/src/toga_android/window.py

@@ -10,6 +10,8 @@
 from java import dynamic_proxy
 from java.io import ByteArrayOutputStream
 
+from toga.constants import WindowState
+
 from .container import Container
 from .screens import Screen as ScreenImpl
 
@@ -135,8 +137,70 @@ def get_visible(self):
     # Window state
     ######################################################################
 
-    def set_full_screen(self, is_full_screen):
-        self.interface.factory.not_implemented("Window.set_full_screen()")
+    def get_window_state(self):
+        # Windows are always full screen
+        decor_view = self.app.native.getWindow().getDecorView()
+        system_ui_flags = decor_view.getSystemUiVisibility()
+        if (
+            system_ui_flags
+            & (
+                decor_view.SYSTEM_UI_FLAG_FULLSCREEN
+                | decor_view.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                | decor_view.SYSTEM_UI_FLAG_IMMERSIVE
+            )
+        ) != 0:
+            if not self.app.native.getSupportActionBar().isShowing():
+                return WindowState.PRESENTATION
+            else:
+                return WindowState.FULLSCREEN
+        # elif getattr(self, "_is_minimized", False) is True:
+        #     return WindowState.MINIMIZED
+        return WindowState.NORMAL
+
+    def set_window_state(self, state):
+        current_state = self.get_window_state()
+        decor_view = self.app.native.getWindow().getDecorView()
+        # On Android Maximized state is same as the Normal state
+        if state in {WindowState.NORMAL, WindowState.MAXIMIZED}:
+            if current_state in {
+                WindowState.FULLSCREEN,
+                WindowState.PRESENTATION,
+            }:
+                decor_view.setSystemUiVisibility(0)
+                if current_state == WindowState.PRESENTATION:
+                    self.app.native.getSupportActionBar().show()
+
+            # Doesn't work consistently
+            # elif current_state == WindowState.MINIMIZED:
+            #     # Get the context
+            #     context = self.app.native.getApplicationContext()
+            #     # Create the intent to bring the activity to the foreground
+            #     new_intent = Intent(context, self.app.native.getClass())
+            #     # These 2 options work properly by resuming existing MainActivity instead of creating
+            #     # a new instance of MainActivity, but they work only once:
+            #     new_intent.addFlags(
+            #         Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP
+            #     )
+            #     new_intent.setFlags(
+            #         Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP
+            #     )
+            #     # This works every time but starts new instance of MainActivity
+            #     new_intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            #     self.app.native.startActivity(new_intent)
+            #     self._is_minimized = False
+        else:
+            if state in {WindowState.FULLSCREEN, WindowState.PRESENTATION}:
+                decor_view.setSystemUiVisibility(
+                    decor_view.SYSTEM_UI_FLAG_FULLSCREEN
+                    | decor_view.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                    | decor_view.SYSTEM_UI_FLAG_IMMERSIVE
+                )
+                if state == WindowState.PRESENTATION:
+                    self.app.native.getSupportActionBar().hide()
+            # elif state == WindowState.MINIMIZED:
+            #     # This works but the issue lies in restoring to normal state
+            #     self.app.native.moveTaskToBack(True)
+            #     self._is_minimized = True
 
     ######################################################################
     # Window capabilities

android/tests_backend/window.py

@@ -1,6 +1,8 @@
 import pytest
 from androidx.appcompat import R as appcompat_R
 
+from toga.constants import WindowState
+
 from .probe import BaseProbe
 
 
@@ -19,6 +21,26 @@ def content_size(self):
             self.root_view.getHeight() / self.scale_factor,
         )
 
+    def is_window_state(self, state):
+        # Windows are always full screen
+        decor_view = self.native.getWindow().getDecorView()
+        system_ui_flags = decor_view.getSystemUiVisibility()
+        if (
+            system_ui_flags
+            & (
+                decor_view.SYSTEM_UI_FLAG_FULLSCREEN
+                | decor_view.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                | decor_view.SYSTEM_UI_FLAG_IMMERSIVE
+            )
+        ) != 0:
+            if not self.native.getSupportActionBar().isShowing():
+                current_state = WindowState.PRESENTATION
+            else:
+                current_state = WindowState.FULLSCREEN
+        else:
+            current_state = WindowState.NORMAL
+        return bool(current_state == state)
+
     async def close_info_dialog(self, dialog):
         dialog_view = self.get_dialog_view()
         self.assert_dialog_buttons(dialog_view, ["OK"])

changes/1857.bugfix.rst

@@ -0,0 +1 @@
+Calling `Window.close()` on platforms like Android and iOS now correctly performs a no-op and doesn't clear the window from the window registry.

changes/1857.feature.rst

@@ -0,0 +1 @@
+Toga apps can now detect and set their window states including maximized, minimized, normal, full screen and presentation states.

changes/1857.removal.rst

@@ -0,0 +1 @@
+The older full screen APIs on `toga.App` and `toga.Window` are now deprecated and are instead replaced by their suitable newer API counterparts.

cocoa/src/toga_cocoa/app.py

@@ -9,6 +9,7 @@
 
 import toga
 from toga.command import Separator
+from toga.constants import WindowState
 from toga.handlers import NativeHandler
 
 from .keys import cocoa_key
@@ -503,33 +504,34 @@ def set_current_window(self, window):
         window._impl.native.makeKeyAndOrderFront(window._impl.native)
 
     ######################################################################
-    # Full screen control
+    # Presentation mode controls
     ######################################################################
 
-    def enter_full_screen(self, windows):
+    def enter_presentation_mode(self, screen_window_dict):
         opts = NSMutableDictionary.alloc().init()
         opts.setObject(
             NSNumber.numberWithBool(True), forKey="NSFullScreenModeAllScreens"
         )
-
-        for window, screen in zip(windows, NSScreen.screens):
-            window.content._impl.native.enterFullScreenMode(screen, withOptions=opts)
+        for screen, window in screen_window_dict.items():
+            window.content._impl.native.enterFullScreenMode(
+                screen._impl.native, withOptions=opts
+            )
             # Going full screen causes the window content to be re-homed
             # in a NSFullScreenWindow; teach the new parent window
             # about its Toga representations.
             window.content._impl.native.window._impl = window._impl
             window.content._impl.native.window.interface = window
             window.content.refresh()
 
-    def exit_full_screen(self, windows):
+    def exit_presentation_mode(self):
         opts = NSMutableDictionary.alloc().init()
         opts.setObject(
             NSNumber.numberWithBool(True), forKey="NSFullScreenModeAllScreens"
         )
-
-        for window in windows:
-            window.content._impl.native.exitFullScreenModeWithOptions(opts)
-            window.content.refresh()
+        for window in self.interface.windows:
+            if window.state == WindowState.PRESENTATION:
+                window.content._impl.native.exitFullScreenModeWithOptions(opts)
+                window.content.refresh()
 
 
 class DocumentApp(App):  # pragma: no cover

cocoa/src/toga_cocoa/window.py

@@ -1,6 +1,7 @@
 from rubicon.objc import CGSize
 
 from toga.command import Command, Separator
+from toga.constants import WindowState
 from toga_cocoa.container import Container
 from toga_cocoa.libs import (
     SEL,
@@ -41,6 +42,11 @@ def windowDidResize_(self, notification) -> None:
             # Set the window to the new size
             self.interface.content.refresh()
 
+    @objc_method
+    def windowDidExitFullScreen_(self, notification) -> None:
+        # This can be used to ensure that the window has completed exiting full screen.
+        pass
+
     ######################################################################
     # Toolbar delegate methods
     ######################################################################
@@ -205,8 +211,14 @@ def set_title(self, title):
     ######################################################################
 
     def close(self):
+        if self.interface.content:
+            self.interface.content.window = None
+        self.interface.app.windows.discard(self.interface)
+
         self.native.close()
 
+        self.interface._closed = True
+
     def create_toolbar(self):
         # Purge any existing toolbar items
         self.purge_toolbar()
@@ -339,10 +351,57 @@ def get_visible(self):
     # Window state
     ######################################################################
 
-    def set_full_screen(self, is_full_screen):
-        current_state = bool(self.native.styleMask & NSWindowStyleMask.FullScreen)
-        if is_full_screen != current_state:
-            self.native.toggleFullScreen(self.native)
+    def get_window_state(self):
+        if self.interface.content and bool(
+            self.interface.content._impl.native.isInFullScreenMode()
+        ):
+            return WindowState.PRESENTATION
+        elif bool(self.native.styleMask & NSWindowStyleMask.FullScreen):
+            return WindowState.FULLSCREEN
+        elif bool(self.native.isZoomed):
+            return WindowState.MAXIMIZED
+        elif bool(self.native.isMiniaturized):
+            return WindowState.MINIMIZED
+        else:
+            return WindowState.NORMAL
+
+    def set_window_state(self, state):
+        current_state = self.get_window_state()
+        if state == WindowState.NORMAL:
+            # If the window is maximized, restore it to its normal size
+            if current_state == WindowState.MAXIMIZED:
+                self.native.setIsZoomed(False)
+            # Deminiaturize the window to restore it to its previous state
+            elif current_state == WindowState.MINIMIZED:
+                self.native.setIsMiniaturized(False)
+            # If the window is in full-screen mode, exit full-screen mode
+            elif current_state == WindowState.FULLSCREEN:
+                # This doesn't wait for completely exiting full screen mode. Hence,
+                # this will cause problems when rapid window state switching is done.
+                # We should wait until `windowDidExitFullScreen_` is notified and then
+                # return to user.
+                self.native.toggleFullScreen(self.native)
+            # If the window is in presentation mode, exit presentation mode
+            elif current_state == WindowState.PRESENTATION:
+                self.interface.app.exit_presentation_mode()
+        else:
+            if state == WindowState.MAXIMIZED:
+                self.native.setIsZoomed(True)
+
+            elif state == WindowState.MINIMIZED:
+                self.native.setIsMiniaturized(True)
+
+            elif state == WindowState.FULLSCREEN:
+                self.native.toggleFullScreen(self.native)
+
+            elif state == WindowState.PRESENTATION:
+                self.interface.app.enter_presentation_mode(
+                    {self.interface.screen: self.interface}
+                )
+            else:  # pragma: no cover
+                # Marking this as no cover, since the type of the state parameter
+                # value is checked on the interface.
+                return
 
     ######################################################################
     # Window capabilities

cocoa/tests_backend/app.py

@@ -4,6 +4,7 @@
 from rubicon.objc import NSPoint, ObjCClass, objc_id, send_message
 
 import toga
+from toga.constants import WindowState
 from toga_cocoa.keys import cocoa_key, toga_key
 from toga_cocoa.libs import (
     NSApplication,
@@ -14,6 +15,7 @@
 )
 
 from .probe import BaseProbe
+from .window import WindowProbe
 
 NSPanel = ObjCClass("NSPanel")
 
@@ -52,13 +54,10 @@ def is_cursor_visible(self):
         return self.app._impl._cursor_visible
 
     def is_full_screen(self, window):
-        return window.content._impl.native.isInFullScreenMode()
+        return WindowProbe(self.app, window).is_window_state(WindowState.PRESENTATION)
 
     def content_size(self, window):
-        return (
-            window.content._impl.native.frame.size.width,
-            window.content._impl.native.frame.size.height,
-        )
+        return WindowProbe(self.app, window).presentation_content_size
 
     def assert_app_icon(self, icon):
         # We have no real way to check we've got the right icon; use pixel peeping as a

cocoa/tests_backend/window.py

@@ -3,6 +3,7 @@
 from rubicon.objc import objc_id, send_message
 from rubicon.objc.collections import ObjCListInstance
 
+from toga.constants import WindowState
 from toga_cocoa.libs import (
     NSURL,
     NSAlertFirstButtonReturn,
@@ -49,9 +50,31 @@ def content_size(self):
             self.native.contentView.frame.size.height,
         )
 
+    @property
+    def presentation_content_size(self):
+        return (
+            self.window.content._impl.native.frame.size.width,
+            self.window.content._impl.native.frame.size.height,
+        )
+
+    def is_window_state(self, state):
+        if self.window.content and bool(
+            self.window.content._impl.native.isInFullScreenMode()
+        ):
+            current_state = WindowState.PRESENTATION
+        elif bool(self.native.styleMask & NSWindowStyleMask.FullScreen):
+            current_state = WindowState.FULLSCREEN
+        elif bool(self.native.isZoomed):
+            current_state = WindowState.MAXIMIZED
+        elif bool(self.native.isMiniaturized):
+            current_state = WindowState.MINIMIZED
+        else:
+            current_state = WindowState.NORMAL
+        return bool(current_state == state)
+
     @property
     def is_full_screen(self):
-        return bool(self.native.styleMask & NSWindowStyleMask.FullScreen)
+        return self.is_window_state(WindowState.FULLSCREEN)
 
     @property
     def is_resizable(self):
@@ -67,7 +90,7 @@ def is_minimizable(self):
 
     @property
     def is_minimized(self):
-        return bool(self.native.isMiniaturized)
+        return self.is_window_state(WindowState.MINIMIZED)
 
     def minimize(self):
         self.native.performMiniaturize(None)