Create ...Representable protocol for each b-end (fix ui/appkit ones)

Author: stackotter

Examples/CustomButton.d

@@ -19,9 +19,11 @@ struct CounterApp: App {
     @State var name = ""
 
     var body: some Scene {
-        WindowGroup("CounterExample: \(count)") {
+        WindowGroup("Inspect modifier and custom native views") {
             #hotReloadable {
                 ScrollView {
+                    CustomButton(label: "Custom native button")
+
                     HStack(spacing: 20) {
                         Button("-") {
                             count -= 1
@@ -32,10 +34,7 @@ struct CounterApp: App {
                                 #if canImport(AppKitBackend)
                                     text.isSelectable = true
                                 #elseif canImport(UIKitBackend)
-                                    #if !targetEnvironment(macCatalyst)
-                                        text.isHighlighted = true
-                                        text.highlightTextColor = .yellow
-                                    #endif
+                                    text.isUserInteractionEnabled = true
                                 #elseif canImport(WinUIBackend)
                                     text.isTextSelectionEnabled = true
                                 #elseif canImport(GtkBackend)

Examples/CustomButton.o

@@ -0,0 +1,111 @@
+struct CustomButton {
+    typealias Coordinator = Void
+
+    var label: String
+}
+
+#if canImport(GtkBackend)
+    import GtkBackend
+    import Gtk
+
+    extension CustomButton: GtkWidgetRepresentable {
+        func makeGtkWidget(context: GtkWidgetRepresentableContext<Coordinator>) -> Gtk.Button {
+            Gtk.Button()
+        }
+
+        func updateGtkWidget(
+            _ button: Gtk.Button,
+            context: GtkWidgetRepresentableContext<Coordinator>
+        ) {
+            button.label = label
+            button.css.clear()
+            button.css.set(properties: [.backgroundColor(.init(1, 0, 1, 1))])
+        }
+    }
+#endif
+
+#if canImport(Gtk3Backend)
+    import Gtk3Backend
+    import Gtk3
+
+    extension CustomButton: Gtk3WidgetRepresentable {
+        func makeGtk3Widget(context: Gtk3WidgetRepresentableContext<Coordinator>) -> Gtk3.Button {
+            Gtk3.Button()
+        }
+
+        func updateGtk3Widget(
+            _ button: Gtk3.Button,
+            context: Gtk3WidgetRepresentableContext<Coordinator>
+        ) {
+            button.label = label
+            button.css.clear()
+            button.css.set(properties: [.backgroundColor(.init(1, 0, 1, 1))])
+        }
+    }
+#endif
+
+#if canImport(AppKitBackend)
+    import AppKitBackend
+    import AppKit
+
+    extension CustomButton: NSViewRepresentable {
+        func makeNSView(context: NSViewRepresentableContext<Coordinator>) -> NSButton {
+            NSButton()
+        }
+
+        func updateNSView(
+            _ button: NSButton,
+            context: NSViewRepresentableContext<Coordinator>
+        ) {
+            button.title = label
+            button.bezelColor = .magenta
+        }
+    }
+#endif
+
+#if canImport(UIKitBackend)
+    import UIKitBackend
+    import UIKit
+
+    extension CustomButton: UIViewRepresentable {
+        func makeUIView(context: UIViewRepresentableContext<Coordinator>) -> UIButton {
+            UIButton()
+        }
+
+        func updateUIView(
+            _ button: UIButton,
+            context: UIViewRepresentableContext<Coordinator>
+        ) {
+            button.setTitle(label, for: .normal)
+            if #available(iOS 15.0, *) {
+                button.configuration = .bordered()
+            }
+        }
+    }
+#endif
+
+#if canImport(WinUIBackend)
+    import WinUIBackend
+    import WinUI
+    import UWP
+
+    extension CustomButton: WinUIElementRepresentable {
+        func makeWinUIElement(
+            context: WinUIElementRepresentableContext<Coordinator>
+        ) -> WinUI.Button {
+            WinUI.Button()
+        }
+
+        func updateWinUIElement(
+            _ button: WinUI.Button,
+            context: WinUIElementRepresentableContext<Coordinator>
+        ) {
+            let block = TextBlock()
+            block.text = label
+            button.content = block
+            let brush = WinUI.SolidColorBrush()
+            brush.color = UWP.Color(a: 255, r: 255, g: 0, b: 255)
+            button.background = brush
+        }
+    }
+#endif

Examples/CustomButton.swiftdeps

@@ -65,7 +65,7 @@ public protocol NSViewRepresentable: View where Content == Never {
     /// This method is called after all AppKit lifecycle methods, such as
     /// `nsView.didMoveToSuperview()`. The default implementation does nothing.
     /// - Parameters:
-    ///   - nsVIew: The view being dismantled.
+    ///   - nsView: The view being dismantled.
     ///   - coordinator: The coordinator.
     static func dismantleNSView(_ nsView: NSViewType, coordinator: Coordinator)
 }
@@ -76,32 +76,43 @@ extension NSViewRepresentable {
     }
 
     public func determineViewSize(
-        for proposal: SIMD2<Int>, nsView: NSViewType,
+        for proposal: SIMD2<Int>,
+        nsView: NSViewType,
         context _: NSViewRepresentableContext<Coordinator>
     ) -> ViewSize {
         let intrinsicSize = nsView.intrinsicContentSize
         let sizeThatFits = nsView.fittingSize
 
         let roundedSizeThatFits = SIMD2(
             Int(sizeThatFits.width.rounded(.up)),
-            Int(sizeThatFits.height.rounded(.up)))
+            Int(sizeThatFits.height.rounded(.up))
+        )
         let roundedIntrinsicSize = SIMD2(
             Int(intrinsicSize.width.rounded(.awayFromZero)),
-            Int(intrinsicSize.height.rounded(.awayFromZero)))
+            Int(intrinsicSize.height.rounded(.awayFromZero))
+        )
 
         return ViewSize(
             size: SIMD2(
-                intrinsicSize.width < 0.0 ? proposal.x : roundedSizeThatFits.x,
-                intrinsicSize.height < 0.0 ? proposal.y : roundedSizeThatFits.y
+                intrinsicSize.width < 0.0
+                    ? proposal.x
+                    : max(min(proposal.x, roundedSizeThatFits.x), roundedIntrinsicSize.x),
+                intrinsicSize.height < 0.0
+                    ? proposal.y
+                    : max(min(proposal.y, roundedSizeThatFits.y), roundedIntrinsicSize.y)
             ),
             // The 10 here is a somewhat arbitrary constant value so that it's always the same.
             // See also `Color` and `Picker`, which use the same constant.
             idealSize: SIMD2(
                 intrinsicSize.width < 0.0 ? 10 : roundedIntrinsicSize.x,
                 intrinsicSize.height < 0.0 ? 10 : roundedIntrinsicSize.y
             ),
+            // We don't have a nice way of measuring these, so just set them to the
+            // view's minimum sizes along each dimension to at least be correct.
+            idealWidthForProposedHeight: max(0, roundedSizeThatFits.x),
+            idealHeightForProposedWidth: max(0, roundedSizeThatFits.y),
             minimumWidth: max(0, roundedIntrinsicSize.x),
-            minimumHeight: max(0, roundedIntrinsicSize.x),
+            minimumHeight: max(0, roundedIntrinsicSize.y),
             maximumWidth: nil,
             maximumHeight: nil
         )
@@ -154,6 +165,9 @@ extension View where Self: NSViewRepresentable {
         let representingWidget = widget as! RepresentingWidget<Self>
         representingWidget.update(with: environment)
 
+        // We need to do this for `fittingSize` to work correctly (it takes all
+        // constraints into account).
+        backend.setSize(of: representingWidget, to: proposedSize)
         let size = representingWidget.representable.determineViewSize(
             for: proposedSize,
             nsView: representingWidget.subview,
@@ -209,14 +223,17 @@ final class RepresentingWidget<Representable: NSViewRepresentable>: NSView {
     }()
 
     func update(with environment: EnvironmentValues) {
-        if context == nil {
-            context = .init(
+        if var context {
+            context.environment = environment
+            representable.updateNSView(subview, context: context)
+            self.context = context
+        } else {
+            let context = NSViewRepresentableContext(
                 coordinator: representable.makeCoordinator(),
                 environment: environment
             )
-        } else {
-            context!.environment = environment
-            representable.updateNSView(subview, context: context!)
+            self.context = context
+            representable.updateNSView(subview, context: context)
         }
     }
 

Examples/CustomButton.swiftdeps~

@@ -41,8 +41,8 @@ open class Fixed: Widget {
     public var children: [Widget] = []
 
     /// Creates a new `GtkFixed`.
-    public convenience init() {
-        self.init(gtk_fixed_new())
+    public init() {
+        super.init(gtk_fixed_new())
     }
 
     public func put(_ child: Widget, x: Double, y: Double) {

Examples/Sources/AdvancedCustomizationExample/AdvancedCustomizationApp.swift

@@ -82,6 +82,38 @@ open class Widget: GObject {
         )
     }
 
+    public struct MeasureResult {
+        public var minimum: Int
+        public var natural: Int
+        public var minimumBaseline: Int
+        public var naturalBaseline: Int
+    }
+
+    public func measure(
+        orientation: Orientation,
+        forPerpendicularSize perpendicularSize: Int
+    ) -> MeasureResult {
+        var minimum: Int32 = 0
+        var natural: Int32 = 0
+        var minimumBaseline: Int32 = 0
+        var naturalBaseline: Int32 = 0
+        gtk_widget_measure(
+            widgetPointer,
+            orientation.toGtk(),
+            Int32(perpendicularSize),
+            &minimum,
+            &natural,
+            &minimumBaseline,
+            &naturalBaseline
+        )
+        return MeasureResult(
+            minimum: Int(minimum),
+            natural: Int(natural),
+            minimumBaseline: Int(minimumBaseline),
+            naturalBaseline: Int(naturalBaseline)
+        )
+    }
+
     public func insertActionGroup(_ name: String, _ actionGroup: any GActionGroup) {
         gtk_widget_insert_action_group(
             widgetPointer,

Examples/Sources/AdvancedCustomizationExample/CustomButton.swift

@@ -37,12 +37,12 @@ import CGtk3
 /// If you know none of these things are an issue for your application,
 /// and prefer the simplicity of `GtkFixed`, by all means use the
 /// widget. But you should be aware of the tradeoffs.
-public class Fixed: Widget {
+open class Fixed: Widget {
     public var children: [Widget] = []
 
     /// Creates a new `GtkFixed`.
-    public convenience init() {
-        self.init(gtk_fixed_new())
+    public init() {
+        super.init(gtk_fixed_new())
     }
 
     public func put(_ child: Widget, x: Int, y: Int) {