Implementation of Scaffolds layer for Apple platforms, with related fixes

cocoa/pyproject.toml

@@ -104,6 +104,9 @@ TimeInput = "toga_cocoa.widgets.timeinput:TimeInput"
 Tree = "toga_cocoa.widgets.tree:Tree"
 WebView = "toga_cocoa.widgets.webview:WebView"
 
+# Scaffolds
+Scaffold = "toga_cocoa.scaffolds.base:Scaffold"
+
 # Windows
 MainWindow = "toga_cocoa.window:MainWindow"
 Window = "toga_cocoa.window:Window"

cocoa/src/toga_cocoa/container.py

@@ -8,6 +8,7 @@
     NSLayoutConstraint,
     NSLayoutRelationGreaterThanOrEqual,
     NSView,
+    NSViewController,
 )
 
 #######################################################################################
@@ -131,3 +132,37 @@ def min_height(self):
     @min_height.setter
     def min_height(self, height):
         self._min_height_constraint.constant = height
+
+
+class ControlledContainer(Container):
+    def __init__(
+        self,
+        min_width=100,
+        min_height=100,
+        layout_native=None,
+        on_refresh=None,
+    ):
+        """A container for layouts, wrapped in an NSViewController.
+
+        Creates and enforces minimum size constraints on the container widget.
+        In addition, wrapped in NSViewController to facilitate attachment to various
+        other things like an NSSplitViewItem.
+
+        :param min_width: The minimum width to enforce on the container
+        :param min_height: The minimum height to enforce on the container
+        :param layout_native: The native widget that should be used to provide size
+            hints to the layout. By default, this will usually be the container widget
+            itself; however, for widgets like ScrollContainer where the layout needs to
+            be computed based on a different size to what will be rendered, the source
+            of the size can be different.
+        :param on_refresh: The callback to be notified when this container's layout is
+            refreshed.
+        """
+        super().__init__(
+            min_width=min_width,
+            min_height=min_height,
+            layout_native=layout_native,
+            on_refresh=on_refresh,
+        )
+        self.controller = NSViewController.alloc().init()
+        self.controller.view = self.native

cocoa/src/toga_cocoa/libs/appkit.py

@@ -750,6 +750,10 @@ def NSTextAlignment(alignment):
 NSBezelBorder = 2
 NSGrooveBorder = 3
 
+######################################################################
+# NSViewController.h
+NSViewController = ObjCClass("NSViewController")
+
 ######################################################################
 # NSWindow.h
 NSWindow = ObjCClass("NSWindow")
@@ -839,3 +843,8 @@ class NSDatePickerStyle(IntEnum):
 # NSDatePicker.h
 
 NSDatePicker = ObjCClass("NSDatePicker")
+
+######################################################################
+# NSKeyValueBinding.h
+
+NSTitleBinding = objc_const(appkit, "NSTitleBinding")

cocoa/src/toga_cocoa/scaffolds/base.py

@@ -0,0 +1,33 @@
+from toga_cocoa.container import ControlledContainer
+
+
+class Scaffold:
+    def __init__(self, interface):
+        self.interface = interface
+        self.container = ControlledContainer(on_refresh=self.content_refreshed)
+        # Expose the root controller for the window to embed
+        self.root_controller = self.container.controller
+
+    @property
+    def current_container(self):
+        return self.container
+
+    def set_content(self, widget):
+        self.container.content = widget
+
+    @property
+    def title(self):
+        return self.container.controller.title
+
+    @title.setter
+    def title(self, value):
+        self.container.controller.title = value
+
+    def refresh(self):
+        if self.container.content:
+            self.container.content.interface.refresh()
+
+    def content_refreshed(self, container):
+        # Apply the minimum size.  This will autoresize the window if needed.
+        self.container.min_width = self.interface.content.layout.min_width
+        self.container.min_height = self.interface.content.layout.min_height

cocoa/src/toga_cocoa/widgets/numberinput.py

@@ -190,16 +190,19 @@ def set_background_color(self, color):
             self.native_input.bezeled = True
             self.native_input.backgroundColor = native_color(color)
 
+    @property
     def has_focus(self):
         # When the NSTextField gets focus, a field editor is created, and that editor
         # has the original widget as the delegate. The first responder is the
         # Field Editor.
