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"
 

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICorePlatformImage.h

@@ -0,0 +1,55 @@
+//
+//  OpenSwiftUICorePlatformImage.h
+//  OpenSwiftUI_SPI
+//
+//  Audited for RELEASE_2024
+//  Status: Complete
+
+#ifndef OpenSwiftUICorePlatformImage_h
+#define OpenSwiftUICorePlatformImage_h
+
+#include "OpenSwiftUIBase.h"
+
+#if OPENSWIFTUI_TARGET_OS_DARWIN
+
+#include <CoreGraphics/CoreGraphics.h>
+#include "OpenSwiftUICoreSystem.h"
+
+OPENSWIFTUI_IMPLICIT_BRIDGING_ENABLED
+
+OPENSWIFTUI_ASSUME_NONNULL_BEGIN
+
+OPENSWIFTUI_EXPORT
+NSObject* _OpenSwiftUICorePlatformImageMakeKitImage(OpenSwiftUICoreSystem system, CGImageRef cgImage, CGFloat scale, uint8_t orientation) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageMakeKitImage(system:cgImage:scale:orientation:));
+
+OPENSWIFTUI_EXPORT
+BOOL _OpenSwiftUICorePlatformImageIsTemplate(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageIsTemplate(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+CGImageRef _Nullable _OpenSwiftUICorePlatformImageGetCGImage(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetCGImage(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+CGSize _OpenSwiftUICorePlatformImageGetSize(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetSize(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+CGFloat _OpenSwiftUICorePlatformImageGetScale(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetScale(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+uint8_t _OpenSwiftUICorePlatformImageGetImageOrientation(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetImageOrientation(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+CGFloat _OpenSwiftUICorePlatformImageGetBaselineOffsetFromBottom(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetBaselineOffsetFromBottom(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+CGRect _OpenSwiftUICorePlatformImageGetAlignmentRect(OpenSwiftUICoreSystem system, id kitImage) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageGetAlignmentRect(system:kitImage:));
+
+OPENSWIFTUI_EXPORT
+void _OpenSwiftUICorePlatformImageSetAlignmentRect(OpenSwiftUICoreSystem system, id kitImage, CGRect rect) OPENSWIFTUI_SWIFT_NAME(_CorePlatformImageSetAlignmentRect(system:kitImage:_:));
+
+OPENSWIFTUI_ASSUME_NONNULL_END
+
+OPENSWIFTUI_IMPLICIT_BRIDGING_DISABLED
+
+#endif
+
+#endif /* OpenSwiftUICorePlatformImage_h */

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICorePlatformImage.m

@@ -0,0 +1,171 @@
+//
+//  OpenSwiftUICorePlatformImage.h
+//  OpenSwiftUICore
+//
+//  Audited for RELEASE_2024
+//  Status: Blocked by macOS implementation and Mac Catalyst support
+
+#include "OpenSwiftUICorePlatformImage.h"
+
+#if OPENSWIFTUI_TARGET_OS_DARWIN
+
+#include <Foundation/Foundation.h>
+#if OPENSWIFTUI_TARGET_OS_IOS
+#include <UIKit/UIKit.h>
+#else
+#include <AppKit/AppKit.h>
+#endif
+
+Class _Nullable _OpenSwiftUICorePlatformImageClass(void) {
+    static BOOL isValid = true;
+    static Class imageClass;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        #if OPENSWIFTUI_TARGET_OS_OSX
+        Class class = NSClassFromString(@"NSImage");
+        imageClass = class;
+        isValid = class != nil;
+        #else
+        Class class = NSClassFromString(@"UIImage");
+        imageClass = class;
+        isValid = class != nil;
+        #endif
+    });
+    if (isValid) {
+        return imageClass;
+    } else {
+        [NSException raise:@"Invalid image class" format:@""];
+    }
+}
+
+NSObject* _OpenSwiftUICorePlatformImageMakeKitImage(OpenSwiftUICoreSystem system, CGImageRef cgImage, CGFloat scale, uint8_t orientation) {
+    Class imageClass = _OpenSwiftUICorePlatformImageClass();
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        CGSize size = CGSizeMake(CGImageGetWidth(cgImage), CGImageGetHeight(cgImage));
+        NSImage *kitImage = [[imageClass alloc] initWithCGImage:cgImage size:size];
+        return kitImage;
+    } else {
+        // FIXME: How to import macOS SDK's iOS Support <UIKit/UIImage.h> header here
+        // UIImage *kitImage = [[imageClass alloc] initWithCGImage:cgImage scale:scale orientation:orientation];
+        // TODO: Unimplemented
+        return nil;
+    }
+    #else
+    UIImage *kitImage = [[imageClass alloc] initWithCGImage:cgImage scale:scale orientation:orientation];
+    if (kitImage.renderingMode == UIImageRenderingModeAlwaysTemplate) {
+        kitImage = [kitImage imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal];
+    }
+    if (kitImage.baselineOffsetFromBottom > 0.0) {
+        kitImage = [kitImage imageWithBaselineOffsetFromBottom:kitImage.baselineOffsetFromBottom];
+    }
+    return kitImage;
+    #endif
+}
+
+BOOL _OpenSwiftUICorePlatformImageIsTemplate(OpenSwiftUICoreSystem system, id kitImage) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return NO;
+    } else {
+        // FIXME: How to import macOS SDK's iOS Support <UIKit/UIImage.h> header here
+        return [kitImage renderingMode] == 2 /* UIImageRenderingModeAlwaysTemplate */;
+    }
+    #else
+    return [(UIImage *)kitImage renderingMode] == UIImageRenderingModeAlwaysTemplate;
+    #endif
+}
+
+CGImageRef _OpenSwiftUICorePlatformImageGetCGImage(OpenSwiftUICoreSystem system, id kitImage) {
+    if (!kitImage) {
+        return nil;
+    }
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return [kitImage CGImageForProposedRect:nil context:nil hints:nil];
+    } else {
+        return [kitImage CGImage];
+    }
+    #else
+    return [(UIImage *)kitImage CGImage];
+    #endif
+}
+
+CGSize _OpenSwiftUICorePlatformImageGetSize(OpenSwiftUICoreSystem system, id kitImage) {
+    CGImageRef cgImage = _OpenSwiftUICorePlatformImageGetCGImage(system, kitImage);
+    if (!cgImage) {
+        return CGSizeZero;
+    }
+    return CGSizeMake(CGImageGetWidth(cgImage), CGImageGetHeight(cgImage));
+}
+
+CGFloat _OpenSwiftUICorePlatformImageGetScale(OpenSwiftUICoreSystem system, id kitImage) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        CGFloat kitImageWidth = [(NSImage *)kitImage size].width;
+        CGFloat cgImageWidth = _OpenSwiftUICorePlatformImageGetSize(OpenSwiftUICoreSystemAppKit, kitImage).width;
+        CGFloat scale = kitImageWidth / cgImageWidth;
+        return scale;
+    } else {
+        return [kitImage scale];
+    }
+    #else
+    return [(UIImage *)kitImage scale];
+    #endif
+}
+
+uint8_t _OpenSwiftUICorePlatformImageGetImageOrientation(OpenSwiftUICoreSystem system, id kitImage) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return 0;
+    } else {
+        // FIXME: How to import macOS SDK's iOS Support <UIKit/UIImage.h> header here
+        // return [(UIImage *)kitImage imageOrientation];
+        // TODO: Unimplemented
+        return 0;
+    }
+    #else
+    return [(UIImage *)kitImage imageOrientation];
+    #endif
+}
+
+CGFloat _OpenSwiftUICorePlatformImageGetBaselineOffsetFromBottom(OpenSwiftUICoreSystem system, id kitImage) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return [(NSImage *)kitImage alignmentRect].origin.y;
+    } else {
+        // FIXME: How to import macOS SDK's iOS Support <UIKit/UIImage.h> header here
+        // return [(UIImage *)kitImage baselineOffsetFromBottom];
+        // TODO: Unimplemented
+        return 0.0;
+    }
+    #else
+    return [(UIImage *)kitImage baselineOffsetFromBottom];
+    #endif
+}
+
+CGRect _OpenSwiftUICorePlatformImageGetAlignmentRect(OpenSwiftUICoreSystem system, id kitImage) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return [(NSImage *)kitImage alignmentRect];
+    } else {
+        return CGRectZero;
+    }
+    #else
+    return CGRectZero;
+    #endif
+}
+
+void _OpenSwiftUICorePlatformImageSetAlignmentRect(OpenSwiftUICoreSystem system, id kitImage, CGRect rect) {
+    #if OPENSWIFTUI_TARGET_OS_OSX
+    if (system == OpenSwiftUICoreSystemAppKit) {
+        return [(NSImage *)kitImage setAlignmentRect:rect];
+    } else {
+        return;
+    }
+    #else
+    return;
+    #endif
+}
+
+#endif

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreSystem.h

