[widget Audit] toga.SplitContainer

changes/1984.feature.rst

@@ -0,0 +1 @@
+The SplitContainer widget now has 100% test coverage, and complete API documentation.

changes/1984.removal.1.rst

@@ -0,0 +1 @@
+Support for SplitContainers with more than 2 panels of content has been removed.

changes/1984.removal.2.rst

@@ -0,0 +1 @@
+Support for 3-tuple form of specifying SplitContainer items, used to prevent panels from resizing, has been removed.

cocoa/src/toga_cocoa/container.py

@@ -19,14 +19,13 @@ def isFlipped(self) -> bool:
 
 
 class BaseContainer:
-    def __init__(self, content=None, on_refresh=None):
+    def __init__(self, on_refresh=None):
         """A base class for macOS containers.
 
-        :param content: The widget impl that is the container's initial content.
         :param on_refresh: The callback to be notified when this container's layout is
             refreshed.
         """
-        self._content = content
+        self._content = None
         self.on_refresh = on_refresh
         # macOS always renders at 96dpi. Scaling is handled
         # transparently at the level of the screen compositor.
@@ -60,20 +59,16 @@ def refreshed(self):
 
 
 class MinimumContainer(BaseContainer):
-    def __init__(self, content=None):
-        """A container for evaluating the minumum possible size for a layout
-
-        :param content: The widget impl that is the container's initial content.
-        """
-        super().__init__(content=content)
+    def __init__(self):
+        """A container for evaluating the minumum possible size for a layout"""
+        super().__init__()
         self.width = 0
         self.height = 0
 
 
 class Container(BaseContainer):
     def __init__(
         self,
-        content=None,
         min_width=100,
         min_height=100,
         layout_native=None,
@@ -83,7 +78,6 @@ def __init__(
 
         Creates and enforces minimum size constraints on the container widget.
 
-        :param content: The widget impl that is the container's initial content.
         :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
@@ -94,7 +88,8 @@ def __init__(
         :param on_refresh: The callback to be notified when this container's layout is
             refreshed.
         """
-        super().__init__(content=content, on_refresh=on_refresh)
+        super().__init__(on_refresh=on_refresh)
+
         self.native = TogaView.alloc().init()
         self.layout_native = self.native if layout_native is None else layout_native
 
@@ -133,8 +128,18 @@ def width(self):
     def height(self):
         return self.layout_native.frame.size.height
 
-    def set_min_width(self, width):
+    @property
+    def min_width(self):
+        return self._min_width_constraint.constant
+
+    @min_width.setter
+    def min_width(self, width):
         self._min_width_constraint.constant = width
 
-    def set_min_height(self, height):
+    @property
+    def min_height(self):
+        return self._min_height_constraint.constant
+
+    @min_height.setter
+    def min_height(self, height):
         self._min_height_constraint.constant = height

cocoa/src/toga_cocoa/widgets/multilinetextinput.py

@@ -34,9 +34,6 @@ def create(self):
         self.native.autohidesScrollers = False
         self.native.borderType = NSBezelBorder
 
-        # Disable all autolayout functionality on the outer widget
-        self.native.translatesAutoresizingMaskIntoConstraints = False
-
         # Create the actual text widget
         self.native_text = TogaTextView.alloc().init()
         self.native_text.interface = self.interface

cocoa/src/toga_cocoa/widgets/splitcontainer.py

@@ -1,84 +1,132 @@
-from rubicon.objc import objc_method, objc_property
+from rubicon.objc import SEL, objc_method, objc_property
 from travertino.size import at_least
 
-from toga_cocoa.container import Container
-from toga_cocoa.libs import NSObject, NSSize, NSSplitView
+from toga.constants import Direction
+from toga_cocoa.container import Container, MinimumContainer
+from toga_cocoa.libs import NSSplitView
 
 from .base import Widget
 
 
-class TogaSplitViewDelegate(NSObject):
+class TogaSplitView(NSSplitView):
     interface = objc_property(object, weak=True)
     impl = objc_property(object, weak=True)
 
-    @objc_method
-    def splitView_resizeSubviewsWithOldSize_(self, view, size: NSSize) -> None:
-        # Turn all the weights into a fraction of 1.0
-        total = sum(self.interface._weight)
-        self.interface._weight = [weight / total for weight in self.interface._weight]
-
-        # Mark the subviews as needing adjustment
-        view.adjustSubviews()
-
-        # Set the splitter positions based on the new weight fractions.
-        cumulative = 0.0
-        if self.interface.direction == self.interface.VERTICAL:
-            for i, weight in enumerate(self.interface._weight[:-1]):
-                cumulative += weight
-                view.setPosition(view.frame.size.width * cumulative, ofDividerAtIndex=i)
-        else:
-            for i, weight in enumerate(self.interface._weight[:-1]):
-                cumulative += weight
-                view.setPosition(
-                    view.frame.size.height * cumulative, ofDividerAtIndex=i
-                )
-
     @objc_method
     def splitViewDidResizeSubviews_(self, notification) -> None:
-        # If the window is actually visible, and the split has moved,
-        # a resize of all the content panels is required. The refresh
-        # needs to be directed at the root container holding the widget,
-        # as the splitview may not be the root container.
-        if self.interface.window and self.interface.window._impl.native.isVisible:
-            self.interface.refresh()
-            self.impl.on_resize()
+        # If the split has moved, a resize of all the content panels is required.
+        for container in self.impl.sub_containers:
+            container.content.interface.refresh()
 
+        # Apply any pending split
+        self.performSelector(
+            SEL("applySplit"),
+            withObject=None,
+            afterDelay=0,
+        )
 
-class SplitContainer(Widget):
-    """Cocoa SplitContainer implementation.
+    @objc_method
+    def applySplit(self) -> None:
+        if self.impl._split_proportion:
+            if self.interface.direction == self.interface.VERTICAL:
+                position = self.impl._split_proportion * self.frame.size.width
+            else:
+                position = self.impl._split_proportion * self.frame.size.height
+
+            self.setPosition(position, ofDividerAtIndex=0)
+            self.impl._split_proportion = None
 
-    Todo:
-        * update the minimum width of the whole SplitContainer based on the content of its sub layouts.
-    """
 
+class SplitContainer(Widget):
     def create(self):
-        self.native = NSSplitView.alloc().init()
+        self.native = TogaSplitView.alloc().init()
+        self.native.interface = self.interface
+        self.native.impl = self
+        self.native.delegate = self.native
+
+        self.sub_containers = [Container(), Container()]
+        self.native.addSubview(self.sub_containers[0].native)
+        self.native.addSubview(self.sub_containers[1].native)
 
-        self.delegate = TogaSplitViewDelegate.alloc().init()
-        self.delegate.interface = self.interface
-        self.delegate.impl = self
-        self.native.delegate = self.delegate
+        self._split_proportion = None
 
         # Add the layout constraints
         self.add_constraints()
 
-    def add_content(self, position, widget, flex):
-        # TODO: add flex option to the implementation
-        container = Container(content=widget)
-
-        # Turn the autoresizing mask on the widget into constraints.
-        # This makes the widget fill the available space inside the
-        # SplitContainer.
-        # FIXME Use Constraints to enforce min width and height of the widgets otherwise width of 0 is possible.
-        container.native.translatesAutoresizingMaskIntoConstraints = True
-        self.native.addSubview(container.native)
+    def set_bounds(self, x, y, width, height):
+        super().set_bounds(x, y, width, height)
+        for container in self.sub_containers:
+            if container.content:
+                container.content.interface.refresh()
+
+        # Apply any pending split
+        self.native.performSelector(
+            SEL("applySplit"),
+            withObject=None,
+            afterDelay=0,
+        )
+
+    def set_content(self, content, flex):
+        # Clear any existing content
+        for container in self.sub_containers:
+            container.content = None
+
+        for index, widget in enumerate(content):
+            # Compute the minimum layout for the content
+            if widget:
+                widget.interface.style.layout(widget.interface, MinimumContainer())
+                min_width = widget.interface.layout.width
+                min_height = widget.interface.layout.height
+
+                # Create a container with that minimum size, and assign the widget as content
+                self.sub_containers[index].min_width = min_width
+                self.sub_containers[index].min_height = min_height
+
+                self.sub_containers[index].content = widget
+            else:
+                self.sub_containers[index].min_width = 0
+                self.sub_containers[index].min_height = 0
+
+        # We now know the initial positions of the split. However, we can't *set* the
+        # because Cocoa requires a pixel position, and the widget isn't visible yet.
+        # So - store the split; and when have a displayed widget, apply that proportion.
+        self._split_proportion = flex[0] / sum(flex)
+
+    def get_direction(self):
+        return Direction.VERTICAL if self.native.isVertical() else Direction.HORIZONTAL
 
     def set_direction(self, value):
         self.native.vertical = value
 
-    def on_resize(self):
-        pass
-
     def rehint(self):
-        self.interface.intrinsic.width = at_least(self.interface._MIN_WIDTH)
-        self.interface.intrinsic.height = at_least(self.interface._MIN_HEIGHT)
+        # This is a SWAG (scientific wild-ass guess). There doesn't appear to be
+        # an actual API to get the true size of the splitter. 10px seems enough.
+        SPLITTER_WIDTH = 10
+        if self.interface.direction == self.interface.HORIZONTAL:
+            # When the splitter is horizontal, the splitcontainer must be
+            # at least as wide as it's widest sub-container, and at least
+            # as tall as the minimum height of all subcontainers, plus the
+            # height of the splitter itself. Enforce a minimum size in both
+            # axies
+            min_width = self.interface._MIN_WIDTH
+            min_height = 0
+            for sub_container in self.sub_containers:
+                min_width = max(min_width, sub_container.min_width)
+                min_height += sub_container.min_height
+
+            min_height = max(min_height, self.interface._MIN_HEIGHT) + SPLITTER_WIDTH
+        else:
+            # When the splitter is vertical, the splitcontainer must be
+            # at least as tall as it's tallest sub-container, and at least
+            # as wide as the minimum width of all subcontainers, plus the
+            # width of the splitter itself.
+            min_width = 0
+            min_height = self.interface._MIN_HEIGHT
+            for sub_container in self.sub_containers:
+                min_width += sub_container.min_width
+                min_height = max(min_height, sub_container.min_height)
+
+            min_width = max(min_width, self.interface._MIN_WIDTH) + SPLITTER_WIDTH
+
+        self.interface.intrinsic.width = at_least(min_width)
+        self.interface.intrinsic.height = at_least(min_height)

cocoa/src/toga_cocoa/window.py

@@ -239,8 +239,8 @@ def show(self):
             self.interface.content,
             MinimumContainer(),
         )
-        self.container.set_min_width(self.interface.content.layout.width)
-        self.container.set_min_height(self.interface.content.layout.height)
+        self.container.min_width = self.interface.content.layout.width
+        self.container.min_height = self.interface.content.layout.height
 
         # Refresh with the actual viewport to do the proper rendering.
         self.interface.content.refresh()

cocoa/tests_backend/widgets/splitcontainer.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from toga_cocoa.libs import NSSplitView
+
+from .base import SimpleProbe
+
+
+class SplitContainerProbe(SimpleProbe):
+    native_class = NSSplitView
+
+    def move_split(self, position):
+        self.native.setPosition(position, ofDividerAtIndex=0)
+
+    async def wait_for_split(self):
+        sub1 = self.impl.sub_containers[0].native.frame.size
+        position = sub1.height, sub1.width
+        current = None
+        while position != current:
+            position = current
+            await asyncio.sleep(0.05)
+            current = sub1.height, sub1.width

core/src/toga/constants/__init__.py

@@ -1 +1,9 @@
+from enum import Enum
+
 from travertino.constants import *  # noqa: F401, F403
+
+
+class Direction(Enum):
+    "The direction a given property should act"
+    HORIZONTAL = 0
+    VERTICAL = 1

core/src/toga/widgets/divider.py

@@ -1,27 +1,31 @@
 from __future__ import annotations
 
+from toga.constants import Direction
+
 from .base import Widget
 
 
 class Divider(Widget):
-    HORIZONTAL = 0
-    VERTICAL = 1
+    HORIZONTAL = Direction.HORIZONTAL
+    VERTICAL = Direction.VERTICAL
 
     def __init__(
         self,
         id=None,
         style=None,
-        direction=HORIZONTAL,
+        direction: Direction = HORIZONTAL,
     ):
         """Create a new divider line.
 
         Inherits from :class:`toga.Widget`.
 
         :param id: The ID for the widget.
-        :param style: A style object. If no style is provided, a default style
-            will be applied to the widget.
-        :param direction: The direction in which the divider will be drawn.
-            Defaults to ``Divider.HORIZONTAL``
+        :param style: A style object. If no style is provided, a default style will be
+            applied to the widget.
+        :param direction: The direction in which the divider will be drawn. Either
+            :attr:`~toga.constants.Direction.HORIZONTAL` or
+            :attr:`~toga.constants.Direction.VERTICAL`; defaults to
+            :attr:`~toga.constants.Direction.HORIZONTAL`
         """
         super().__init__(id=id, style=style)
 
@@ -47,11 +51,8 @@ def focus(self):
         pass
 
     @property
-    def direction(self):
-        """The direction in which the visual separator will be drawn.
-
-        :returns: ``Divider.HORIZONTAL`` or ``Divider.VERTICAL``
-        """
+    def direction(self) -> Direction:
+        """The direction in which the visual separator will be drawn."""
         return self._impl.get_direction()
 
     @direction.setter