-        return isinstance(self.native.window.firstResponder, NSTextView) and (
-            self.native.window.firstResponder.delegate == self.native_input
+        return (
+            self.native.window is not None
+            and isinstance(self.native.window.firstResponder, NSTextView)
+            and (self.native.window.firstResponder.delegate == self.native_input)
         )
 
     def focus(self):
-        if not self.has_focus():
+        if self.interface.window and not self.has_focus:
             self.interface.window._impl.native.makeFirstResponder(self.native_input)
 
     def get_readonly(self):
@@ -224,7 +227,13 @@ def set_max_value(self, value):
             self.native_stepper.maxValue = float(value)
 
     def set_text_align(self, value):
+        if self.has_focus:
+            # Drop focus if we're currently focussed, or else alignment setting
+            # will not work properly with Cocoa
+            self.interface.window._impl.native.makeFirstResponder(None)
         self.native_input.alignment = NSTextAlignment(value)
+        # Refocus after we're done.
+        self.focus()
 
     def set_font(self, font):
         self.native_input.font = font._impl.native

cocoa/src/toga_cocoa/widgets/textinput.py

@@ -185,6 +185,10 @@ def set_placeholder(self, value):
         self.native.cell.placeholderString = value
 
     def set_text_align(self, value):
+        if self.has_focus:
+            # Drop focus if we're currently focussed, or else alignment setting
+            # will not work properly with Cocoa
+            self.interface.window._impl.native.makeFirstResponder(None)
         self.native.alignment = NSTextAlignment(value)
         # The alert label should be on the trailing edge
         if value == RIGHT:

cocoa/src/toga_cocoa/window.py

@@ -12,14 +12,14 @@
 from toga.constants import WindowState
 from toga.types import Position, Size
 from toga.window import _initial_position
-from toga_cocoa.container import Container
 from toga_cocoa.libs import (
     NSBackingStoreBuffered,
     NSImage,
     NSMutableArray,
     NSMutableDictionary,
     NSNumber,
     NSScreen,
+    NSTitleBinding,
     NSToolbar,
     NSToolbarItem,
     NSWindow,
@@ -135,7 +135,7 @@ def toolbarAllowedItemIdentifiers_(self, toolbar):  # pragma: no cover
         # can't ever be invoked - but we need to provide an implementation.
         allowed = NSMutableArray.alloc().init()
         for item in self.interface.toolbar:
-            allowed.addObject_(toolbar_identifier(item))
+            allowed.addObject(toolbar_identifier(item))
         return allowed
 
     @objc_method
@@ -151,8 +151,8 @@ def toolbarDefaultItemIdentifiers_(self, toolbar):
                 and item.group != prev_group
                 and not isinstance(item, Separator)
             ):
-                default.addObject_(toolbar_identifier(prev_group))
-            default.addObject_(toolbar_identifier(item))
+                default.addObject(toolbar_identifier(prev_group))
+            default.addObject(toolbar_identifier(item))
             prev_group = item.group
 
         return default
@@ -167,7 +167,7 @@ def toolbar_itemForItemIdentifier_willBeInsertedIntoToolbar_(
         """Create the requested toolbar button."""
         try:
             item = self.impl._toolbar_items[str(identifier)]
-            native = NSToolbarItem.alloc().initWithItemIdentifier_(identifier)
+            native = NSToolbarItem.alloc().initWithItemIdentifier(identifier)
             native.setLabel(item.text)
             native.setPaletteLabel(item.text)
             if item.tooltip:
@@ -208,7 +208,7 @@ def onToolbarButtonPress_(self, obj) -> None:
 
 
 class Window:
-    def __init__(self, interface, title, position, size):
+    def __init__(self, interface, position, size):
         self.interface = interface
         self.interface._impl = self
 
@@ -230,6 +230,12 @@ def __init__(self, interface, title, position, size):
             backing=NSBackingStoreBuffered,
             defer=False,
         )
+        self.native.bind(
+            NSTitleBinding,
+            toObject=self.native,
+            withKeyPath="contentViewController.title",
+            options=None,
+        )
         self.native.interface = self.interface
         self.native.impl = self
 
@@ -242,29 +248,20 @@ def __init__(self, interface, title, position, size):
         # Pending Window state transition variable:
         self._pending_state_transition = None
 
-        self.set_title(title)
         self.set_size(size)
         self.set_position(position if position is not None else _initial_position())
 
         self.native.delegate = self.native
 
-        self.container = Container(on_refresh=self.content_refreshed)
-        self.native.contentView = self.container.native
-
-        # Ensure that the container renders it's background in the same color as the
-        # window.
-        self.native.wantsLayer = True
-        self.container.native.backgroundColor = self.native.backgroundColor
-
     ######################################################################
     # Window properties
     ######################################################################
 
     def get_title(self):
-        return str(self.native.title)
+        return str(self._scaffold.title)
 
     def set_title(self, title):
-        self.native.title = title
+        self._scaffold.title = title
 
     ######################################################################
     # Window lifecycle
@@ -287,34 +284,31 @@ def show(self):
     # Window content and resources
     ######################################################################
 
-    def content_refreshed(self, container):
-        min_width = self.interface.content.layout.min_width
-        min_height = self.interface.content.layout.min_height
-
-        # If the minimum layout is bigger than the current window,
-        # increase the size of the window.
+    def set_scaffold(self, scaffold):
+        restore_presentation = False
+        if self.get_window_state() == WindowState.PRESENTATION:
+            restore_presentation = True
+            self.set_window_state(WindowState.NORMAL)
         frame = self.native.frame
-        if frame.size.width < min_width and frame.size.height < min_height:
-            self.set_size((min_width, min_height))
-        elif frame.size.width < min_width:
-            self.set_size((min_width, frame.size.height))
-        elif frame.size.height < min_height:
-            self.set_size((frame.size.width, min_height))
-
-        self.container.min_width = min_width
-        self.container.min_height = min_height
-
-    def set_content(self, widget):
+        # Get the current title and sync it up with the new scaffold.
+        # This check is required as the initial scaffold set will not have
+        # a previous scaffold to grab title from.
+        if hasattr(self, "_scaffold"):
+            scaffold.title = self.get_title()
+        self._scaffold = scaffold
         # Set the content of the window's container
-        self.container.content = widget
+        self.native.contentViewController = scaffold.root_controller
+        self.native.setFrame(frame, display=True, animate=False)
+        if restore_presentation:
+            self.set_window_state(WindowState.PRESENTATION)
 
     ######################################################################
     # Window size
     ######################################################################
 
     def get_size(self) -> Size:
         if self.interface.state == WindowState.PRESENTATION:
-            native_frame = self.container.native.frame
+            native_frame = self._scaffold.current_container.controller.view.frame
         else:
             native_frame = self.native.frame
         return Size(int(native_frame.size.width), int(native_frame.size.height))
@@ -384,7 +378,12 @@ def get_visible(self):
     def get_window_state(self, in_progress_state=False):
         if in_progress_state and self._pending_state_transition:
             return self._pending_state_transition
-        if self.container.native.isInFullScreenMode():
+        # Set scaffold will call get_window_state and back then during init there
+        # may not be any scaffold yet so we need to check the first condition
+        if (
+            hasattr(self, "_scaffold")
+            and self._scaffold.current_container.controller.view.isInFullScreenMode()
+        ):
             return WindowState.PRESENTATION
         elif self.native.styleMask & NSWindowStyleMask.FullScreen:
             return WindowState.FULLSCREEN
@@ -469,22 +468,25 @@ def _apply_state(self, target_state):
                 # window._impl.native.contentView is window._impl.container.native.
                 # Hence, we need to go fullscreen on window._impl.container.native
                 # instead.
-                self.container.native.enterFullScreenMode(
+                self._scaffold.current_container.controller.view.enterFullScreenMode(
                     self.interface.screen._impl.native, withOptions=opts
                 )
 
-                # Going presentation mode causes the window content to be re-homed in a
-                # NSFullScreenWindow; Teach the new parent window about its Toga
+                # Going presentation mode causes the window content 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
+                self._scaffold.current_container.controller.view.window._impl = self
+                self._scaffold.current_container.controller.view.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, since this is fully applied
+                # No need to check for other pending states, since this is fully
+                # applied
                 # at this point.
                 self._pending_state_transition = None
 
@@ -503,7 +505,9 @@ def _apply_state(self, target_state):
                 opts.setObject(
                     NSNumber.numberWithBool(True), forKey="NSFullScreenModeAllScreens"
                 )
-                self.container.native.exitFullScreenModeWithOptions(opts)
+                self._scaffold.current_container.controller.view.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.
@@ -520,11 +524,12 @@ def _apply_state(self, target_state):
     ######################################################################
 
     def get_image_data(self):
-        bitmap = self.container.native.bitmapImageRepForCachingDisplayInRect(
-            self.container.native.bounds
+        container = self._scaffold.current_container
+        bitmap = container.native.bitmapImageRepForCachingDisplayInRect(
+            container.native.bounds
         )
-        self.container.native.cacheDisplayInRect(
-            self.container.native.bounds, toBitmapImageRep=bitmap
+        container.native.cacheDisplayInRect(
+            container.native.bounds, toBitmapImageRep=bitmap
         )
 
         # Get a reference to the CGImage from the bitmap
@@ -539,8 +544,8 @@ def get_image_data(self):
 
 
 class MainWindow(Window):
-    def __init__(self, interface, title, position, size):
-        super().__init__(interface, title, position, size)
+    def __init__(self, interface, position, size):
+        super().__init__(interface, position, size)
 
         # By default, no toolbar
         self._toolbar_items = {}