A bunch of updates, mostly window fixes

Author: bbrk24

Package.swift

@@ -61,14 +61,15 @@ switch ProcessInfo.processInfo.environment["SCUI_LIBRARY_TYPE"] {
 
 let package = Package(
     name: "swift-cross-ui",
-    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13)],
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .macCatalyst(.v13)],
     products: [
         .library(name: "SwiftCrossUI", type: libraryType, targets: ["SwiftCrossUI"]),
         .library(name: "AppKitBackend", type: libraryType, targets: ["AppKitBackend"]),
         .library(name: "GtkBackend", type: libraryType, targets: ["GtkBackend"]),
         .library(name: "Gtk3Backend", type: libraryType, targets: ["Gtk3Backend"]),
         .library(name: "WinUIBackend", targets: ["WinUIBackend"]),
         .library(name: "DefaultBackend", type: libraryType, targets: ["DefaultBackend"]),
+        .library(name: "UIKitBackend", type: libraryType, targets: ["UIKitBackend"]),
         .library(name: "Gtk", type: libraryType, targets: ["Gtk"]),
         .executable(name: "GtkExample", targets: ["GtkExample"]),
         // .library(name: "CursesBackend", type: libraryType, targets: ["CursesBackend"]),
@@ -149,7 +150,7 @@ let package = Package(
                 // Non-desktop platforms need to be handled separately:
                 // Only one backend is supported, and `#if` won't work because it's evaluated
                 // on the compiling desktop, not the target.
-                .target(name: "UIKitBackend", condition: .when(platforms: [.iOS, .tvOS])),
+                .target(name: "UIKitBackend", condition: .when(platforms: [.iOS, .tvOS, .macCatalyst])),
             ]
         ),
         .target(name: "AppKitBackend", dependencies: ["SwiftCrossUI"]),

Sources/AppKitBackend/AppKitBackend.swift

@@ -71,6 +71,10 @@ public final class AppKitBackend: AppBackend {
         )
     }
 
+    public func isFixedSizeWindow(_ window: Window) -> Bool {
+        !window.styleMask.contains(.fullScreen)
+    }
+
     public func setSize(ofWindow window: Window, to newSize: SIMD2<Int>) {
         window.setContentSize(NSSize(width: newSize.x, height: newSize.y))
     }