@@ -0,0 +1,18 @@
+//
+//  OpenSwiftUICoreSystem.h
+//  OpenSwiftUI_SPI
+//
+//  Audited for RELEASE_2024
+//  Status: Complete
+
+#ifndef OpenSwiftUICoreSystem_h
+#define OpenSwiftUICoreSystem_h
+
+#include "OpenSwiftUIBase.h"
+
+typedef OPENSWIFTUI_ENUM(uint8_t, OpenSwiftUICoreSystem) {
+    OpenSwiftUICoreSystemUIKit,
+    OpenSwiftUICoreSystemAppKit,
+} OPENSWIFTUI_SWIFT_NAME(CoreSystem);
+
+#endif /* OpenSwiftUICoreSystem_h */

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUICoreTextGraphicsContextProvider.h

@@ -17,6 +17,7 @@
 
 void InitializeCoreTextGraphicsContextProvider(void);
 
+OPENSWIFTUI_SWIFT_NAME(CoreTextGraphicsContextProvider)
 @interface OpenSwiftUICoreTextGraphicsContextProvider : NSObject<NSTextGraphicsContextProvider, NSTextGraphicsContext>
 
 @property (readonly) CGContextRef CGContext;

Sources/OpenSwiftUI_SPI/Overlay/CoreGraphics/OpenSwiftUIViewSystem.h

