diff --git a/Package.resolved b/Package.resolved index c783dbfe5..d0eec9faf 100644 --- a/Package.resolved +++ b/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "76c8cae8132f5d5205a1166d013709a22af196cc16b4ce364daefb62bb6b6f32", + "originHash" : "5674484bf7bbc724d2ca67ef1cd44e23efdec1b5c043a67cf261ccee1aa0127c", "pins" : [ { "identity" : "darwinprivateframeworks", @@ -7,7 +7,7 @@ "location" : "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git", "state" : { "branch" : "main", - "revision" : "381059629386a9d6004ebf39c51a0ffb8e67bea8" + "revision" : "b2642fdcc1ec7db833900421e479729305c939f8" } }, { @@ -25,7 +25,7 @@ "location" : "https://github.com/OpenSwiftUIProject/OpenCoreGraphics", "state" : { "branch" : "main", - "revision" : "03ddedb7e6b364573c37445f3aee267353cd4710" + "revision" : "735ce20fa83d9e7f73dff980b3812a62a488d8d7" } }, { @@ -43,7 +43,7 @@ "location" : "https://github.com/OpenSwiftUIProject/OpenRenderBox", "state" : { "branch" : "main", - "revision" : "ca047c126042599d90fa103e703de8322eb573eb" + "revision" : "6dce9cec800d431e34de89f08ade642dabacad8a" } }, { diff --git a/Package.swift b/Package.swift index 4421d427c..e9a2b4038 100644 --- a/Package.swift +++ b/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 diff --git a/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.h b/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.h new file mode 100644 index 000000000..e60c4bb63 --- /dev/null +++ b/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.h @@ -0,0 +1,25 @@ +// +// OpenSwiftUI+NSWindow.h +// COpenSwiftUI + +#ifndef OpenSwiftUI_NSWindow_h +#define OpenSwiftUI_NSWindow_h + +#include "OpenSwiftUIBase.h" + +#if OPENSWIFTUI_TARGET_OS_OSX + +#import +#import + +OPENSWIFTUI_ASSUME_NONNULL_BEGIN + +OPENSWIFTUI_EXPORT +CGDirectDisplayID _NSWindowGetCGDisplayID(NSWindow * _Nullable window); + +OPENSWIFTUI_ASSUME_NONNULL_END + +#endif /* OPENSWIFTUI_TARGET_OS_OSX */ + +#endif /* OpenSwiftUI_NSWindow_h */ + diff --git a/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.m b/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.m new file mode 100644 index 000000000..f40a74f07 --- /dev/null +++ b/Sources/COpenSwiftUI/Overlay/AppKit/OpenSwiftUI+NSWindow.m @@ -0,0 +1,16 @@ +// +// OpenSwiftUI+NSWindow.m +// COpenSwiftUI + +#import "OpenSwiftUI+NSWindow.h" + +#if OPENSWIFTUI_TARGET_OS_OSX + +CGDirectDisplayID _NSWindowGetCGDisplayID(NSWindow *window) { + NSScreen *screen = [window screen]; + NSDictionary *deviceDescription = [screen deviceDescription]; + NSNumber *screenNumber = deviceDescription[@"NSScreenNumber"]; + return [screenNumber unsignedIntValue]; +} +#endif + diff --git a/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h b/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h index b9a1d2234..9cd1da1c1 100644 --- a/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h +++ b/Sources/COpenSwiftUI/Shims/AppKit/AppKit_Private.h @@ -27,6 +27,7 @@ typedef OPENSWIFTUI_ENUM(NSInteger, NSViewVibrantBlendingStyle) { }; @interface NSView () +@property (getter=isOpaque) BOOL opaque; - (void)_updateLayerGeometryFromView; @end diff --git a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSGraphicsView.swift b/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSGraphicsView.swift deleted file mode 100644 index d64f22311..000000000 --- a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSGraphicsView.swift +++ /dev/null @@ -1,27 +0,0 @@ -// -// NSGraphicsView.swift -// OpenSwiftUI -// -// Audited for 6.0.87 -// Status: WIP - -#if os(macOS) - -import OpenSwiftUI_SPI -import AppKit - -final 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) - } -} - -#endif diff --git a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSInheritedView.swift b/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSInheritedView.swift deleted file mode 100644 index 481473736..000000000 --- a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/View/NSInheritedView.swift +++ /dev/null @@ -1,25 +0,0 @@ -// -// NSInheritedView.swift -// OpenSwiftUI -// -// Audited for 6.0.87 -// Status: WIP - -#if os(macOS) - -import OpenSwiftUI_SPI -import AppKit - -class _NSInheritedView: NSView { - var hitTestsAsOpaque: Bool = false - - override init(frame frameRect: NSRect) { - super.init(frame: frameRect) - } - - required init?(coder: NSCoder) { - super.init(coder: coder) - } -} - -#endif diff --git a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/NSViewPlatformViewDefinition.swift b/Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift similarity index 80% rename from Sources/OpenSwiftUI/Integration/Hosting/AppKit/NSViewPlatformViewDefinition.swift rename to Sources/OpenSwiftUI/Render/DisplayList/AppKitDisplayList.swift index 0bba9ccd9..79b96df2c 100644 --- a/Sources/OpenSwiftUI/Integration/Hosting/AppKit/NSViewPlatformViewDefinition.swift +++ b/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 QuartzCore_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 diff --git a/Sources/OpenSwiftUI/Render/DisplayList/DisplayListViewDrawing.swift b/Sources/OpenSwiftUI/Render/DisplayList/DisplayListViewDrawing.swift new file mode 100644 index 000000000..1c77dd546 --- /dev/null +++ b/Sources/OpenSwiftUI/Render/DisplayList/DisplayListViewDrawing.swift @@ -0,0 +1,240 @@ +// +// DisplayListViewDrawing.swift +// OpenSwiftUI +// +// Audited for 6.5.4 +// Status: Blocked by RBDrawingView +// 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 { + didSet { + guard oldValue != options else { + return + } + updateOptions() + } + } + + private func updateOptions() { + #if os(iOS) || os(visionOS) + isOpaque = options.isOpaque + layer.contentsFormat = options.caLayerContentsFormat + #elseif os(macOS) + layer!.isOpaque = options.isOpaque + layer!.contentsFormat = options.caLayerContentsFormat + #endif + } + + init(options: PlatformDrawableOptions) { + self.options = options + super.init(frame: .zero) + #if os(macOS) + wantsLayer = true + layer = CGDrawingLayer() + #endif + updateOptions() + } + + required init?(coder: NSCoder) { + _openSwiftUIUnreachableCode() + } + + #if os(iOS) || os(visionOS) + override class var layerClass: AnyClass { + CGDrawingLayer.self + } + #endif + + #if os(macOS) + override func draw(_ dirtyRect: NSRect) { + guard let context = NSGraphicsContext.current, + !context.isDrawingToScreen + else { return } + let layer = layer as! CGDrawingLayer + layer.content + .draw( + in: context.cgContext, + size: bounds.size, + contentsScale: layer.contentsScale, + state: &layer.state + ) + } + #endif + + static var allowsContentsMultiplyColor: Bool { + true + } + + func update( + content: PlatformDrawableContent?, + required: Bool + ) -> Bool { + let layer = layer as! CGDrawingLayer + if let content { + layer.content = content + } + #if os(iOS) || os(visionOS) + setNeedsDisplay() + #elseif os(macOS) + needsDisplay = true + #endif + return true + } + + func makeAsyncUpdate( + content: PlatformDrawableContent, + required: Bool, + layer: CALayer, + bounds: CGRect + ) -> (() -> Void)? { + nil + } + + func setContentsScale(_ scale: CGFloat) { + #if os(iOS) || os(visionOS) + layer.contentsScale = scale + #elseif os(macOS) + layer!.contentsScale = scale + #endif + } + + 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 func updateOptions() { + isOpaque = options.isOpaque + #if os(iOS) || os(visionOS) + options.update(rbLayer: layer) + #elseif os(macOS) + options.update(rbLayer: layer!) + #endif + rendersFirstFrameAsynchronously = options.rendersFirstFrameAsynchronously + } + + 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) { + _openSwiftUIUnreachableCode() + } + + static var allowsContentsMultiplyColor: Bool { + false + } + + func update( + content: PlatformDrawableContent?, + required: Bool + ) -> Bool { + guard required || !options.rendersAsynchronously || (layer as! ORBLayer).isDrawableAvailable else { + return false + } + if let content { + state.content = content + } + #if os(iOS) || os(visionOS) + layer.setNeedsDisplay() + #elseif os(macOS) + needsDisplay = true + #endif + return true + } + + func makeAsyncUpdate( + content: PlatformDrawableContent, + required: Bool, + layer: CALayer, + bounds: CGRect + ) -> (() -> Void)? { + let layer = layer as! ORBLayer + guard required || !options.rendersAsynchronously || !layer.isDrawableAvailable else { + return nil + } + return { + _openSwiftUIUnimplementedFailure() + } + } + + func setContentsScale(_ scale: CGFloat) { + #if os(iOS) || os(visionOS) + layer.contentsScale = scale + #elseif os(macOS) + layer!.contentsScale = scale + #endif + } + + func drawForTesting(in displayList: ORBDisplayList) { + var s = PlatformDrawableContent.State() + state.content.draw(in: displayList, size: bounds.size, state: &s) + } + + override func draw(inDisplayList displayList: ORBDisplayList) { + draw(in: displayList, size: bounds.size) + } + + private func draw(in displayList: ORBDisplayList, size: CGSize) { + _openSwiftUIUnimplementedFailure() + } +} + +#endif + diff --git a/Sources/OpenSwiftUI/Render/DisplayList/RenderBoxView.swift b/Sources/OpenSwiftUI/Render/DisplayList/RenderBoxView.swift new file mode 100644 index 000000000..015d23d4a --- /dev/null +++ b/Sources/OpenSwiftUI/Render/DisplayList/RenderBoxView.swift @@ -0,0 +1,126 @@ +// +// RenderBoxView.swift +// OpenSwiftUI +// +// Audited for 6.5.4 +// Status: Complete +// ID: 0CB954C9DC99A8A907C58D7882F9389E (SwiftUI) + +#if canImport(Darwin) +import COpenSwiftUI +import Foundation +import QuartzCore +import QuartzCore_Private +import OpenRenderBoxShims + +// MARK: - RenderBoxView + +@objc +class RenderBoxView: PlatformGraphicsView { + var rendersFirstFrameAsynchronously: Bool + + #if os(iOS) || os(visionOS) + override class var layerClass: AnyClass { + RenderBoxLayer.self + } + #endif + + private func rbInit() { + #if os(iOS) || os(visionOS) + let layer = layer + layer.delegate = self + layer.isOpaque = isOpaque + #elseif os(macOS) + wantsLayer = true + layer = RenderBoxLayer() + layerContentsRedrawPolicy = .duringViewResize + let layer = layer! + layer.delegate = self + layer.isOpaque = isOpaque + #endif + } + + override init(frame: CGRect) { + rendersFirstFrameAsynchronously = false + super.init(frame: frame) + rbInit() + } + + required init?(coder: NSCoder) { + rendersFirstFrameAsynchronously = false + super.init(coder: coder) + rbInit() + } + + deinit { + (layer as! RenderBoxLayer).waitUntilAsyncRenderingCompleted() + } + + #if os(iOS) || os(visionOS) + 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() + } + #elseif os(macOS) + override func viewDidMoveToWindow() { + guard let window else { return } + layer?.contentsScale = window.backingScaleFactor + needsDisplay = true + } + #endif + + func draw(inDisplayList displayList: ORBDisplayList) { + _openSwiftUIEmptyStub() + } +} + +extension RenderBoxView: ORBLayerDelegate { + func rbLayer(_ layer: ORBLayer, draw inDisplayList: ORBDisplayList) { + draw(inDisplayList: inDisplayList) + } + + #if os(macOS) + func rbLayerDefaultDevice(_ layer: ORBLayer) -> ORBDevice? { + let id = _NSWindowGetCGDisplayID(window) + guard id != 0 else { + return nil + } + return ORBDevice.sharedDevice(forDisplay: id) + } + #endif +} + +// MARK: - RenderBoxLayer + +private class RenderBoxLayer: ORBLayer { + 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 diff --git a/Sources/OpenSwiftUI/Integration/Hosting/UIKit/UIViewPlatformViewDefinition.swift b/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift similarity index 95% rename from Sources/OpenSwiftUI/Integration/Hosting/UIKit/UIViewPlatformViewDefinition.swift rename to Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift index a80602ac0..f45f08251 100644 --- a/Sources/OpenSwiftUI/Integration/Hosting/UIKit/UIViewPlatformViewDefinition.swift +++ b/Sources/OpenSwiftUI/Render/DisplayList/UIKitDisplayList.swift @@ -1,17 +1,17 @@ // -// UIViewPlatformViewDefinition.swift +// UIKitDisplayList.swift // OpenSwiftUI // // Audited for 6.5.4 // Status: WIP -// ID: A34643117F00277B93DEBAB70EC06971 (SwiftUI?) +// ID: A34643117F00277B93DEBAB70EC06971 (SwiftUI) #if os(iOS) || os(visionOS) import COpenSwiftUI @_spi(DisplayList_ViewSystem) import OpenSwiftUICore import UIKit import OpenSwiftUISymbolDualTestsSupport -import CoreAnimation_Private +import QuartzCore_Private import OpenSwiftUI_SPI // MARK: - UIViewPlatformViewDefinition [TODO] [6.0.87] @@ -81,6 +81,8 @@ final class UIViewPlatformViewDefinition: PlatformViewDefinition, @unchecked Sen // MARK: - _UIGraphicsView +typealias PlatformGraphicsView = _UIGraphicsView + class _UIGraphicsView: UIView { override init(frame: CGRect) { super.init(frame: frame) @@ -101,6 +103,8 @@ class _UIGraphicsView: UIView { // MARK: - _UIInheritedView +typealias PlatformInheritedView = _UIInheritedView + final class _UIInheritedView: _UIGraphicsView { override init(frame: CGRect) { super.init(frame: frame) diff --git a/Sources/OpenSwiftUICore/Graphic/Color/ColorMatrix.swift b/Sources/OpenSwiftUICore/Graphic/Color/ColorMatrix.swift index 92e7c7d63..8c446c48a 100644 --- a/Sources/OpenSwiftUICore/Graphic/Color/ColorMatrix.swift +++ b/Sources/OpenSwiftUICore/Graphic/Color/ColorMatrix.swift @@ -12,7 +12,7 @@ import CoreGraphics import Foundation #endif import OpenSwiftUI_SPI -import CoreAnimation_Private +import QuartzCore_Private // MARK: - ColorMatrix diff --git a/Sources/OpenSwiftUICore/Render/PlatformDrawable.swift b/Sources/OpenSwiftUICore/Render/PlatformDrawable.swift index 614d649da..82d6d8815 100644 --- a/Sources/OpenSwiftUICore/Render/PlatformDrawable.swift +++ b/Sources/OpenSwiftUICore/Render/PlatformDrawable.swift @@ -3,14 +3,14 @@ // OpenSwiftUICore // // Audited for 6.5.4 -// Status: WIP +// Status: Blocked by PlatformDrawableContent import OpenAttributeGraphShims -import OpenRenderBoxShims +@_spiOnly public import OpenRenderBoxShims public import OpenCoreGraphicsShims -#if canImport(QuarzCore) -public import QuartzCore -import CoreAnimation_Private +public import OpenQuartzCoreShims +#if canImport(QuartzCore) +import QuartzCore_Private #endif // MARK: - PlatformDrawable @@ -24,18 +24,16 @@ public protocol PlatformDrawable: AnyObject { func update(content: PlatformDrawableContent?, required: Bool) -> Bool - #if canImport(QuarzCore) func makeAsyncUpdate( content: PlatformDrawableContent, required: Bool, layer: CALayer, bounds: CGRect ) -> (() -> Void)? - #endif func setContentsScale(_ scale: CGFloat) - func drawForTesting(in: RBDisplayList) -> () + func drawForTesting(in: ORBDisplayList) -> () } // MARK: - PlatformDrawableContent [WIP] @@ -47,26 +45,26 @@ public struct PlatformDrawableContent: @unchecked Sendable { case graphicsCallback((inout GraphicsContext, CGSize) -> ()) case platformCallback((CGSize) -> ()) case displayList(DisplayList, CGPoint, Time) - case rbDisplayList(RBDisplayListContents, CGPoint) + case rbDisplayList(any RBDisplayListContents, CGPoint) case rbInterpolator(RBDisplayListInterpolator, Float, CGPoint) case empty } - private var storage: Storage = .empty + var storage: Storage = .empty + + // MARK: - PlatformDrawableContent.State public struct State { - package var mode: DisplayList.GraphicsRenderer.PlatformViewMode + package var mode: DisplayList.GraphicsRenderer.PlatformViewMode = .unsupported package var _renderer: DisplayList.GraphicsRenderer? package init() { - mode = .unsupported - _renderer = nil + _openSwiftUIEmptyStub() } package init(platformViewMode: DisplayList.GraphicsRenderer.PlatformViewMode) { mode = platformViewMode - _renderer = nil } package mutating func renderer() -> DisplayList.GraphicsRenderer { @@ -95,7 +93,7 @@ public struct PlatformDrawableContent: @unchecked Sendable { #endif public func draw( - in list: RBDisplayList, + in list: ORBDisplayList, size: CGSize, state: inout PlatformDrawableContent.State ) { @@ -107,7 +105,7 @@ public struct PlatformDrawableContent: @unchecked Sendable { @available(*, unavailable) extension PlatformDrawableContent.State: Sendable {} -// MARK: - PlatformDrawableOptions [Blocked by RBLayer] +// MARK: - PlatformDrawableOptions @_spi(DisplayList_ViewSystem) @available(OpenSwiftUI_v6_0, *) @@ -130,7 +128,7 @@ public struct PlatformDrawableOptions: Equatable, Sendable { base.rendersFirstFrameAsynchronously } - #if canImport(QuarzCore) + #if canImport(QuartzCore) public var caLayerContentsFormat: CALayerContentsFormat { var format = CALayerContentsFormat.automatic if base.flags.contains(.rgbaContext) { @@ -144,7 +142,15 @@ public struct PlatformDrawableOptions: Equatable, Sendable { #endif public func update(rbLayer: AnyObject) { - // TODO: RBLayer - _openSwiftUIUnimplementedFailure() + #if canImport(Darwin) + let layer = rbLayer as! ORBLayer + layer.colorMode = base.resolvedColorMode + layer.rendersAsynchronously = rendersAsynchronously + layer.maxDrawableCount = Int(base.maxDrawableCount) + layer.allowsDisplayCompositing = base.prefersDisplayCompositing + layer.allowsPackedDrawable = base.allowsPackedDrawable + #else + _openSwiftUIPlatformUnimplementedWarning() + #endif } } diff --git a/Sources/OpenSwiftUICore/Render/RasterizationOptions.swift b/Sources/OpenSwiftUICore/Render/RasterizationOptions.swift index 3e1d24039..cc24e7d1b 100644 --- a/Sources/OpenSwiftUICore/Render/RasterizationOptions.swift +++ b/Sources/OpenSwiftUICore/Render/RasterizationOptions.swift @@ -3,7 +3,9 @@ // OpenSwiftUICore // // Audited for 6.5.4 -// Status: WIP +// Status: Complete + +package import OpenRenderBoxShims // MARK: - ColorRenderingMode @@ -51,7 +53,7 @@ extension ColorRenderingMode: ProtobufEnum { } } -// MARK: - RasterizationOptions [WIP] +// MARK: - RasterizationOptions package struct RasterizationOptions: Equatable { package struct Flags: OptionSet { @@ -134,12 +136,30 @@ package struct RasterizationOptions: Equatable { set { flags.setValue(newValue, for: .allowsPackedDrawable) } } - package var resolvedColorMode: RBColorMode { - _openSwiftUIUnimplementedFailure() - } - - package var colorSpace: RBColorSpace { - _openSwiftUIUnimplementedFailure() + #if !OPENSWIFTUI_ANY_ATTRIBUTE_FIX + package var resolvedColorMode: ORBColor.Mode { + if let mode = rbColorMode { + return ORBColor.Mode(rawValue: mode) + } else { + let alphaOnly = alphaOnly + switch colorMode { + case .nonLinear: + return alphaOnly ? ORBColor.Mode(rawValue: 9) : ORBColor.Mode(rawValue: 0) + case .linear: + return alphaOnly ? ORBColor.Mode(rawValue: 10) : ORBColor.Mode(rawValue: 1) + case .extendedLinear: + return alphaOnly ? ORBColor.Mode(rawValue: 10) : ORBColor.Mode(rawValue: 2) + } + } + } + #endif + + package var colorSpace: ORBColor.ColorSpace { + #if OPENSWIFTUI_ANY_ATTRIBUTE_FIX + .default + #else + resolvedColorMode.workingColorSpace + #endif } package var alphaOnly: Bool { @@ -177,5 +197,3 @@ extension RasterizationOptions: ProtobufMessage { self = options } } - -// TODO: DrawingGroupEffect diff --git a/Sources/OpenSwiftUICore/Render/RendererConfiguration.swift b/Sources/OpenSwiftUICore/Render/RendererConfiguration.swift index 9a34bf030..c837130ff 100644 --- a/Sources/OpenSwiftUICore/Render/RendererConfiguration.swift +++ b/Sources/OpenSwiftUICore/Render/RendererConfiguration.swift @@ -70,7 +70,9 @@ public struct _RendererConfiguration { /// the view, will currently be clamped to the range [2, 3]. public var maxDrawableCount: Int = 3 - public init() {} + public init() { + _openSwiftUIEmptyStub() + } } } diff --git a/Sources/OpenSwiftUICore/Util/RenderBoxShims.swift b/Sources/OpenSwiftUICore/Util/RenderBoxShims.swift index 1a4ca4902..4ac01ec6e 100644 --- a/Sources/OpenSwiftUICore/Util/RenderBoxShims.swift +++ b/Sources/OpenSwiftUICore/Util/RenderBoxShims.swift @@ -5,9 +5,3 @@ package protocol RBDisplayListContents {} // RenderBox.RBDisplayListContents class RBDisplayListInterpolator {} - -public enum RBDisplayList {} - -package enum RBColorSpace {} - -package enum RBColorMode {} diff --git a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h new file mode 100644 index 000000000..06b705e44 --- /dev/null +++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.h @@ -0,0 +1,27 @@ +// CALayerPrivate.h +// OpenSwiftUI_SPI + +#ifndef CALayerPrivate_h +#define CALayerPrivate_h + +#include "OpenSwiftUIBase.h" + +#if __has_include() + +#import + +@interface CALayer (OpenSwiftUI_SPI) + +@property (nonatomic, assign) BOOL allowsDisplayCompositing_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(allowsDisplayCompositing); +@property (nonatomic, assign, readonly) BOOL hasBeenCommitted_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(hasBeenCommitted); +@property (nonatomic, assign) BOOL allowsGroupBlending_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(allowsGroupBlending); + +@property (nonatomic, assign) uint64_t openSwiftUI_viewTestProperties; +@end + +CA_EXTERN CALayerContentsFormat const kCAContentsFormatAutomatic OPENSWIFTUI_SWIFT_NAME(automatic); +CA_EXTERN CALayerContentsFormat const kCAContentsFormatA8 OPENSWIFTUI_SWIFT_NAME(A8); + +#endif + +#endif /* CALayerPrivate_h */ diff --git a/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m new file mode 100644 index 000000000..a1595f062 --- /dev/null +++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CALayerPrivate.m @@ -0,0 +1,49 @@ +// +// CALayerPrivate.m +// OpenSwiftUI_SPI + +#import "CoreAnimation_Private.h" + +#if __has_include() + +#import "../OpenSwiftUIShims.h" +#import + +@implementation CALayer (OpenSwiftUI_SPI) + +- (BOOL)allowsDisplayCompositing_openswiftui_safe_wrapper { + OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"allowsDisplayCompositing", NO); + return func(self, selector); +} + +- (void)setAllowsDisplayCompositing_openswiftui_safe_wrapper:(BOOL)allows { + OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setAllowsDisplayCompositing:", , BOOL); + func(self, selector, allows); +} + +- (BOOL)hasBeenCommitted_openswiftui_safe_wrapper { + OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"hasBeenCommitted", NO); + return func(self, selector); +} + +- (BOOL)allowsGroupBlending_openswiftui_safe_wrapper { + OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"allowsGroupBlending", NO); + return func(self, selector); +} + +- (void)setAllowsGroupBlending_openswiftui_safe_wrapper:(BOOL)allows { + OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setAllowsGroupBlending:", , BOOL); + func(self, selector, allows); +} + +- (uint64_t)openSwiftUI_viewTestProperties { + NSNumber *properties = [self valueForKey:@"_viewTestProperties"]; + return properties.integerValue; +} + +- (void)setOpenSwiftUI_viewTestProperties:(uint64_t)properties { + [self setValue:[NSNumber numberWithUnsignedLongLong:properties] forKey:@"_viewTestProperties"]; +} +@end + +#endif /* */ diff --git a/Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.h b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.h similarity index 70% rename from Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.h rename to Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.h index 855b984d2..a3bf51e2e 100644 --- a/Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.h +++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.h @@ -13,13 +13,6 @@ OPENSWIFTUI_ASSUME_NONNULL_BEGIN -@interface CALayer (OpenSwiftUI_SPI) -@property (nonatomic, assign, readonly) BOOL hasBeenCommitted_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(hasBeenCommitted); -@property (nonatomic, assign) BOOL allowsGroupBlending_openswiftui_safe_wrapper OPENSWIFTUI_SWIFT_NAME(allowsGroupBlending); - -@property (nonatomic, assign) uint64_t openSwiftUI_viewTestProperties; -@end - struct CAColorMatrix { float m11, m12, m13, m14, m15; float m21, m22, m23, m24, m25; @@ -46,9 +39,6 @@ typedef struct CAColorMatrix CAColorMatrix; - (void)setHighFrameRateReasons_openswiftui_safe_wrapper:(const uint32_t *)reasons count:(NSInteger)count OPENSWIFTUI_SWIFT_NAME(setHighFrameRateReasons(_:count:)); @end -CA_EXTERN CALayerContentsFormat const kCAContentsFormatAutomatic OPENSWIFTUI_SWIFT_NAME(automatic); -CA_EXTERN CALayerContentsFormat const kCAContentsFormatA8 OPENSWIFTUI_SWIFT_NAME(A8); - OPENSWIFTUI_ASSUME_NONNULL_END #endif /* CoreAnimation.h */ diff --git a/Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.m b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.m similarity index 59% rename from Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.m rename to Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.m index 9ca6314d2..5d3046113 100644 --- a/Sources/OpenSwiftUI_SPI/Shims/CoreAnimation/CoreAnimation_Private.m +++ b/Sources/OpenSwiftUI_SPI/Shims/QuartzCore/CoreAnimation_Private.m @@ -9,33 +9,6 @@ #import "../OpenSwiftUIShims.h" #import -@implementation CALayer (OpenSwiftUI_SPI) - -- (BOOL)hasBeenCommitted_openswiftui_safe_wrapper { - OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"hasBeenCommitted", NO); - return func(self, selector); -} - -- (BOOL)allowsGroupBlending_openswiftui_safe_wrapper { - OPENSWIFTUI_SAFE_WRAPPER_IMP(BOOL, @"allowsGroupBlending", NO); - return func(self, selector); -} - -- (void)setAllowsGroupBlending_openswiftui_safe_wrapper:(BOOL)allows { - OPENSWIFTUI_SAFE_WRAPPER_IMP(void, @"setAllowsGroupBlending:", , BOOL); - func(self, selector, allows); -} - -- (uint64_t)openSwiftUI_viewTestProperties { - NSNumber *properties = [self valueForKey:@"_viewTestProperties"]; - return properties.integerValue; -} - -- (void)setOpenSwiftUI_viewTestProperties:(uint64_t)properties { - [self setValue:[NSNumber numberWithUnsignedLongLong:properties] forKey:@"_viewTestProperties"]; -} -@end - @implementation NSValue (OpenSwiftUI_SPI) + (NSValue *)valueWithCAColorMatrix_openswiftui_safe_wrapper:(CAColorMatrix)t { OPENSWIFTUI_SAFE_WRAPPER_IMP(NSValue *, @"valueWithCAColorMatrix:", nil, CAColorMatrix); diff --git a/Sources/OpenSwiftUI_SPI/module.modulemap b/Sources/OpenSwiftUI_SPI/module.modulemap index abf42c3e1..4b8a930f7 100644 --- a/Sources/OpenSwiftUI_SPI/module.modulemap +++ b/Sources/OpenSwiftUI_SPI/module.modulemap @@ -8,8 +8,8 @@ module OpenSwiftUI_SPI { } } -module CoreAnimation_Private { - umbrella "Shims/CoreAnimation" +module QuartzCore_Private { + umbrella "Shims/QuartzCore" export * }