Added on_resize handler on toga.Window

android/src/toga_android/window.py

@@ -29,6 +29,7 @@ def onGlobalLayout(self):
         """
         native_parent = self.window.native_content.getParent()
         self.window.resize_content(native_parent.getWidth(), native_parent.getHeight())
+        self.window.interface.on_resize()
 
 
 class Window(Container):

changes/2304.feature.rst

@@ -0,0 +1 @@
+Toga Windows now supports calling user functions on resize events.

cocoa/src/toga_cocoa/window.py

@@ -64,6 +64,7 @@ def windowWillClose_(self, notification) -> None:
 
     @objc_method
     def windowDidResize_(self, notification) -> None:
+        self.impl.interface.on_resize()
         if self.interface.content:
             # Set the window to the new size
             self.interface.content.refresh()
@@ -454,10 +455,14 @@ def _apply_state(self, target_state):
             )
 
             # Going presentation mode causes the window content
-            # to be re-homed in a NSFullScreenWindow; teach the
-            # new parent window about its Toga representations.
+            # to be re-homed in a NSFullScreenWindow;
+            # Teach the new parent window about its Toga representations.
             self.container.native.window._impl = self
             self.container.native.window.interface = self.interface
+            # Manually trigger the resize event as the original NSWindow's
+            # size remains unchanged, hence the windowDidResize_ would not
+            # be notified when the window goes into presentation mode.
+            self.interface.on_resize()
             self.interface.content.refresh()
 
             # No need to check for other pending states,
@@ -481,6 +486,10 @@ def _apply_state(self, target_state):
                     NSNumber.numberWithBool(True), forKey="NSFullScreenModeAllScreens"
                 )
                 self.container.native.exitFullScreenModeWithOptions(opts)
+                # Manually trigger the resize event as the original NSWindow's
+                # size remains unchanged, hence the windowDidResize_ would not
+                # be notified when the window goes out of the presentation mode.
+                self.interface.on_resize()
                 self.interface.content.refresh()
 
                 self.interface.screen = self._before_presentation_mode_screen

core/src/toga/window.py

@@ -158,6 +158,25 @@ def __call__(self, window: Window, **kwargs: Any) -> None:
         ...
 
 
+class OnResizeHandler(Protocol):
+    def __call__(self, window: Window, **kwargs: Any) -> None:
+        """A handler to invoke when a window resizes.
+
+        This event is also triggered when any change in available layout size occurs.
+        However, a change in visibility (e.g. when a window is hidden or minimized)
+        does not cause a change in layout size and therefore, the event will not be
+        triggered.
+
+        On mobile platforms, it is also triggered when the orientation of the
+        device is changed.
+
+        :param window: The window instance that resizes.
+        :param kwargs: Ensures compatibility with additional arguments introduced in
+            future ver
+        """
+        ...
+
+
 _DialogResultT = TypeVar("_DialogResultT")
 
 
@@ -197,6 +216,7 @@ def __init__(
         on_lose_focus: OnLoseFocusHandler | None = None,
         on_show: OnShowHandler | None = None,
         on_hide: OnHideHandler | None = None,
+        on_resize: OnResizeHandler | None = None,
         content: Widget | None = None,
     ) -> None:
         """Create a new Window.