@@ -0,0 +1,19 @@
+//
+//  OpenSwiftUIViewSystem.h
+//  OpenSwiftUI_SPI
+//
+//  Audited for RELEASE_2024
+//  Status: Complete
+
+#ifndef OpenSwiftUIViewSystem_h
+#define OpenSwiftUIViewSystem_h
+
+#include "OpenSwiftUIBase.h"
+
+typedef OPENSWIFTUI_ENUM(uint8_t, OpenSwiftUIViewSystem) {
+    OpenSwiftUIViewSystemUIView,
+    OpenSwiftUIViewSystemNSView,
+    OpenSwiftUIViewSystemSwiftUIView,
+} OPENSWIFTUI_SWIFT_NAME(ViewSystem);
+
+#endif /* OpenSwiftUIViewSystem_h */

Tests/OpenSwiftUI_SPITests/Overlay/CoreGraphics/OpenSwiftUICoreColorTests.swift → Tests/OpenSwiftUI_SPITests/Overlay/CoreGraphics/CoreColorTests.swift

@@ -1,5 +1,5 @@
 //
-//  CoreFoundationPrivateTests.swift
+//  CoreColorTests.swift
 //  OpenSwiftUI_SPITests
 
 import Numerics
@@ -16,7 +16,7 @@ import UIKit
 #endif
 
 @MainActor
