Add RenderBoxView and RBLayer integration

Package.swift

@@ -226,6 +226,7 @@ var sharedSwiftSettings: [SwiftSetting] = [
     .swiftLanguageMode(.v5),
 
     .define("OPENSWIFTUI_RELEASE_\(releaseVersion)"),
+    .unsafeFlags(["-Xfrontend", "-experimental-spi-only-imports"]),
 ]
 
 // Modified from: https://github.com/swiftlang/swift/blob/main/SwiftCompilerSources/Package.swift

Sources/OpenSwiftUI/Integration/Hosting/AppKit/NSViewPlatformViewDefinition.swift → Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift

@@ -1,17 +1,18 @@
 //
-//  NSViewPlatformViewDefinition.swift
+//  AppKitDisplayList.swift
 //  OpenSwiftUI
 //
 //  Audited for 6.0.87
 //  Status: WIP
-//  ID: 33EEAA67E0460DA84AE814EA027152BA (SwiftUI?)
+//  ID: 33EEAA67E0460DA84AE814EA027152BA (SwiftUI)
 
 #if os(macOS)
 @_spi(DisplayList_ViewSystem) import OpenSwiftUICore
 import AppKit
 import OpenSwiftUISymbolDualTestsSupport
 import COpenSwiftUI
 import CoreAnimation_Private
+import OpenSwiftUI_SPI
 
 // MARK: - NSViewPlatformViewDefinition [TODO]
 
@@ -84,6 +85,40 @@ final class NSViewPlatformViewDefinition: PlatformViewDefinition, @unchecked Sen
     }
 }
 
+// MARK: - _NSGraphicsView
+
+typealias PlatformGraphicsView = _NSGraphicsView
+
+class _NSGraphicsView: NSView {
+    var recursiveIgnoreHitTest: Bool = false
+
+    var customAcceptsFirstMouse: Bool?
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+}
+
+// MARK: - _NSInheritedView
+
+typealias PlatformInheritedView = _NSInheritedView
+
+class _NSInheritedView: _NSGraphicsView {
+    var hitTestsAsOpaque: Bool = false
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+}
+
 // MARK: - _NSProjectionView [6.5.4]
 
 @objc

Sources/OpenSwiftUI/Render/DisplayList/DisplayListViewDrawing.swift

@@ -0,0 +1,148 @@
+//
+//  DisplayListViewDrawing.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: WIP
+//  ID: 65A81BD07F0108B0485D2E15DE104A75 (SwiftUI)
+
+#if canImport(Darwin)
+
+@_spi(DisplayList_ViewSystem)
+import OpenSwiftUICore
+import QuartzCore
+import OpenRenderBoxShims
+
+#if os(iOS) || os(visionOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
+
+// MARK: - CGDrawingView
+
+final class CGDrawingView: PlatformGraphicsView, PlatformDrawable {
+    var options: PlatformDrawableOptions
+
+    init(options: PlatformDrawableOptions) {
+        self.options = options
+        super.init(frame: .zero)
+        isOpaque = options.isOpaque
+        layer.contentsFormat = options.caLayerContentsFormat
+    }
+
+    required init?(coder: NSCoder) {
+        _openSwiftUIUnreachableCode()
+    }
+
+    override class var layerClass: AnyClass {
+        CGDrawingLayer.self
+    }
+
+    static var allowsContentsMultiplyColor: Bool {
+        true
+    }
+
+    func update(content: PlatformDrawableContent?, required: Bool) -> Bool {
+        let layer = layer as! CGDrawingLayer
+        if let content {
+            layer.content = content
+        }
+        layer.setNeedsDisplay()
+        return true
+    }
+
+    func makeAsyncUpdate(content: PlatformDrawableContent, required: Bool, layer: CALayer, bounds: CGRect) -> (() -> Void)? {
+        return nil
+    }
+
+    func setContentsScale(_ scale: CGFloat) {
+        layer.contentsScale = scale
+    }
+
+    func drawForTesting(in displayList: ORBDisplayList) {
+        var state = PlatformDrawableContent.State()
+        let layer = layer as! CGDrawingLayer
+        layer.content.draw(in: displayList, size: bounds.size, state: &state)
+    }
+}
+
+// MARK: - CGDrawingLayer
+
+private final class CGDrawingLayer: CALayer {
+    var content: PlatformDrawableContent = .init()
+    var state: PlatformDrawableContent.State = .init()
+
+    override func draw(in ctx: CGContext) {
+        content.draw(
+            in: ctx,
+            size: bounds.size,
+            contentsScale: contentsScale,
+            state: &state
+        )
+    }
+}
+
+// MARK: - RBDrawingView [WIP]
+
+final class RBDrawingView: RenderBoxView, PlatformDrawable {
+    var options: PlatformDrawableOptions {
+        didSet {
+            guard oldValue != options else {
+                return
+            }
+            updateOptions()
+        }
+    }
+
+    private struct State {
+        var content: PlatformDrawableContent = .init()
+        var renderer: PlatformDrawableContent.State = .init()
+    }
+
+    @AtomicBox
+    private var state: RBDrawingView.State = .init()
+
+    init(options: PlatformDrawableOptions) {
+        self.options = options
+        super.init(frame: .zero)
+        updateOptions()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError()
+    }
+
+    private func updateOptions() {
+        isOpaque = options.isOpaque
+        options.update(rbLayer: layer)
+        rendersFirstFrameAsynchronously = options.rendersFirstFrameAsynchronously
+    }
+
+    static var allowsContentsMultiplyColor: Bool {
+        _openSwiftUIUnimplementedFailure()
+    }
+
+    func update(content: PlatformDrawableContent?, required: Bool) -> Bool {
+        _openSwiftUIUnimplementedFailure()
+
+    }
+
+    func makeAsyncUpdate(content: PlatformDrawableContent, required: Bool, layer: CALayer, bounds: CGRect) -> (() -> Void)? {
+        _openSwiftUIUnimplementedFailure()
+
+    }
+
+    func setContentsScale(_ scale: CGFloat) {
+        _openSwiftUIUnimplementedFailure()
+
+    }
+
+    func drawForTesting(in: ORBDisplayList) {
+        _openSwiftUIUnimplementedFailure()
+
+    }
+}
+
+#endif
+

Sources/OpenSwiftUI/Render/DisplayList/RenderBoxView.swift

@@ -0,0 +1,89 @@
+//
+//  RenderBoxView.swift
+//  OpenSwiftUI
+//
+//  Audited for 6.5.4
+//  Status: Complete
+//  ID: 0CB954C9DC99A8A907C58D7882F9389E (SwiftUI)
+
+#if canImport(Darwin)
+import Foundation
+import QuartzCore
+import CoreAnimation_Private
+import OpenRenderBoxShims
+
+// MARK: - RenderBoxView
+
+@objc
+class RenderBoxView: PlatformGraphicsView {
+    var rendersFirstFrameAsynchronously: Bool
+
+    override class var layerClass: AnyClass {
+        RenderBoxLayer.self
+    }
+
+    override init(frame: CGRect) {
+        rendersFirstFrameAsynchronously = false
+        super.init(frame: frame)
+        let layer = layer
+        layer.delegate = self
+        layer.isOpaque = isOpaque
+    }
+
+    required init?(coder: NSCoder) {
+        rendersFirstFrameAsynchronously = false
+        super.init(coder: coder)
+        let layer = layer
+        layer.delegate = self
+        layer.isOpaque = isOpaque
+    }
+
+    deinit {
+        (layer as! RenderBoxLayer).waitUntilAsyncRenderingCompleted()
+    }
+
+    override var isOpaque: Bool {
+        get { super.isOpaque }
+        set {
+            layer.isOpaque = newValue
+            super.isOpaque = newValue
+        }
+    }
+
+    override func didMoveToWindow() {
+        guard let window else { return }
+        layer.contentsScale = window.screen.scale
+        setNeedsDisplay()
+    }
+
+    override func setNeedsDisplay() {
+        layer.setNeedsDisplay()
+    }
+}
+
+extension RenderBoxView: RBLayerDelegate {
+    func rbLayer(_ layer: RBLayer, draw inDisplayList: RBDisplayList) {
+    }
+}
+
+// MARK: - RenderBoxLayer
+
+private class RenderBoxLayer: RBLayer {
+    override var needsSynchronousUpdate: Bool {
+        get {
+            guard super.needsSynchronousUpdate else {
+                return false
+            }
+            guard let delegate = delegate as? RenderBoxView,
+                  delegate.rendersFirstFrameAsynchronously
+            else {
+                return true
+            }
+            return hasBeenCommitted
+        }
+        set {
+            super.needsSynchronousUpdate = newValue
+        }
+    }
+}
+#endif