@@ -226,6 +246,17 @@ def __init__(
         self._closable = closable
         self._minimizable = minimizable
 
+        # Prime up the event handlers on the interface, as they might be
+        # called during the initialization of the native window class.
+        self.on_close = on_close
+
+        self.on_gain_focus = on_gain_focus
+        self.on_lose_focus = on_lose_focus
+        self.on_show = on_show
+        self.on_hide = on_hide
+
+        self.on_resize = on_resize
+
         # The app needs to exist before windows are created. _app will only be None
         # until the window is added to the app below.
         self._app: App = None
@@ -247,13 +278,6 @@ def __init__(
         if content:
             self.content = content
 
-        self.on_close = on_close
-
-        self.on_gain_focus = on_gain_focus
-        self.on_lose_focus = on_lose_focus
-        self.on_show = on_show
-        self.on_hide = on_hide
-
     def __lt__(self, other: Window) -> bool:
         return self.id < other.id
 
@@ -652,6 +676,15 @@ def on_hide(self) -> callable:
     def on_hide(self, handler):
         self._on_hide = wrapped_handler(self, handler)
 
+    @property
+    def on_resize(self) -> OnResizeHandler:
+        """The handler to invoke when the window resizes."""
+        return self._on_resize
+
+    @on_resize.setter
+    def on_resize(self, handler):
+        self._on_resize = wrapped_handler(self, handler)
+
     ######################################################################
     # 2024-06: Backwards compatibility for <= 0.4.5
     ######################################################################

core/tests/window/test_window.py

@@ -769,6 +769,35 @@ def test_visibility_events(window):
     assert_window_on_show(window)
 
 
+def test_resize_event(window):
+    """The window can trigger on_resize() event handler, when the window
+    size is changed."""
+    window.show()
+    assert window.on_resize._raw is None
+    window_on_resize_handler = Mock()
+    window.on_resize = window_on_resize_handler
+    assert window.on_resize._raw == window_on_resize_handler
+    initial_size = window.size
+
+    # Resize the window, on_resize() will be triggered
+    window.size = (200, 150)
+    assert window.size == (200, 150)
+    window_on_resize_handler.assert_called_with(window)
+    window_on_resize_handler.reset_mock()
+
+    # Resize to initial size, on_resize() will be triggered
+    window.size = initial_size
+    assert window.size == initial_size
+    window_on_resize_handler.assert_called_with(window)
+    window_on_resize_handler.reset_mock()
+
+    # Again request for resizing to initial size, on_resize()
+    # will not be triggered
+    window.size = initial_size
+    assert window.size == initial_size
+    window_on_resize_handler.assert_not_called()
+
+
 def test_as_image(window):
     """A window can be captured as an image."""
     image = window.as_image()

dummy/src/toga_dummy/window.py

@@ -108,6 +108,7 @@ def get_size(self) -> Size:
     def set_size(self, size):
         self._action("set size")
         self._size = size
+        self.interface.on_resize()
 
     ######################################################################
     # Window position

gtk/src/toga_gtk/libs/gtk.py

@@ -6,6 +6,7 @@
 gi.require_version("Gdk", gtk_version)
 gi.require_version("Gtk", gtk_version)
 
+from gi._gi import hook_up_vfunc_implementation  # noqa: E402, F401
 from gi.events import GLibEventLoopPolicy  # noqa: E402, F401
 from gi.repository import (  # noqa: E402, F401
     Gdk,

gtk/src/toga_gtk/libs/utils.py

@@ -11,3 +11,14 @@ def gtk_text_align(alignment):
         CENTER: (0.5, Gtk.Justification.CENTER),
         JUSTIFY: (0.0, Gtk.Justification.FILL),
     }[alignment]
+
+
+def create_toga_native(native_gtk_class):  # pragma: no-cover-if-gtk3
+    """Create a new native class from a native gtk class, whose virtual functions
+    could be safely overridden."""
+    toga_native_class = type(
+        native_gtk_class.__gtype__.name,
+        (native_gtk_class,),
+        {"base_class": native_gtk_class},  # Store the base class type
+    )
+    return toga_native_class

gtk/src/toga_gtk/libs/wrapper.py

@@ -0,0 +1,22 @@
+import weakref
+
+
+class WeakrefCallable:  # pragma: no-cover-if-gtk3
+    """
+    A wrapper for callable that holds a weak reference to it.
+
+    This can be useful in particular when setting gtk virtual function handlers,
+    to avoid cyclical reference cycles between python and gi that are detected
+    neither by the python garbage collector nor the gi.
+    """
+
+    def __init__(self, function):
+        try:
+            self.ref = weakref.WeakMethod(function)
+        except TypeError:  # pragma: no cover
+            self.ref = weakref.ref(function)
+
+    def __call__(self, *args, **kwargs):
+        function = self.ref()
+        if function:  # pragma: no branch
+            return function(*args, **kwargs)

gtk/src/toga_gtk/window.py

@@ -9,12 +9,15 @@
 from toga.window import _initial_position
 
 from .container import TogaContainer
-from .libs import GTK_VERSION, IS_WAYLAND, Gdk, GLib, Gtk
+from .libs import GTK_VERSION, IS_WAYLAND, Gdk, GLib, Gtk, hook_up_vfunc_implementation
+from .libs.utils import create_toga_native
 from .screens import Screen as ScreenImpl
 
 if TYPE_CHECKING:  # pragma: no cover
     from toga.types import PositionT, SizeT
 
+from .libs.wrapper import WeakrefCallable
+
 
 class Window:
     def __init__(self, interface, title, position, size):
@@ -23,6 +26,9 @@ def __init__(self, interface, title, position, size):
 
         self.layout = None
 
+        if GTK_VERSION >= (4, 0, 0):  # pragma: no-cover-if-gtk3
+            self._window_size = Size(0, 0)
+
         self.create()
         self.native._impl = self
 
@@ -42,10 +48,17 @@ def __init__(self, interface, title, position, size):
             self.native.connect("window-state-event", self.gtk_window_state_event)
             self.native.connect("focus-in-event", self.gtk_focus_in_event)
             self.native.connect("focus-out-event", self.gtk_focus_out_event)
+            self.native.connect("configure-event", self.gtk_configure_event)
         else:  # pragma: no-cover-if-gtk3
             self.native.connect("notify::fullscreened", self.gtk_window_state_event)
             self.native.connect("notify::maximized", self.gtk_window_state_event)
             self.native.connect("notify::minimized", self.gtk_window_state_event)
+            # do_size_allocate is a virtual function, used to track window resize.
+            hook_up_vfunc_implementation(
+                self.native.do_size_allocate,
+                self.native.__gtype__,
+                WeakrefCallable(self.gtk_do_size_allocate),
+            )
 
         self._window_state_flags = None
         self._in_presentation = False
@@ -82,11 +95,31 @@ def __init__(self, interface, title, position, size):
             self.native.set_child(self.layout)
 
     def create(self):
-        self.native = Gtk.Window()
+        if GTK_VERSION < (4, 0, 0):  # pragma: no-cover-if-gtk4
+            self.native = Gtk.Window()
+        else:  # pragma: no-cover-if-gtk3
+            self.native = create_toga_native(Gtk.Window)()
 
     ######################################################################
     # Native event handlers
     ######################################################################
+    def gtk_do_size_allocate(
+        self, native, width, height, baseline
+    ):  # pragma: no-cover-if-gtk3
+
+        # Note: Virtual methods can't use super() to access the original
+        # implementation, so they use native.base_class instead.
+
+        # Call the parent class's size_allocate via native.base_class.
+        native.base_class.do_size_allocate(native, width, height, baseline)
+
+        if self._window_size != (width, height):
+            self._window_size = Size(width, height)
+            self.interface.on_resize()
+
+    def gtk_configure_event(self, widget, data):  # pragma: no-cover-if-gtk4
+        self.interface.on_resize()
+
     def gtk_show(self, widget):
         self.interface.on_show()
 
@@ -228,12 +261,10 @@ def set_content(self, widget):
 
     def get_size(self) -> Size:
         if GTK_VERSION < (4, 0, 0):  # pragma: no-cover-if-gtk4
-            width, height = self.native.get_default_size()
             size = self.native.get_size()
             return Size(size.width, size.height)
         else:  # pragma: no-cover-if-gtk3
-            width, height = self.native.get_default_size()
-            return Size(width, height)
+            return self._window_size
 
     def set_size(self, size: SizeT):
         if GTK_VERSION < (4, 0, 0):  # pragma: no-cover-if-gtk4
@@ -444,7 +475,10 @@ def get_image_data(self):
 
 class MainWindow(Window):
     def create(self):
-        self.native = Gtk.ApplicationWindow()
+        if GTK_VERSION < (4, 0, 0):  # pragma: no-cover-if-gtk4
+            self.native = Gtk.ApplicationWindow()
+        else:  # pragma: no-cover-if-gtk3
+            self.native = create_toga_native(Gtk.ApplicationWindow)()
         if GTK_VERSION < (4, 0, 0):  # pragma: no-cover-if-gtk4
             self.native.set_role("MainWindow")
 

iOS/src/toga_iOS/app.py

@@ -51,6 +51,7 @@ def application_didChangeStatusBarOrientation_(
         """This callback is invoked when rotating the device from landscape to portrait
         and vice versa."""
         App.app.interface.main_window.content.refresh()
+        App.app.interface.current_window.on_resize()
 
 
 class App: