Add CorePlatformImage support

Sources/OpenSwiftUICore/Graphic/Color/ColorResolved.swift

@@ -322,7 +322,7 @@
         var green: CGFloat = 0
         var blue: CGFloat = 0
         var alpha: CGFloat = 0
-        let result = OpenSwiftUICoreColorPlatformColorGetComponents(isAppKitBased(), platformColor, &red, &green, &blue, &alpha)
+        let result = CoreColorPlatformColorGetComponents(system: isAppKitBased() ? .appKit : .uiKit, color: platformColor, red: &red, green: &green, blue: &blue, alpha: &alpha)
         if result {
             self.init(red: Float(red), green: Float(green), blue: Float(blue), opacity: Float(alpha))
         } else {
@@ -332,7 +332,7 @@
 
     // ID: 4330A474F53D66045762501ED6F8A749
     private static let cache: ObjectCache<Color.Resolved, NSObject> = ObjectCache { resolved in
-        OpenSwiftUICoreColor.platformColor(resolvedColor: resolved)!
+        CoreColor.platformColor(resolvedColor: resolved)!
     }
 
     package var kitColor: NSObject {

Sources/OpenSwiftUICore/Graphic/Color/CoreColor+Extension.swift

@@ -9,13 +9,13 @@
 import Foundation
 internal import OpenSwiftUI_SPI
 
-extension OpenSwiftUICoreColor {
+extension CoreColor {
     package static func platformColor(resolvedColor: Color.Resolved) -> NSObject? {
         platformColor(red: CGFloat(resolvedColor.red), green: CGFloat(resolvedColor.green), blue: CGFloat(resolvedColor.blue), alpha: CGFloat(resolvedColor.opacity))
     }
 
     package static func platformColor(red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) -> NSObject? {
-        OpenSwiftUICorePlatformColorForRGBA(isAppKitBased(), red, green, blue, alpha)
+        CorePlatformColorForRGBA(system: isAppKitBased() ? .appKit : .uiKit, red: red, green: green, blue: blue, alpha: alpha)
     }
 }
 

Sources/OpenSwiftUICore/Graphic/Image/CorePlatformImage.swift

@@ -0,0 +1,57 @@
+//
+//  CorePlatformImage.swift
+//  OpenSwiftUICore
+//
+//  Audited for RELEASE_2024
+//  Status: WIP
+
+#if canImport(Darwin)
+import Foundation
+package import OpenSwiftUI_SPI
+
+@objc(OpenSwiftUICorePlatformImage)
+package final class CorePlatformImage: NSObject {
+    package var system: CoreSystem
+    package var kitImage: NSObject
+    package var isTemplate: Bool
+
+    package init(system: CoreSystem, kitImage: NSObject) {
+        self.system = system
+        self.kitImage = kitImage
+        self.isTemplate = _CorePlatformImageIsTemplate(system: system, kitImage: kitImage)
+        super.init()
+    }
+
+    convenience package init(system: CoreSystem, cgImage: CGImage, scale: CGFloat, orientation: UInt8){
+        self.init(
+            system: system,
+            kitImage: _CorePlatformImageMakeKitImage(system: system, cgImage: cgImage, scale: scale, orientation: orientation)
+        )
+    }
+
+    package var cgImage: CGImage? {
+        _CorePlatformImageGetCGImage(system: system, kitImage: kitImage)
+    }
+
+    package var size: CGSize {
+        _CorePlatformImageGetSize(system: system, kitImage: kitImage)
+    }
+
+    package var scale: CGFloat {
+        _CorePlatformImageGetScale(system: system, kitImage: kitImage)
+    }
+
+    package var imageOrientation: UInt8 {
+        _CorePlatformImageGetImageOrientation(system: system, kitImage: kitImage)
+    }
+
+    package var baselineOffsetFromBottom: CGFloat {
+        _CorePlatformImageGetBaselineOffsetFromBottom(system: system, kitImage: kitImage)
+    }
+
+    package var alignmentRect: CGRect {
+        get { _CorePlatformImageGetAlignmentRect(system: system, kitImage: kitImage) }
+        set { _CorePlatformImageSetAlignmentRect(system: system, kitImage: kitImage, newValue) }
+    }
+}
+#endif

Sources/OpenSwiftUICore/Render/PlatformViewDefinition.swift

@@ -47,7 +47,7 @@
         }
     }
 
-    open class var system: PlatformViewDefinition.System { .init(base: ._2) }
+    open class var system: PlatformViewDefinition.System { .init(base: .swiftUIView) }
     open class func makeView(kind: PlatformViewDefinition.ViewKind) -> AnyObject { fatalError() }
     #if canImport(Darwin)
     open class func makeLayerView(type: CALayer.Type, kind: PlatformViewDefinition.ViewKind) -> AnyObject { fatalError() }

Sources/OpenSwiftUI_SPI/OpenSwiftUIBase.h

@@ -70,4 +70,20 @@
 
 #define OPENSWIFTUI_ENUM CF_ENUM
 
+#ifndef OPENSWIFTUI_IMPLICIT_BRIDGING_ENABLED
+#if __has_feature(arc_cf_code_audited)
+#define OPENSWIFTUI_IMPLICIT_BRIDGING_ENABLED _Pragma("clang arc_cf_code_audited begin")
+#else
+#define OPENSWIFTUI_IMPLICIT_BRIDGING_ENABLED
+#endif
+#endif
+
+#ifndef OPENSWIFTUI_IMPLICIT_BRIDGING_DISABLED
+#if __has_feature(arc_cf_code_audited)
+#define OPENSWIFTUI_IMPLICIT_BRIDGING_DISABLED _Pragma("clang arc_cf_code_audited end")
+#else
+#define OPENSWIFTUI_IMPLICIT_BRIDGING_DISABLED
+#endif
+#endif
+
 #endif /* OpenSwiftUIBase_h */

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreColor.h

@@ -17,35 +17,37 @@
 #else
 #include <AppKit/AppKit.h>
 #endif
+#include "OpenSwiftUICoreSystem.h"
 
 OPENSWIFTUI_ASSUME_NONNULL_BEGIN
 
 OPENSWIFTUI_EXPORT
-BOOL OpenSwiftUICoreColorPlatformColorGetComponents(BOOL system, id color, CGFloat *red, CGFloat *green, CGFloat *blue, CGFloat *alpha);
+BOOL OpenSwiftUICoreColorPlatformColorGetComponents(OpenSwiftUICoreSystem system, id color, CGFloat *red, CGFloat *green, CGFloat *blue, CGFloat *alpha) OPENSWIFTUI_SWIFT_NAME(CoreColorPlatformColorGetComponents(system:color:red:green:blue:alpha:));
 
 OPENSWIFTUI_EXPORT
-NSObject  * _Nullable OpenSwiftUICorePlatformColorForRGBA(BOOL system, CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha);
+NSObject  * _Nullable OpenSwiftUICorePlatformColorForRGBA(OpenSwiftUICoreSystem system, CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha) OPENSWIFTUI_SWIFT_NAME(CorePlatformColorForRGBA(system:red:green:blue:alpha:));
 
 OPENSWIFTUI_EXPORT
-Class _Nullable OpenSwiftUICoreColorGetKitColorClass(BOOL system);
+Class _Nullable OpenSwiftUICoreColorGetKitColorClass(OpenSwiftUICoreSystem system) OPENSWIFTUI_SWIFT_NAME(CoreColorGetKitColorClass(system:));
 
+OPENSWIFTUI_SWIFT_NAME(CoreColor)
 @interface OpenSwiftUICoreColor : NSObject
 
-+ (nullable NSObject *)colorWithSystem:(BOOL)system cgColor: (CGColorRef)cgColor;
-+ (nullable NSObject *)blackColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemRedColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemOrangeColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemYellowColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemGreenColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemTealColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemMintColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemCyanColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemBlueColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemIndigoColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemPurpleColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemPinkColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemBrownColorWithSystem:(BOOL)system;
-+ (nullable NSObject *)systemGrayColorWithSystem:(BOOL)system;
++ (nullable NSObject *)colorWithSystem:(OpenSwiftUICoreSystem)system cgColor: (CGColorRef)cgColor;
++ (nullable NSObject *)blackColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemRedColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemOrangeColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemYellowColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemGreenColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemTealColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemMintColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemCyanColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemBlueColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemIndigoColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemPurpleColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemPinkColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemBrownColorWithSystem:(OpenSwiftUICoreSystem)system;
++ (nullable NSObject *)systemGrayColorWithSystem:(OpenSwiftUICoreSystem)system;
 
 - (instancetype)initWithCGColor:(CGColorRef)cgColor;
 - (void)set;

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreColor.m

@@ -10,14 +10,14 @@
 #if OPENSWIFTUI_TARGET_OS_DARWIN
 #include "OpenSwiftUICoreGraphicsContext.h"
 
-Class OpenSwiftUICoreColorClass(BOOL system);
+Class OpenSwiftUICoreColorClass(OpenSwiftUICoreSystem system);
 
 #if OPENSWIFTUI_TARGET_OS_OSX
 id NSColorSpaceForCGColorSpace(CGColorSpaceRef cgColorSpace);
 Class NSColorSpaceClass(void);
 #endif
 
-BOOL OpenSwiftUICoreColorPlatformColorGetComponents(BOOL system, id color, CGFloat *red, CGFloat *green, CGFloat *blue, CGFloat *alpha) {
+BOOL OpenSwiftUICoreColorPlatformColorGetComponents(OpenSwiftUICoreSystem system, id color, CGFloat *red, CGFloat *green, CGFloat *blue, CGFloat *alpha) {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     if (!colorClass) {
         return NO;
@@ -44,13 +44,13 @@ BOOL OpenSwiftUICoreColorPlatformColorGetComponents(BOOL system, id color, CGFlo
     #endif
 }
 
-NSObject *OpenSwiftUICorePlatformColorForRGBA(BOOL system, CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha) {
+NSObject *OpenSwiftUICorePlatformColorForRGBA(OpenSwiftUICoreSystem system, CGFloat red, CGFloat green, CGFloat blue, CGFloat alpha) {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     if (!colorClass) {
         return nil;
     }
     #if OPENSWIFTUI_TARGET_OS_OSX
-    if (system) {
+    if (system == OpenSwiftUICoreSystemAppKit) {
         id colorSpace = NSColorSpaceForCGColorSpace(CGColorSpaceCreateWithName(kCGColorSpaceExtendedSRGB));
         return [colorClass colorWithColorSpace:colorSpace components:(CGFloat[]){red, green, blue, alpha} count:4];
     } else {
@@ -61,22 +61,22 @@ BOOL OpenSwiftUICoreColorPlatformColorGetComponents(BOOL system, id color, CGFlo
     #endif
 }
 
-Class _Nullable OpenSwiftUICoreColorGetKitColorClass(BOOL system) {
+Class _Nullable OpenSwiftUICoreColorGetKitColorClass(OpenSwiftUICoreSystem system) {
     return OpenSwiftUICoreColorClass(system);
 }
 
-Class _Nullable OpenSwiftUICoreColorClass(BOOL system) {
+Class _Nullable OpenSwiftUICoreColorClass(OpenSwiftUICoreSystem system) {
     static BOOL isValid = true;
     static Class colorClass;
     static dispatch_once_t once;
     dispatch_once(&once, ^{
         #if OPENSWIFTUI_TARGET_OS_OSX
-        if (!system) {
+        if (system == OpenSwiftUICoreSystemUIKit) {
             Class class = NSClassFromString(@"UIColor");
             colorClass = class;
             isValid = class != nil;
         }
-        if (system) {
+        if (system == OpenSwiftUICoreSystemAppKit) {
             Class class = NSClassFromString(@"NSColor");
             colorClass = class;
             isValid = class != nil;
@@ -122,7 +122,7 @@ @interface OpenSwiftUICoreColor () {
 
 @implementation OpenSwiftUICoreColor
 
-+ (NSObject *)colorWithSystem:(BOOL)system cgColor: (CGColorRef)cgColor {
++ (NSObject *)colorWithSystem:(OpenSwiftUICoreSystem)system cgColor: (CGColorRef)cgColor {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     if (colorClass) {
         return [colorClass colorWithCGColor: cgColor];
@@ -131,72 +131,72 @@ + (NSObject *)colorWithSystem:(BOOL)system cgColor: (CGColorRef)cgColor {
     }
 }
 
-+ (NSObject *)blackColorWithSystem:(BOOL)system {
++ (NSObject *)blackColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass blackColor];
 }
 
-+ (NSObject *)systemRedColorWithSystem:(BOOL)system {
++ (NSObject *)systemRedColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemRedColor];
 }
 
-+ (NSObject *)systemOrangeColorWithSystem:(BOOL)system {
++ (NSObject *)systemOrangeColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemOrangeColor];
 }
 
-+ (NSObject *)systemYellowColorWithSystem:(BOOL)system {
++ (NSObject *)systemYellowColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemYellowColor];
 }
 
-+ (NSObject *)systemGreenColorWithSystem:(BOOL)system {
++ (NSObject *)systemGreenColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemGreenColor];
 }
 
-+ (NSObject *)systemTealColorWithSystem:(BOOL)system {
++ (NSObject *)systemTealColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemTealColor];
 }
 
-+ (NSObject *)systemMintColorWithSystem:(BOOL)system {
++ (NSObject *)systemMintColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemMintColor];
 }
 
-+ (NSObject *)systemCyanColorWithSystem:(BOOL)system {
++ (NSObject *)systemCyanColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemCyanColor];
 }
 
-+ (NSObject *)systemBlueColorWithSystem:(BOOL)system {
++ (NSObject *)systemBlueColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemBlueColor];
 }
 
-+ (NSObject *)systemIndigoColorWithSystem:(BOOL)system {
++ (NSObject *)systemIndigoColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemIndigoColor];
 }
 
-+ (NSObject *)systemPurpleColorWithSystem:(BOOL)system {
++ (NSObject *)systemPurpleColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemPurpleColor];
 }
 
-+ (NSObject *)systemPinkColorWithSystem:(BOOL)system {
++ (NSObject *)systemPinkColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemPinkColor];
 }
 
-+ (NSObject *)systemBrownColorWithSystem:(BOOL)system {
++ (NSObject *)systemBrownColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemBrownColor];
 }
 
-+ (NSObject *)systemGrayColorWithSystem:(BOOL)system {
++ (NSObject *)systemGrayColorWithSystem:(OpenSwiftUICoreSystem)system {
     Class colorClass = OpenSwiftUICoreColorClass(system);
     return [colorClass systemGrayColor];
 }

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreGraphicsContext.h

@@ -16,6 +16,7 @@
 
 OPENSWIFTUI_ASSUME_NONNULL_BEGIN
 
+OPENSWIFTUI_SWIFT_NAME(CoreGraphicsContext)
 @interface OpenSwiftUICoreGraphicsContext : NSObject
 
 @property (class, nonatomic, readonly) OpenSwiftUICoreGraphicsContext *current;

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreGraphicsContext.m

@@ -3,7 +3,7 @@
 //  OpenSwiftUI_SPI
 //
 //  Audited for RELEASE_2024
-//  Status: WIP
+//  Status: Complete
 
 #include "OpenSwiftUICoreGraphicsContext.h"