-struct OpenSwiftUICoreColorTests {
+struct CoreColorTests {
     @Test
     func platformColorGetComponents() {
         #if os(macOS)
@@ -33,17 +33,17 @@ struct OpenSwiftUICoreColorTests {
         var g: CGFloat = 0
         var b: CGFloat = 0
         var a: CGFloat = 0
-        #expect(OpenSwiftUICoreColorPlatformColorGetComponents(isAppKitBased(), blackColor, &r, &g, &b, &a) == true)
+        #expect(CoreColorPlatformColorGetComponents(system: isAppKitBased() ? .appKit : .uiKit, color: blackColor, red: &r, green: &g, blue: &b, alpha: &a) == true)
         #expect(r.isApproximatelyEqual(to: 0))
         #expect(g.isApproximatelyEqual(to: 0))
         #expect(b.isApproximatelyEqual(to: 0))
         #expect(a.isApproximatelyEqual(to: 1))
-        #expect(OpenSwiftUICoreColorPlatformColorGetComponents(isAppKitBased(), grayColor, &r, &g, &b, &a) == true)
+        #expect(CoreColorPlatformColorGetComponents(system: isAppKitBased() ? .appKit : .uiKit, color: grayColor, red: &r, green: &g, blue: &b, alpha: &a) == true)
         #expect(r.isApproximatelyEqual(to: 0.5))
         #expect(g.isApproximatelyEqual(to: 0.5))
         #expect(b.isApproximatelyEqual(to: 0.5))
         #expect(a.isApproximatelyEqual(to: 1))
-        #expect(OpenSwiftUICoreColorPlatformColorGetComponents(isAppKitBased(), whiteColor, &r, &g, &b, &a) == true)
+        #expect(CoreColorPlatformColorGetComponents(system: isAppKitBased() ? .appKit : .uiKit, color: whiteColor, red: &r, green: &g, blue: &b, alpha: &a) == true)
         #expect(r.isApproximatelyEqual(to: 1))
         #expect(g.isApproximatelyEqual(to: 1))
         #expect(b.isApproximatelyEqual(to: 1))
@@ -52,9 +52,9 @@ struct OpenSwiftUICoreColorTests {
 
     @Test
     func platformColorForRGBA() throws {
-        let blackColorObject = try #require(OpenSwiftUICorePlatformColorForRGBA(isAppKitBased(), 0, 0, 0, 1))
-        let greyColorObject = try #require(OpenSwiftUICorePlatformColorForRGBA(isAppKitBased(), 0.5, 0.5, 0.5, 1))
-        let whiteColorObject = try #require(OpenSwiftUICorePlatformColorForRGBA(isAppKitBased(), 1, 1, 1, 1))
+        let blackColorObject = try #require(CorePlatformColorForRGBA(system: isAppKitBased() ? .appKit : .uiKit, red: 0, green: 0, blue: 0, alpha: 1))
+        let greyColorObject = try #require(CorePlatformColorForRGBA(system: isAppKitBased() ? .appKit : .uiKit, red: 0.5, green: 0.5, blue: 0.5, alpha: 1))
+        let whiteColorObject = try #require(CorePlatformColorForRGBA(system: isAppKitBased() ? .appKit : .uiKit, red: 1, green: 1, blue: 1, alpha: 1))
         #if os(macOS)
         let blackColor = try #require((blackColorObject as? NSColor)?.usingColorSpace(.deviceRGB))
         let greyColor = try #require(greyColorObject as? NSColor)
@@ -98,7 +98,7 @@ struct OpenSwiftUICoreColorTests {
 
     @Test
     func getKitColorClass() {
-        let colorClass: AnyClass? = OpenSwiftUICoreColorGetKitColorClass(isAppKitBased())
+        let colorClass: AnyClass? = CoreColorGetKitColorClass(system: isAppKitBased() ? .appKit : .uiKit)
         #if os(macOS)
         #expect(colorClass == NSColor.self)
         #elseif os(iOS)

Tests/OpenSwiftUI_SPITests/Overlay/CoreGraphics/OpenSwiftUICoreGraphicsContext.swift → Tests/OpenSwiftUI_SPITests/Overlay/CoreGraphics/CoreGraphicsContextTests.swift

@@ -1,5 +1,5 @@
 //
-//  OpenSwiftUICoreGraphicsContextTests.swift
+//  CoreGraphicsContextTests.swift
 //  OpenSwiftUI_SPITests
 
 import OpenSwiftUI_SPI
@@ -10,7 +10,7 @@ import CoreGraphics
 import Foundation
 
 @MainActor
-struct OpenSwiftUICoreGraphicsContextTests {
+struct CoreGraphicsContextTests {
     @Test
     func example() async throws {
         let width = 200
@@ -30,12 +30,12 @@ struct OpenSwiftUICoreGraphicsContextTests {
             fatalError("Could not create CGContext")
         }
 
-        let context = OpenSwiftUICoreGraphicsContext(cgContext: cgContext)
-        #expect(OpenSwiftUICoreGraphicsContext.current == nil)
+        let context = CoreGraphicsContext(cgContext: cgContext)
+        #expect(CoreGraphicsContext.current == nil)
         context.push()
-        #expect(OpenSwiftUICoreGraphicsContext.current != nil)
+        #expect(CoreGraphicsContext.current != nil)
         context.pop()
-        #expect(OpenSwiftUICoreGraphicsContext.current == nil)
+        #expect(CoreGraphicsContext.current == nil)
     }
 }
 

Tests/OpenSwiftUI_SPITests/Overlay/CoreGraphics/CorePlatformImageTests.swift

@@ -0,0 +1,41 @@
+//
+//  CorePlatformImageTests.swift
+//  OpenSwiftUI_SPITests
+
+#if canImport(Darwin)
+import CoreGraphics
+import Foundation
+import OpenSwiftUI_SPI
+import OpenSwiftUICore
+import Testing
+
+@MainActor
+struct CorePlatformImageTests {
+    @Test
+    func nilCGImage() {
+        let image: NSObject
+        #if os(iOS)
+        image = UIImage()
+        #elseif os(macOS)
+        image = NSImage(size: CGSize(width: 100, height: 100))
+        #endif
+        let coreImage = CorePlatformImage(system: .appKit, kitImage: image)
+        #expect(coreImage.cgImage == nil)
+        #expect(coreImage.size == .zero)
+    }
+
+    @Test
+    func nonNilCGImage() {
+        let image: NSObject
+        #if os(iOS)
+        image = UIImage.add
+        #elseif os(macOS)
+        image = NSImage(named: NSImage.addTemplateName)!
+        #endif
+        let coreImage = CorePlatformImage(system: .appKit, kitImage: image)
+        #expect(coreImage.cgImage != nil)
+        #expect(coreImage.size != .zero)
+    }
+}
+
+#endif