@@ -175,18 +179,27 @@ public final class AppKitBackend: AppBackend {
     public static func createDefaultAboutMenu() -> NSMenu {
         let appName = ProcessInfo.processInfo.processName
         let appMenu = NSMenu(title: appName)
-        appMenu.addItem(withTitle: "About \(appName)", action: #selector(NSApp.orderFrontStandardAboutPanel(_:)), keyEquivalent: "")
+        appMenu.addItem(
+            withTitle: "About \(appName)",
+            action: #selector(NSApp.orderFrontStandardAboutPanel(_:)), keyEquivalent: "")
         appMenu.addItem(NSMenuItem.separator())
 
-        let hideMenu = appMenu.addItem(withTitle: "Hide \(appName)", action: #selector(NSApp.hide(_:)), keyEquivalent: "h")
+        let hideMenu = appMenu.addItem(
+            withTitle: "Hide \(appName)", action: #selector(NSApp.hide(_:)), keyEquivalent: "h")
         hideMenu.keyEquivalentModifierMask = .command
 
-        let hideOthers = appMenu.addItem(withTitle: "Hide Others", action: #selector(NSApp.hideOtherApplications(_:)), keyEquivalent: "h")
+        let hideOthers = appMenu.addItem(
+            withTitle: "Hide Others", action: #selector(NSApp.hideOtherApplications(_:)),
+            keyEquivalent: "h")
         hideOthers.keyEquivalentModifierMask = [.option, .command]
 
-        appMenu.addItem(withTitle: "Show All", action: #selector(NSApp.unhideAllApplications(_:)), keyEquivalent: "")
+        appMenu.addItem(
+            withTitle: "Show All", action: #selector(NSApp.unhideAllApplications(_:)),
+            keyEquivalent: "")
 
-        let quitMenu = appMenu.addItem(withTitle: "Quit \(appName)", action: #selector(NSApp.terminate(_:)), keyEquivalent: "q")
+        let quitMenu = appMenu.addItem(
+            withTitle: "Quit \(appName)", action: #selector(NSApp.terminate(_:)), keyEquivalent: "q"
+        )
         quitMenu.keyEquivalentModifierMask = .command
 
         return appMenu

Sources/GtkBackend/GtkBackend.swift

@@ -117,6 +117,11 @@ public final class GtkBackend: AppBackend {
         return SIMD2(size.width, size.height)
     }
 
+    public func isFixedSizeWindow(_ window: Window) -> Bool {
+        // TODO: Detect whether window is fullscreen
+        return false
+    }
+
     public func setSize(ofWindow window: Window, to newSize: SIMD2<Int>) {
         let child = window.getChild() as! CustomRootWidget
         window.size = Size(

Sources/SwiftCrossUI/Backend/AppBackend.swift

@@ -11,8 +11,9 @@ import Foundation
 /// ``AppBackend/setTitle(ofWindow:to:)``, ``AppBackend/setResizability(ofWindow:to:)``,
 /// ``AppBackend/setChild(ofWindow:to:)``, ``AppBackend/show(window:)``,
 /// ``AppBackend/runMainLoop()``, ``AppBackend/runInMainThread(action:)``,
-/// ``AppBackend/show(widget:)``. Many of these can simply be given dummy
-/// implementations until you're ready to implement them properly.
+/// ``AppBackend/isFixedSizeWindow(_:)``, ``AppBackend/show(widget:)``.
+/// Many of these can simply be given dummy implementations until you're ready
+/// to implement them properly.
 ///
 /// If you need to modify the children of a widget after creation but there
 /// aren't update methods available, this is an intentional limitation to
@@ -112,6 +113,9 @@ public protocol AppBackend {
     func setChild(ofWindow window: Window, to child: Widget)
     /// Gets the size of the given window in pixels.
     func size(ofWindow window: Window) -> SIMD2<Int>
+    /// Check whether a window is programmatically resizable. This value does not necessarily
+    /// reflect whether the window is resizable by the user.
+    func isFixedSizeWindow(_ window: Window) -> Bool
     /// Sets the size of the given window in pixels.
     func setSize(ofWindow window: Window, to newSize: SIMD2<Int>)
     /// Sets the minimum width and height of the window. Prevents the user from making the

Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift

@@ -66,13 +66,16 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             fatalError("Scene updated with a backend incompatible with the window it was given")
         }
 
+        let isFixedSize = backend.isFixedSizeWindow(window)
+
         _ = update(
             newScene,
-            proposedWindowSize: isFirstUpdate
+            proposedWindowSize: isFirstUpdate && !isFixedSize
                 ? (newScene ?? scene).defaultSize
                 : backend.size(ofWindow: window),
             backend: backend,
-            environment: environment
+            environment: environment,
+            windowSizeIsFinal: isFixedSize
         )
     }
 
@@ -147,17 +150,12 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             }
         }
 
-        let finalContentResult: ViewUpdateResult
-        if windowSizeIsFinal {
-            finalContentResult = contentResult
-        } else {
-            finalContentResult = viewGraph.update(
-                with: newScene?.body,
-                proposedSize: proposedWindowSize,
-                environment: environment,
-                dryRun: false
-            )
-        }
+        let finalContentResult = viewGraph.update(
+            with: newScene?.body,
+            proposedSize: proposedWindowSize,
+            environment: environment,
+            dryRun: false
+        )
 
         // The Gtk 3 backend has some broken sizing code that can't really be
         // fixed due to the design of Gtk 3. Our layout system underestimates

Sources/UIKitBackend/BaseWidget.swift

@@ -61,15 +61,15 @@ public class BaseWidget: UIView {
         leftConstraint?.isActive = false
         guard let superview else { return }
         leftConstraint = self.leftAnchor.constraint(
-            equalTo: superview.leftAnchor, constant: CGFloat(x))
+            equalTo: superview.safeAreaLayoutGuide.leftAnchor, constant: CGFloat(x))
         leftConstraint!.isActive = true
     }
 
     private func updateTopConstraint() {
         topConstraint?.isActive = false
         guard let superview else { return }
         topConstraint = self.topAnchor.constraint(
-            equalTo: superview.topAnchor, constant: CGFloat(y))
+            equalTo: superview.safeAreaLayoutGuide.topAnchor, constant: CGFloat(y))
         topConstraint!.isActive = true
     }
 
@@ -114,4 +114,8 @@ internal class WrapperWidget<View: UIView>: BaseWidget {
     var child: View {
         subviews[0] as! View
     }
+
+    override var intrinsicContentSize: CGSize {
+        child.intrinsicContentSize
+    }
 }

Sources/UIKitBackend/UIKitBackend+Container.swift

@@ -8,6 +8,60 @@
 import SwiftCrossUI
 import UIKit
 
+final class ScrollWidget: WrapperWidget<UIScrollView> {
+    private var childWidthConstraint: NSLayoutConstraint?
+    private var childHeightConstraint: NSLayoutConstraint?
+
+    private let innerChild: BaseWidget
+
+    init(child innerChild: BaseWidget) {
+        self.innerChild = innerChild
+        super.init(child: UIScrollView())
+
+        child.addSubview(innerChild)
+
+        NSLayoutConstraint.activate([
+            innerChild.topAnchor.constraint(equalTo: child.contentLayoutGuide.topAnchor),
+            innerChild.bottomAnchor.constraint(equalTo: child.contentLayoutGuide.bottomAnchor),
+            innerChild.leftAnchor.constraint(equalTo: child.contentLayoutGuide.leftAnchor),
+            innerChild.rightAnchor.constraint(equalTo: child.contentLayoutGuide.rightAnchor),
+        ])
+    }
+
+    func setScrollBars(
+        hasVerticalScrollBar: Bool,
+        hasHorizontalScrollBar: Bool
+    ) {
+        switch (hasVerticalScrollBar, childHeightConstraint?.isActive) {
+            case (true, true):
+                childHeightConstraint!.isActive = false
+            case (false, nil):
+                childHeightConstraint = innerChild.heightAnchor.constraint(
+                    equalTo: child.heightAnchor)
+                fallthrough
+            case (false, false):
+                childHeightConstraint!.isActive = true
+            default:
+                break
+        }
+
+        switch (hasHorizontalScrollBar, childWidthConstraint?.isActive) {
+            case (true, true):
+                childWidthConstraint!.isActive = false
+            case (false, nil):
+                childWidthConstraint = innerChild.widthAnchor.constraint(equalTo: child.widthAnchor)
+                fallthrough
+            case (false, false):
+                childWidthConstraint!.isActive = true
+            default:
+                break
+        }
+
+        child.showsVerticalScrollIndicator = hasVerticalScrollBar
+        child.showsHorizontalScrollIndicator = hasHorizontalScrollBar
+    }
+}
+
 extension UIKitBackend {
     public func createContainer() -> Widget {
         BaseWidget()
@@ -68,5 +122,18 @@ extension UIKitBackend {
         widget.height = size.y
     }
 
-    // TODO: Scroll containers
+    public func createScrollContainer(for child: Widget) -> Widget {
+        ScrollWidget(child: child)
+    }
+
+    public func setScrollBarPresence(
+        ofScrollContainer scrollView: Widget,
+        hasVerticalScrollBar: Bool,
+        hasHorizontalScrollBar: Bool
+    ) {
+        let scrollWidget = scrollView as! ScrollWidget
+        scrollWidget.setScrollBars(
+            hasVerticalScrollBar: hasVerticalScrollBar,
+            hasHorizontalScrollBar: hasHorizontalScrollBar)
+    }
 }

Sources/UIKitBackend/UIKitBackend+Control.swift

@@ -57,37 +57,69 @@ internal final class PickerWidget: WrapperWidget<UIPickerView>, UIPickerViewData
             child.reloadComponent(0)
         }
     }
-    var onSelect: ((Int) -> Void)?
+    var onSelect: ((Int?) -> Void)?
 
     init() {
         super.init(child: UIPickerView())
 
         child.dataSource = self
         child.delegate = self
+
+        child.selectRow(0, inComponent: 0, animated: false)
     }
 
     func numberOfComponents(in _: UIPickerView) -> Int {
         1
     }
 
     func pickerView(_: UIPickerView, numberOfRowsInComponent component: Int) -> Int {
-        options.count
+        options.count + 1
     }
 
     func pickerView(
         _: UIPickerView,
         titleForRow row: Int,
         forComponent _: Int
     ) -> String? {
-        options.indices ~= row ? options[row] : nil
+        switch row {
+            case 0:
+                ""
+            case 1...options.count:
+                options[row - 1]
+            default:
+                nil
+        }
     }
 
     func pickerView(
         _: UIPickerView,
         didSelectRow row: Int,
         inComponent _: Int
     ) {
-        onSelect?(row)
+        onSelect?(row > 0 ? row - 1 : nil)
+    }
+}
+
+internal final class SwitchWidget: WrapperWidget<UISwitch> {
+    var onChange: ((Bool) -> Void)?
+
+    @objc
+    func switchFlipped() {
+        onChange?(child.isOn)
+    }
+
+    init() {
+        super.init(child: UISwitch())
+
+        // On iOS 14 and later, UISwitch can be either a switch or a checkbox. We have no
+        // control over this on iOS 13 or any tvOS, but when possible, prefer a switch.
+        #if os(iOS) || targetEnvironment(macCatalyst)
+            if #available(iOS 14, macCatalyst 14, *) {
+                child.preferredStyle = .sliding
+            }
+        #endif
+
+        child.addTarget(self, action: #selector(switchFlipped), for: .valueChanged)
     }
 }
 
@@ -158,8 +190,21 @@ extension UIKitBackend {
     }
 
     public func setSelectedOption(ofPicker picker: Widget, to selectedOption: Int?) {
-        guard let selectedOption else { return }
         let pickerWidget = picker as! PickerWidget
-        pickerWidget.child.selectRow(selectedOption, inComponent: 0, animated: false)
+        pickerWidget.child.selectRow((selectedOption ?? -1) + 1, inComponent: 0, animated: false)
+    }
+
+    public func createSwitch() -> Widget {
+        SwitchWidget()
+    }
+
+    public func updateSwitch(_ switchWidget: Widget, onChange: @escaping (Bool) -> Void) {
+        let wrapper = switchWidget as! SwitchWidget
+        wrapper.onChange = onChange
+    }
+
+    public func setState(ofSwitch switchWidget: Widget, to state: Bool) {
+        let wrapper = switchWidget as! SwitchWidget
+        wrapper.child.setOn(state, animated: true)
     }
 }