Documentation Archive Developer
Search

CoreGraphics Changes for Swift

CoreGraphics

Removed CGColorConverterTransformType [enum]
Removed CGColorConverterTransformType.applySpace
Removed CGColorConverterTransformType.fromSpace
Removed CGColorConverterTransformType.toSpace
Removed CGFloat.advancedBy(_: CGFloat) -> CGFloat
Removed CGFloat.distanceTo(_: CGFloat) -> CGFloat
Removed CGFloat.isSignaling
Removed CGFloat.isSignMinus
Removed CGFloat.max
Removed CGFloat.min
Removed CGFloat.NaN
Removed CGFloat.quietNaN
Removed CGPatternCallbacks.init(version: UInt32, drawPattern: CGPatternDrawPatternCallback?, releaseInfo: CGPatternReleaseInfoCallback?)
Removed CGRect.contains(_: CGPoint) -> Bool
Removed CGRect.contains(_: CGRect) -> Bool
Removed CGRect.divide(_: CGFloat, fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
Removed CGRect.height
Removed CGRect.infinite
Removed CGRect.insetBy(dx: CGFloat, dy: CGFloat) -> CGRect
Removed CGRect.insetInPlace(dx: CGFloat, dy: CGFloat)
Removed CGRect.integral
Removed CGRect.intersect(_: CGRect) -> CGRect
Removed CGRect.intersectInPlace(_: CGRect)
Removed CGRect.intersects(_: CGRect) -> Bool
Removed CGRect.isEmpty
Removed CGRect.isInfinite
Removed CGRect.isNull
Removed CGRect.makeIntegralInPlace()
Removed CGRect.maxX
Removed CGRect.maxY
Removed CGRect.midX
Removed CGRect.midY
Removed CGRect.minX
Removed CGRect.minY
Removed CGRect.null
Removed CGRect.offsetBy(dx: CGFloat, dy: CGFloat) -> CGRect
Removed CGRect.offsetInPlace(dx: CGFloat, dy: CGFloat)
Removed CGRect.standardized
Removed CGRect.standardizeInPlace()
Removed CGRect.union(_: CGRect) -> CGRect
Removed CGRect.unionInPlace(_: CGRect)
Removed CGRect.width
Removed %(_: CGFloat, _: CGFloat) -> CGFloat
Removed %=(_: CGFloat, _: CGFloat)
Removed +(_: CGFloat) -> CGFloat
Removed ++(_: CGFloat) -> CGFloat
Removed ++(_: CGFloat) -> CGFloat
Removed -(_: CGFloat) -> CGFloat
Removed --(_: CGFloat) -> CGFloat
Removed --(_: CGFloat) -> CGFloat
Removed <(_: CGFloat, _: CGFloat) -> Bool
Removed ==(_: CGFloat, _: CGFloat) -> Bool
Removed ceil(_: CGFloat) -> CGFloat
Removed CGAffineTransformIdentity
Removed CGColorConverter
Removed CGColorConverterCreateSimple(_: CGColorSpace?, _: CGColorSpace?) -> CGColorConverterRef
Removed CGColorConverterGetTypeID() -> CFTypeID
Removed CGColorConverterRelease(_: CGColorConverterRef)
Removed CGPointZero
Removed CGPointZero
Removed CGRectZero
Removed CGRectZero
Removed CGSizeZero
Removed CGSizeZero
Removed fabs(_: CGFloat) -> CGFloat
Removed floor(_: CGFloat) -> CGFloat
Removed fma(_: CGFloat, _: CGFloat, _: CGFloat) -> CGFloat
Removed fmod(_: CGFloat, _: CGFloat) -> CGFloat
Removed fpclassify(_: CGFloat) -> Int
Removed isfinite(_: CGFloat) -> Bool
Removed isinf(_: CGFloat) -> Bool
Removed isnan(_: CGFloat) -> Bool
Removed isnormal(_: CGFloat) -> Bool
Removed remainder(_: CGFloat, _: CGFloat) -> CGFloat
Removed round(_: CGFloat) -> CGFloat
Removed signbit(_: CGFloat) -> Int
Removed sqrt(_: CGFloat) -> CGFloat
Removed trunc(_: CGFloat) -> CGFloat
Added CGFloat.add(_: CGFloat)
Added CGFloat.divide(by: CGFloat)
Added CGFloat.multiply(by: CGFloat)
Added CGFloat.subtract(_: CGFloat)
Added ==(_: CGAffineTransform, _: CGAffineTransform) -> Bool
Added ==(_: CGColor, _: CGColor) -> Bool
Added ==(_: CGPath, _: CGPath) -> Bool
DeclarationProtocols
From
struct CGAffineTransform {
    var a: CGFloat
    var b: CGFloat
    var c: CGFloat
    var d: CGFloat
    var tx: CGFloat
    var ty: CGFloat
    init()
    init(a a: CGFloat, b b: CGFloat, c c: CGFloat, d d: CGFloat, tx tx: CGFloat, ty ty: CGFloat)
}
--
To
struct CGAffineTransform {
    var a: CGFloat
    var b: CGFloat
    var c: CGFloat
    var d: CGFloat
    var tx: CGFloat
    var ty: CGFloat
    init()
    init(a a: CGFloat, b b: CGFloat, c c: CGFloat, d d: CGFloat, tx tx: CGFloat, ty ty: CGFloat)
    static let identity: CGAffineTransform
    init(a a: CGFloat, b b: CGFloat, c c: CGFloat, d d: CGFloat, tx tx: CGFloat, ty ty: CGFloat)
     init(translationX tx: CGFloat, y ty: CGFloat)
     init(scaleX sx: CGFloat, y sy: CGFloat)
     init(rotationAngle angle: CGFloat)
    var isIdentity: Bool { get }
    func translatedBy(x tx: CGFloat, y ty: CGFloat) -> CGAffineTransform
    func scaledBy(x sx: CGFloat, y sy: CGFloat) -> CGAffineTransform
    func rotated(by angle: CGFloat) -> CGAffineTransform
    func inverted() -> CGAffineTransform
    func concatenating(_ t2: CGAffineTransform) -> CGAffineTransform
    func __equalTo(_ t2: CGAffineTransform) -> Bool
    static var identity: CGAffineTransform { get }
}
extension CGAffineTransform {
    static let identity: CGAffineTransform
    init(a a: CGFloat, b b: CGFloat, c c: CGFloat, d d: CGFloat, tx tx: CGFloat, ty ty: CGFloat)
     init(translationX tx: CGFloat, y ty: CGFloat)
     init(scaleX sx: CGFloat, y sy: CGFloat)
     init(rotationAngle angle: CGFloat)
    var isIdentity: Bool { get }
    func translatedBy(x tx: CGFloat, y ty: CGFloat) -> CGAffineTransform
    func scaledBy(x sx: CGFloat, y sy: CGFloat) -> CGAffineTransform
    func rotated(by angle: CGFloat) -> CGAffineTransform
    func inverted() -> CGAffineTransform
    func concatenating(_ t2: CGAffineTransform) -> CGAffineTransform
    func __equalTo(_ t2: CGAffineTransform) -> Bool
}
extension CGAffineTransform {
    static var identity: CGAffineTransform { get }
}
extension CGAffineTransform : Equatable {
}
Equatable

NameDeclaration
FromCGAffineTransformConcat(_:_:)
func CGAffineTransformConcat(_ t1: CGAffineTransform, _ t2: CGAffineTransform) -> CGAffineTransform
Toconcatenating(_:)
func concatenating(_ t2: CGAffineTransform) -> CGAffineTransform

NameDeclaration
FromCGAffineTransformMakeRotation(_:)
func CGAffineTransformMakeRotation(_ angle: CGFloat) -> CGAffineTransform
Toinit(rotationAngle:)
init(rotationAngle angle: CGFloat)

NameDeclaration
FromCGAffineTransformMakeScale(_:_:)
func CGAffineTransformMakeScale(_ sx: CGFloat, _ sy: CGFloat) -> CGAffineTransform
Toinit(scaleX:y:)
init(scaleX sx: CGFloat, y sy: CGFloat)

NameDeclaration
FromCGAffineTransformMakeTranslation(_:_:)
func CGAffineTransformMakeTranslation(_ tx: CGFloat, _ ty: CGFloat) -> CGAffineTransform
Toinit(translationX:y:)
init(translationX tx: CGFloat, y ty: CGFloat)

NameDeclaration
FromCGAffineTransformInvert(_:)
func CGAffineTransformInvert(_ t: CGAffineTransform) -> CGAffineTransform
Toinverted()
func inverted() -> CGAffineTransform

NameDeclarationReadonly
FromCGAffineTransformIsIdentity(_:)
func CGAffineTransformIsIdentity(_ t: CGAffineTransform) -> Bool
--
ToisIdentity
var isIdentity: Bool { get }
yes

NameDeclaration
FromCGAffineTransformRotate(_:_:)
func CGAffineTransformRotate(_ t: CGAffineTransform, _ angle: CGFloat) -> CGAffineTransform
Torotated(by:)
func rotated(by angle: CGFloat) -> CGAffineTransform

NameDeclaration
FromCGAffineTransformScale(_:_:_:)
func CGAffineTransformScale(_ t: CGAffineTransform, _ sx: CGFloat, _ sy: CGFloat) -> CGAffineTransform
ToscaledBy(x:y:)
func scaledBy(x sx: CGFloat, y sy: CGFloat) -> CGAffineTransform

NameDeclaration
FromCGAffineTransformTranslate(_:_:_:)
func CGAffineTransformTranslate(_ t: CGAffineTransform, _ tx: CGFloat, _ ty: CGFloat) -> CGAffineTransform
TotranslatedBy(x:y:)
func translatedBy(x tx: CGFloat, y ty: CGFloat) -> CGAffineTransform

DeclarationProtocols
From
struct CGBitmapInfo : OptionSetType {
    init(rawValue rawValue: UInt32)
    static var AlphaInfoMask: CGBitmapInfo { get }
    static var FloatInfoMask: CGBitmapInfo { get }
    static var FloatComponents: CGBitmapInfo { get }
    static var ByteOrderMask: CGBitmapInfo { get }
    static var ByteOrderDefault: CGBitmapInfo { get }
    static var ByteOrder16Little: CGBitmapInfo { get }
    static var ByteOrder32Little: CGBitmapInfo { get }
    static var ByteOrder16Big: CGBitmapInfo { get }
    static var ByteOrder32Big: CGBitmapInfo { get }
}
OptionSetType
To
struct CGBitmapInfo : OptionSet {
    init(rawValue rawValue: UInt32)
    static var alphaInfoMask: CGBitmapInfo { get }
    static var floatInfoMask: CGBitmapInfo { get }
    static var floatComponents: CGBitmapInfo { get }
    static var byteOrderMask: CGBitmapInfo { get }
    static var byteOrderDefault: CGBitmapInfo { get }
    static var byteOrder16Little: CGBitmapInfo { get }
    static var byteOrder32Little: CGBitmapInfo { get }
    static var byteOrder16Big: CGBitmapInfo { get }
    static var byteOrder32Big: CGBitmapInfo { get }
    func intersect(_ other: CGBitmapInfo) -> CGBitmapInfo
    func exclusiveOr(_ other: CGBitmapInfo) -> CGBitmapInfo
    mutating func unionInPlace(_ other: CGBitmapInfo)
    mutating func intersectInPlace(_ other: CGBitmapInfo)
    mutating func exclusiveOrInPlace(_ other: CGBitmapInfo)
    func isSubsetOf(_ other: CGBitmapInfo) -> Bool
    func isDisjointWith(_ other: CGBitmapInfo) -> Bool
    func isSupersetOf(_ other: CGBitmapInfo) -> Bool
    mutating func subtractInPlace(_ other: CGBitmapInfo)
    func isStrictSupersetOf(_ other: CGBitmapInfo) -> Bool
    func isStrictSubsetOf(_ other: CGBitmapInfo) -> Bool
}
extension CGBitmapInfo {
    func union(_ other: CGBitmapInfo) -> CGBitmapInfo
    func intersection(_ other: CGBitmapInfo) -> CGBitmapInfo
    func symmetricDifference(_ other: CGBitmapInfo) -> CGBitmapInfo
}
extension CGBitmapInfo {
    func contains(_ member: CGBitmapInfo) -> Bool
    mutating func insert(_ newMember: CGBitmapInfo) -> (inserted: Bool, memberAfterInsert: CGBitmapInfo)
    mutating func remove(_ member: CGBitmapInfo) -> CGBitmapInfo?
    mutating func update(with newMember: CGBitmapInfo) -> CGBitmapInfo?
}
extension CGBitmapInfo {
    convenience init()
    mutating func formUnion(_ other: CGBitmapInfo)
    mutating func formIntersection(_ other: CGBitmapInfo)
    mutating func formSymmetricDifference(_ other: CGBitmapInfo)
}
extension CGBitmapInfo {
    convenience init<S : Sequence where S.Iterator.Element == CGBitmapInfo>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: CGBitmapInfo...)
    mutating func subtract(_ other: CGBitmapInfo)
    func isSubset(of other: CGBitmapInfo) -> Bool
    func isSuperset(of other: CGBitmapInfo) -> Bool
    func isDisjoint(with other: CGBitmapInfo) -> Bool
    func subtracting(_ other: CGBitmapInfo) -> CGBitmapInfo
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: CGBitmapInfo) -> Bool
    func isStrictSubset(of other: CGBitmapInfo) -> Bool
}
OptionSet

Declaration
From
static var AlphaInfoMask: CGBitmapInfo { get }
To
static var alphaInfoMask: CGBitmapInfo { get }

Declaration
From
static var ByteOrder16Big: CGBitmapInfo { get }
To
static var byteOrder16Big: CGBitmapInfo { get }

Declaration
From
static var ByteOrder16Little: CGBitmapInfo { get }
To
static var byteOrder16Little: CGBitmapInfo { get }

Declaration
From
static var ByteOrder32Big: CGBitmapInfo { get }
To
static var byteOrder32Big: CGBitmapInfo { get }

Declaration
From
static var ByteOrder32Little: CGBitmapInfo { get }
To
static var byteOrder32Little: CGBitmapInfo { get }

Declaration
From
static var ByteOrderMask: CGBitmapInfo { get }
To
static var byteOrderMask: CGBitmapInfo { get }

Declaration
From
static var FloatComponents: CGBitmapInfo { get }
To
static var floatComponents: CGBitmapInfo { get }

Declaration
From
static var FloatInfoMask: CGBitmapInfo { get }
To
static var floatInfoMask: CGBitmapInfo { get }

Declaration
From
enum CGBlendMode : Int32 {
    case Normal
    case Multiply
    case Screen
    case Overlay
    case Darken
    case Lighten
    case ColorDodge
    case ColorBurn
    case SoftLight
    case HardLight
    case Difference
    case Exclusion
    case Hue
    case Saturation
    case Color
    case Luminosity
    case Clear
    case Copy
    case SourceIn
    case SourceOut
    case SourceAtop
    case DestinationOver
    case DestinationIn
    case DestinationOut
    case DestinationAtop
    case XOR
    case PlusDarker
    case PlusLighter
}
To
enum CGBlendMode : Int32 {
    case normal
    case multiply
    case screen
    case overlay
    case darken
    case lighten
    case colorDodge
    case colorBurn
    case softLight
    case hardLight
    case difference
    case exclusion
    case hue
    case saturation
    case color
    case luminosity
    case clear
    case copy
    case sourceIn
    case sourceOut
    case sourceAtop
    case destinationOver
    case destinationIn
    case destinationOut
    case destinationAtop
    case xor
    case plusDarker
    case plusLighter
}

Declaration
From
case Clear
To
case clear

Declaration
From
case Color
To
case color

Declaration
From
case ColorBurn
To
case colorBurn

Declaration
From
case ColorDodge
To
case colorDodge

Declaration
From
case Copy
To
case copy

Declaration
From
case Darken
To
case darken

Declaration
From
case DestinationAtop
To
case destinationAtop

Declaration
From
case DestinationIn
To
case destinationIn

Declaration
From
case DestinationOut
To
case destinationOut

Declaration
From
case DestinationOver
To
case destinationOver

Declaration
From
case Difference
To
case difference

Declaration
From
case Exclusion
To
case exclusion

Declaration
From
case HardLight
To
case hardLight

Declaration
From
case Hue
To
case hue

Declaration
From
case Lighten
To
case lighten

Declaration
From
case Luminosity
To
case luminosity

Declaration
From
case Multiply
To
case multiply

Declaration
From
case Normal
To
case normal

Declaration
From
case Overlay
To
case overlay

Declaration
From
case PlusDarker
To
case plusDarker

Declaration
From
case PlusLighter
To
case plusLighter

Declaration
From
case Saturation
To
case saturation

Declaration
From
case Screen
To
case screen

Declaration
From
case SoftLight
To
case softLight

Declaration
From
case SourceAtop
To
case sourceAtop

Declaration
From
case SourceIn
To
case sourceIn

Declaration
From
case SourceOut
To
case sourceOut

Declaration
From
case XOR
To
case xor

Modified CGColor
DeclarationProtocols
From
class CGColor {
}
--
To
class CGColor {
    var components: [CGFloat]? { get }
     init?(colorSpace space: CGColorSpace, components components: UnsafePointer<CGFloat>)
     init(gray gray: CGFloat, alpha alpha: CGFloat)
     init(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    init(genericCMYKCyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    class func __constantColor(for colorName: CFString) -> CGColor?
     init?(patternSpace space: CGColorSpace, pattern pattern: CGPattern, components components: UnsafePointer<CGFloat>)
    func copy() -> CGColor?
    func copy(alpha alpha: CGFloat) -> CGColor?
    func converted(to _: CGColorSpace, intent intent: CGColorRenderingIntent, options options: CFDictionary?) -> CGColor?
    func __equalTo(_ color2: CGColor) -> Bool
    var numberOfComponents: Int { get }
    var __unsafeComponents: UnsafePointer<CGFloat>? { get }
    var alpha: CGFloat { get }
    var colorSpace: CGColorSpace? { get }
    var pattern: CGPattern? { get }
    class var typeID: CFTypeID { get }
    class let __whiteColorName: CFString
    class let __blackColorName: CFString
    class let __clearColorName: CFString
    class let conversionBlackPointCompensation: CFString
}
extension CGColor {
     init?(colorSpace space: CGColorSpace, components components: UnsafePointer<CGFloat>)
     init(gray gray: CGFloat, alpha alpha: CGFloat)
     init(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    init(genericCMYKCyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    class func __constantColor(for colorName: CFString) -> CGColor?
     init?(patternSpace space: CGColorSpace, pattern pattern: CGPattern, components components: UnsafePointer<CGFloat>)
    func copy() -> CGColor?
    func copy(alpha alpha: CGFloat) -> CGColor?
    func converted(to _: CGColorSpace, intent intent: CGColorRenderingIntent, options options: CFDictionary?) -> CGColor?
    func __equalTo(_ color2: CGColor) -> Bool
    var numberOfComponents: Int { get }
    var __unsafeComponents: UnsafePointer<CGFloat>? { get }
    var alpha: CGFloat { get }
    var colorSpace: CGColorSpace? { get }
    var pattern: CGPattern? { get }
    class var typeID: CFTypeID { get }
    class let __whiteColorName: CFString
    class let __blackColorName: CFString
    class let __clearColorName: CFString
}
extension CGColor {
    class let conversionBlackPointCompensation: CFString
}
extension CGColor : Equatable {
}
extension CGColor {
    var components: [CGFloat]? { get }
}
Equatable

NameDeclarationReadonly
FromCGColorGetAlpha(_:)
func CGColorGetAlpha(_ color: CGColor?) -> CGFloat
--
Toalpha
var alpha: CGFloat { get }
yes

NameDeclarationReadonly
FromCGColorGetColorSpace(_:)
func CGColorGetColorSpace(_ color: CGColor?) -> CGColorSpace?
--
TocolorSpace
var colorSpace: CGColorSpace? { get }
yes

NameDeclaration
FromCGColorCreateCopyByMatchingToColorSpace(_:_:_:_:)
func CGColorCreateCopyByMatchingToColorSpace(_ _: CGColorSpace?, _ intent: CGColorRenderingIntent, _ color: CGColor?, _ options: CFDictionary?) -> CGColor?
Toconverted(to:intent:options:)
func converted(to _: CGColorSpace, intent intent: CGColorRenderingIntent, options options: CFDictionary?) -> CGColor?

NameDeclaration
FromCGColorCreateCopy(_:)
func CGColorCreateCopy(_ color: CGColor?) -> CGColor?
Tocopy()
func copy() -> CGColor?

NameDeclaration
FromCGColorCreateCopyWithAlpha(_:_:)
func CGColorCreateCopyWithAlpha(_ color: CGColor?, _ alpha: CGFloat) -> CGColor?
Tocopy(alpha:)
func copy(alpha alpha: CGFloat) -> CGColor?

NameDeclaration
FromCGColorCreate(_:_:)
func CGColorCreate(_ space: CGColorSpace?, _ components: UnsafePointer<CGFloat>) -> CGColor?
Toinit(colorSpace:components:)
init?(colorSpace space: CGColorSpace, components components: UnsafePointer<CGFloat>)

NameDeclaration
FromCGColorCreateWithPattern(_:_:_:)
func CGColorCreateWithPattern(_ space: CGColorSpace?, _ pattern: CGPattern?, _ components: UnsafePointer<CGFloat>) -> CGColor?
Toinit(patternSpace:pattern:components:)
init?(patternSpace space: CGColorSpace, pattern pattern: CGPattern, components components: UnsafePointer<CGFloat>)

NameDeclarationReadonly
FromCGColorGetNumberOfComponents(_:)
func CGColorGetNumberOfComponents(_ color: CGColor?) -> Int
--
TonumberOfComponents
var numberOfComponents: Int { get }
yes

NameDeclarationReadonly
FromCGColorGetPattern(_:)
func CGColorGetPattern(_ color: CGColor?) -> CGPattern?
--
Topattern
var pattern: CGPattern? { get }
yes

NameDeclaration
FromCGColorGetTypeID()
func CGColorGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
enum CGColorRenderingIntent : Int32 {
    case RenderingIntentDefault
    case RenderingIntentAbsoluteColorimetric
    case RenderingIntentRelativeColorimetric
    case RenderingIntentPerceptual
    case RenderingIntentSaturation
}
To
enum CGColorRenderingIntent : Int32 {
    case defaultIntent
    case absoluteColorimetric
    case relativeColorimetric
    case perceptual
    case saturation
}

Declaration
From
case RenderingIntentAbsoluteColorimetric
To
case absoluteColorimetric

Declaration
From
case RenderingIntentDefault
To
case defaultIntent

Declaration
From
case RenderingIntentPerceptual
To
case perceptual

Declaration
From
case RenderingIntentRelativeColorimetric
To
case relativeColorimetric

Declaration
From
case RenderingIntentSaturation
To
case saturation

Modified CGColorSpace
Declaration
From
class CGColorSpace {
}
To
class CGColorSpace {
    var colorTable: [UInt8]? { get }
    class let genericGray: CFString
    class let genericRGB: CFString
    class let genericCMYK: CFString
    class let displayP3: CFString
    class let genericRGBLinear: CFString
    class let adobeRGB1998: CFString
    class let sRGB: CFString
    class let genericGrayGamma2_2: CFString
    class let genericXYZ: CFString
    class let acescgLinear: CFString
    class let itur_709: CFString
    class let itur_2020: CFString
    class let rommrgb: CFString
    class let dcip3: CFString
    class let extendedSRGB: CFString
    class let linearSRGB: CFString
    class let extendedLinearSRGB: CFString
    class let extendedGray: CFString
    class let linearGray: CFString
    class let extendedLinearGray: CFString
    init?(calibratedGrayWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: CGFloat)
    init?(calibratedRGBWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: UnsafePointer<CGFloat>!, matrix matrix: UnsafePointer<CGFloat>!)
    init?(labWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, range range: UnsafePointer<CGFloat>!)
     init?(iccProfileData data: CFData)
    init?(iccBasedNComponents nComponents: Int, range range: UnsafePointer<CGFloat>?, profile profile: CGDataProvider, alternate alternate: CGColorSpace?)
    init?(indexedBaseSpace baseSpace: CGColorSpace, last lastIndex: Int, colorTable colorTable: UnsafePointer<UInt8>)
    init?(patternBaseSpace baseSpace: CGColorSpace?)
     init?(platformColorSpaceRef ref: UnsafeRawPointer)
     init?(name name: CFString)
    var name: CFString? { get }
    class var typeID: CFTypeID { get }
    var numberOfComponents: Int { get }
    var model: CGColorSpaceModel { get }
    var baseColorSpace: CGColorSpace? { get }
    var __colorTableCount: Int { get }
    func __unsafeGetColorTable(_ table: UnsafeMutablePointer<UInt8>)
    var iccData: CFData? { get }
    func copyICCData() -> CFData?
    var isWideGamutRGB: Bool { get }
    var supportsOutput: Bool { get }
}
extension CGColorSpace {
    class let genericGray: CFString
    class let genericRGB: CFString
    class let genericCMYK: CFString
    class let displayP3: CFString
    class let genericRGBLinear: CFString
    class let adobeRGB1998: CFString
    class let sRGB: CFString
    class let genericGrayGamma2_2: CFString
    class let genericXYZ: CFString
    class let acescgLinear: CFString
    class let itur_709: CFString
    class let itur_2020: CFString
    class let rommrgb: CFString
    class let dcip3: CFString
    class let extendedSRGB: CFString
    class let linearSRGB: CFString
    class let extendedLinearSRGB: CFString
    class let extendedGray: CFString
    class let linearGray: CFString
    class let extendedLinearGray: CFString
    init?(calibratedGrayWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: CGFloat)
    init?(calibratedRGBWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: UnsafePointer<CGFloat>!, matrix matrix: UnsafePointer<CGFloat>!)
    init?(labWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, range range: UnsafePointer<CGFloat>!)
     init?(iccProfileData data: CFData)
    init?(iccBasedNComponents nComponents: Int, range range: UnsafePointer<CGFloat>?, profile profile: CGDataProvider, alternate alternate: CGColorSpace?)
    init?(indexedBaseSpace baseSpace: CGColorSpace, last lastIndex: Int, colorTable colorTable: UnsafePointer<UInt8>)
    init?(patternBaseSpace baseSpace: CGColorSpace?)
     init?(platformColorSpaceRef ref: UnsafeRawPointer)
     init?(name name: CFString)
    var name: CFString? { get }
    class var typeID: CFTypeID { get }
    var numberOfComponents: Int { get }
    var model: CGColorSpaceModel { get }
    var baseColorSpace: CGColorSpace? { get }
    var __colorTableCount: Int { get }
    func __unsafeGetColorTable(_ table: UnsafeMutablePointer<UInt8>)
    var iccData: CFData? { get }
    func copyICCData() -> CFData?
    var isWideGamutRGB: Bool { get }
    var supportsOutput: Bool { get }
}
extension CGColorSpace {
    var colorTable: [UInt8]? { get }
}

NameDeclaration
FromkCGColorSpaceACESCGLinear
let kCGColorSpaceACESCGLinear: CFString
ToacescgLinear
class let acescgLinear: CFString

NameDeclaration
FromkCGColorSpaceAdobeRGB1998
let kCGColorSpaceAdobeRGB1998: CFString
ToadobeRGB1998
class let adobeRGB1998: CFString

NameDeclarationReadonly
FromCGColorSpaceGetBaseColorSpace(_:)
func CGColorSpaceGetBaseColorSpace(_ space: CGColorSpace?) -> CGColorSpace?
--
TobaseColorSpace
var baseColorSpace: CGColorSpace? { get }
yes

NameDeclaration
FromkCGColorSpaceDCIP3
let kCGColorSpaceDCIP3: CFString
Todcip3
class let dcip3: CFString

NameDeclarationIntroduction
FromkCGColorSpaceDisplayP3
let kCGColorSpaceDisplayP3: CFString
iOS 9.0
TodisplayP3
class let displayP3: CFString
iOS 9.3

NameDeclaration
FromkCGColorSpaceGenericCMYK
let kCGColorSpaceGenericCMYK: CFString
TogenericCMYK
class let genericCMYK: CFString

NameDeclaration
FromkCGColorSpaceGenericGrayGamma2_2
let kCGColorSpaceGenericGrayGamma2_2: CFString
TogenericGrayGamma2_2
class let genericGrayGamma2_2: CFString

NameDeclaration
FromkCGColorSpaceGenericRGBLinear
let kCGColorSpaceGenericRGBLinear: CFString
TogenericRGBLinear
class let genericRGBLinear: CFString

NameDeclaration
FromkCGColorSpaceGenericXYZ
let kCGColorSpaceGenericXYZ: CFString
TogenericXYZ
class let genericXYZ: CFString

NameDeclarationIntroductionReadonly
FromCGColorSpaceCopyICCProfile(_:)
func CGColorSpaceCopyICCProfile(_ space: CGColorSpace?) -> CFData?
iOS 6.0--
ToiccData
var iccData: CFData? { get }
iOS 10.0yes

NameDeclaration
FromCGColorSpaceCreateCalibratedGray(_:_:_:)
func CGColorSpaceCreateCalibratedGray(_ whitePoint: UnsafePointer<CGFloat>, _ blackPoint: UnsafePointer<CGFloat>, _ gamma: CGFloat) -> CGColorSpace?
Toinit(calibratedGrayWhitePoint:blackPoint:gamma:)
init?(calibratedGrayWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: CGFloat)

NameDeclaration
FromCGColorSpaceCreateCalibratedRGB(_:_:_:_:)
func CGColorSpaceCreateCalibratedRGB(_ whitePoint: UnsafePointer<CGFloat>, _ blackPoint: UnsafePointer<CGFloat>, _ gamma: UnsafePointer<CGFloat>, _ matrix: UnsafePointer<CGFloat>) -> CGColorSpace?
Toinit(calibratedRGBWhitePoint:blackPoint:gamma:matrix:)
init?(calibratedRGBWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, gamma gamma: UnsafePointer<CGFloat>!, matrix matrix: UnsafePointer<CGFloat>!)

NameDeclaration
FromCGColorSpaceCreateICCBased(_:_:_:_:)
func CGColorSpaceCreateICCBased(_ nComponents: Int, _ range: UnsafePointer<CGFloat>, _ profile: CGDataProvider?, _ alternate: CGColorSpace?) -> CGColorSpace?
Toinit(iccBasedNComponents:range:profile:alternate:)
init?(iccBasedNComponents nComponents: Int, range range: UnsafePointer<CGFloat>?, profile profile: CGDataProvider, alternate alternate: CGColorSpace?)

NameDeclaration
FromCGColorSpaceCreateWithICCProfile(_:)
func CGColorSpaceCreateWithICCProfile(_ data: CFData?) -> CGColorSpace?
Toinit(iccProfileData:)
init?(iccProfileData data: CFData)

NameDeclaration
FromCGColorSpaceCreateIndexed(_:_:_:)
func CGColorSpaceCreateIndexed(_ baseSpace: CGColorSpace?, _ lastIndex: Int, _ colorTable: UnsafePointer<UInt8>) -> CGColorSpace?
Toinit(indexedBaseSpace:last:colorTable:)
init?(indexedBaseSpace baseSpace: CGColorSpace, last lastIndex: Int, colorTable colorTable: UnsafePointer<UInt8>)

NameDeclaration
FromCGColorSpaceCreateLab(_:_:_:)
func CGColorSpaceCreateLab(_ whitePoint: UnsafePointer<CGFloat>, _ blackPoint: UnsafePointer<CGFloat>, _ range: UnsafePointer<CGFloat>) -> CGColorSpace?
Toinit(labWhitePoint:blackPoint:range:)
init?(labWhitePoint whitePoint: UnsafePointer<CGFloat>!, blackPoint blackPoint: UnsafePointer<CGFloat>!, range range: UnsafePointer<CGFloat>!)

NameDeclaration
FromCGColorSpaceCreateWithName(_:)
func CGColorSpaceCreateWithName(_ name: CFString?) -> CGColorSpace?
Toinit(name:)
init?(name name: CFString)

NameDeclaration
FromCGColorSpaceCreatePattern(_:)
func CGColorSpaceCreatePattern(_ baseSpace: CGColorSpace?) -> CGColorSpace?
Toinit(patternBaseSpace:)
init?(patternBaseSpace baseSpace: CGColorSpace?)

NameDeclaration
FromCGColorSpaceCreateWithPlatformColorSpace(_:)
func CGColorSpaceCreateWithPlatformColorSpace(_ ref: UnsafePointer<Void>) -> CGColorSpace?
Toinit(platformColorSpaceRef:)
init?(platformColorSpaceRef ref: UnsafeRawPointer)

NameDeclaration
FromkCGColorSpaceITUR_2020
let kCGColorSpaceITUR_2020: CFString
Toitur_2020
class let itur_2020: CFString

NameDeclaration
FromkCGColorSpaceITUR_709
let kCGColorSpaceITUR_709: CFString
Toitur_709
class let itur_709: CFString

NameDeclarationReadonly
FromCGColorSpaceGetModel(_:)
func CGColorSpaceGetModel(_ space: CGColorSpace?) -> CGColorSpaceModel
--
Tomodel
var model: CGColorSpaceModel { get }
yes

NameDeclarationReadonly
FromCGColorSpaceGetNumberOfComponents(_:)
func CGColorSpaceGetNumberOfComponents(_ space: CGColorSpace?) -> Int
--
TonumberOfComponents
var numberOfComponents: Int { get }
yes

NameDeclaration
FromkCGColorSpaceROMMRGB
let kCGColorSpaceROMMRGB: CFString
Torommrgb
class let rommrgb: CFString

NameDeclaration
FromkCGColorSpaceSRGB
let kCGColorSpaceSRGB: CFString
TosRGB
class let sRGB: CFString

NameDeclaration
FromCGColorSpaceGetTypeID()
func CGColorSpaceGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
enum CGColorSpaceModel : Int32 {
    case Unknown
    case Monochrome
    case RGB
    case CMYK
    case Lab
    case DeviceN
    case Indexed
    case Pattern
}
To
enum CGColorSpaceModel : Int32 {
    case unknown
    case monochrome
    case rgb
    case cmyk
    case lab
    case deviceN
    case indexed
    case pattern
}

Declaration
From
case CMYK
To
case cmyk

Declaration
From
case DeviceN
To
case deviceN

Declaration
From
case Indexed
To
case indexed

Declaration
From
case Lab
To
case lab

Declaration
From
case Monochrome
To
case monochrome

Declaration
From
case Pattern
To
case pattern

Declaration
From
case RGB
To
case rgb

Declaration
From
case Unknown
To
case unknown

Modified CGContext
Declaration
From
class CGContext {
}
To
class CGContext {
     init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32, releaseCallback releaseCallback: CoreGraphics.CGBitmapContextReleaseDataCallback?, releaseInfo releaseInfo: UnsafeMutableRawPointer?)
     init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32)
    var data: UnsafeMutableRawPointer? { get }
    var width: Int { get }
    var height: Int { get }
    var bitsPerComponent: Int { get }
    var bitsPerPixel: Int { get }
    var bytesPerRow: Int { get }
    var colorSpace: CGColorSpace? { get }
    var alphaInfo: CGImageAlphaInfo { get }
    var bitmapInfo: CGBitmapInfo { get }
    func makeImage() -> CGImage?
    func setLineDash(phase phase: CGFloat, lengths lengths: [CGFloat])
    func move(to point: CGPoint)
    func addLine(to point: CGPoint)
    func addCurve(to end: CGPoint, control1 control1: CGPoint, control2 control2: CGPoint)
    func addQuadCurve(to end: CGPoint, control control: CGPoint)
    func addRects(_ rects: [CGRect])
    func addLines(between points: [CGPoint])
    func addArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool)
    func addArc(tangent1End tangent1End: CGPoint, tangent2End tangent2End: CGPoint, radius radius: CGFloat)
    func fillPath(using rule: CGPathFillRule = default)
    func clip(using rule: CGPathFillRule = default)
    func fill(_ rects: [CGRect])
    func strokeLineSegments(between points: [CGPoint])
    func clip(to rects: [CGRect])
    func draw(_ image: CGImage, in rect: CGRect, byTiling byTiling: Bool = default)
    var textPosition: CGPoint
    func showGlyphs(_ glyphs: [CGGlyph], at positions: [CGPoint])
    func draw(_ layer: CGLayer, in rect: CGRect)
    func draw(_ layer: CGLayer, at point: CGPoint)
    class var typeID: CFTypeID { get }
    func saveGState()
    func restoreGState()
    func scaleBy(x sx: CGFloat, y sy: CGFloat)
    func translateBy(x tx: CGFloat, y ty: CGFloat)
    func rotate(by angle: CGFloat)
    func concatenate(_ transform: CGAffineTransform)
    var ctm: CGAffineTransform { get }
    func setLineWidth(_ width: CGFloat)
    func setLineCap(_ cap: CGLineCap)
    func setLineJoin(_ join: CGLineJoin)
    func setMiterLimit(_ limit: CGFloat)
    func __setLineDash(phase phase: CGFloat, lengths lengths: UnsafePointer<CGFloat>?, count count: Int)
    func setFlatness(_ flatness: CGFloat)
    func setAlpha(_ alpha: CGFloat)
    func setBlendMode(_ mode: CGBlendMode)
    func beginPath()
    func __moveTo(x x: CGFloat, y y: CGFloat)
    func __addLineTo(x x: CGFloat, y y: CGFloat)
    func __addCurveTo(cp1x cp1x: CGFloat, cp1y cp1y: CGFloat, cp2x cp2x: CGFloat, cp2y cp2y: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func __addQuadCurveTo(cpx cpx: CGFloat, cpy cpy: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func closePath()
    func addRect(_ rect: CGRect)
    func __addRects(_ rects: UnsafePointer<CGRect>?, count count: Int)
    func __addLines(between points: UnsafePointer<CGPoint>?, count count: Int)
    func addEllipse(in rect: CGRect)
    func __addArc(centerX x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Int32)
    func __addArc(x1 x1: CGFloat, y1 y1: CGFloat, x2 x2: CGFloat, y2 y2: CGFloat, radius radius: CGFloat)
    func addPath(_ path: CGPath)
    func replacePathWithStrokedPath()
    var isPathEmpty: Bool { get }
    var currentPointOfPath: CGPoint { get }
    var boundingBoxOfPath: CGRect { get }
    var path: CGPath? { get }
    func pathContains(_ point: CGPoint, mode mode: CGPathDrawingMode) -> Bool
    func drawPath(using mode: CGPathDrawingMode)
    func __fillPath()
    func __eoFillPath()
    func strokePath()
    func fill(_ rect: CGRect)
    func __fill(_ rects: UnsafePointer<CGRect>?, count count: Int)
    func stroke(_ rect: CGRect)
    func stroke(_ rect: CGRect, width width: CGFloat)
    func clear(_ rect: CGRect)
    func fillEllipse(in rect: CGRect)
    func strokeEllipse(in rect: CGRect)
    func __strokeLineSegments(between points: UnsafePointer<CGPoint>?, count count: Int)
    func __clip()
    func __eoClip()
    func clip(to rect: CGRect, mask mask: CGImage)
    var boundingBoxOfClipPath: CGRect { get }
    func clip(to rect: CGRect)
    func __clip(to rects: UnsafePointer<CGRect>, count count: Int)
    func setFillColor(_ color: CGColor)
    func setStrokeColor(_ color: CGColor)
    func setFillColorSpace(_ space: CGColorSpace)
    func setStrokeColorSpace(_ space: CGColorSpace)
    func setFillColor(_ components: UnsafePointer<CGFloat>)
    func setStrokeColor(_ components: UnsafePointer<CGFloat>)
    func setFillPattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)
    func setStrokePattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)
    func setPatternPhase(_ phase: CGSize)
    func setFillColor(gray gray: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(gray gray: CGFloat, alpha alpha: CGFloat)
    func setFillColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    func setFillColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    func setRenderingIntent(_ intent: CGColorRenderingIntent)
    func __draw(in rect: CGRect, image image: CGImage)
    func __draw(in rect: CGRect, byTiling image: CGImage)
    var interpolationQuality: CGInterpolationQuality
    func setShadow(offset offset: CGSize, blur blur: CGFloat, color color: CGColor?)
    func setShadow(offset offset: CGSize, blur blur: CGFloat)
    func drawLinearGradient(_ gradient: CGGradient, start startPoint: CGPoint, end endPoint: CGPoint, options options: CGGradientDrawingOptions)
    func drawRadialGradient(_ gradient: CGGradient, startCenter startCenter: CGPoint, startRadius startRadius: CGFloat, endCenter endCenter: CGPoint, endRadius endRadius: CGFloat, options options: CGGradientDrawingOptions)
    func drawShading(_ shading: CGShading)
    func setCharacterSpacing(_ spacing: CGFloat)
    func __setTextPosition(x x: CGFloat, y y: CGFloat)
    var __textPosition: CGPoint { get }
    var textMatrix: CGAffineTransform
    func setTextDrawingMode(_ mode: CGTextDrawingMode)
    func setFont(_ font: CGFont)
    func setFontSize(_ size: CGFloat)
    func __showGlyphs(_ glyphs: UnsafePointer<CGGlyph>, atPositions Lpositions: UnsafePointer<CGPoint>, count count: Int)
    func drawPDFPage(_ page: CGPDFPage)
    func beginPage(mediaBox mediaBox: UnsafePointer<CGRect>?)
    func endPage()
    func flush()
    func synchronize()
    func setShouldAntialias(_ shouldAntialias: Bool)
    func setAllowsAntialiasing(_ allowsAntialiasing: Bool)
    func setShouldSmoothFonts(_ shouldSmoothFonts: Bool)
    func setAllowsFontSmoothing(_ allowsFontSmoothing: Bool)
    func setShouldSubpixelPositionFonts(_ shouldSubpixelPositionFonts: Bool)
    func setAllowsFontSubpixelPositioning(_ allowsFontSubpixelPositioning: Bool)
    func setShouldSubpixelQuantizeFonts(_ shouldSubpixelQuantizeFonts: Bool)
    func setAllowsFontSubpixelQuantization(_ allowsFontSubpixelQuantization: Bool)
    func beginTransparencyLayer(auxiliaryInfo auxiliaryInfo: CFDictionary?)
    func beginTransparencyLayer(in rect: CGRect, auxiliaryInfo auxInfo: CFDictionary?)
    func endTransparencyLayer()
    var userSpaceToDeviceSpaceTransform: CGAffineTransform { get }
    func convertToDeviceSpace(_ point: CGPoint) -> CGPoint
    func convertToUserSpace(_ point: CGPoint) -> CGPoint
    func convertToDeviceSpace(_ size: CGSize) -> CGSize
    func convertToUserSpace(_ size: CGSize) -> CGSize
    func convertToDeviceSpace(_ rect: CGRect) -> CGRect
    func convertToUserSpace(_ rect: CGRect) -> CGRect
    func selectFont(name name: UnsafePointer<Int8>, size size: CGFloat, textEncoding textEncoding: CGTextEncoding)
    func showText(string string: UnsafePointer<Int8>, length length: Int)
    func showTextAtPoint(x x: CGFloat, y y: CGFloat, string string: UnsafePointer<Int8>, length length: Int)
    func showGlyphs(g g: UnsafePointer<CGGlyph>?, count count: Int)
    func showGlyphsAtPoint(x x: CGFloat, y y: CGFloat, glyphs glyphs: UnsafePointer<CGGlyph>?, count count: Int)
    func showGlyphsWithAdvances(glyphs glyphs: UnsafePointer<CGGlyph>?, advances advances: UnsafePointer<CGSize>?, count count: Int)
    func drawPDFDocument(_ rect: CGRect, document document: CGPDFDocument, page page: Int32)
    func __draw(in rect: CGRect, layer layer: CGLayer)
    func __draw(at point: CGPoint, layer layer: CGLayer)
     init?(consumer consumer: CGDataConsumer, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)
     init?(_ url: CFURL, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)
    func closePDF()
    func beginPDFPage(_ pageInfo: CFDictionary?)
    func endPDFPage()
    func addDocumentMetadata(_ metadata: CFData?)
    func setURL(_ url: CFURL, for rect: CGRect)
    func addDestination(_ name: CFString, at point: CGPoint)
    func setDestination(_ name: CFString, for rect: CGRect)
}
extension CGContext {
     init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32, releaseCallback releaseCallback: CoreGraphics.CGBitmapContextReleaseDataCallback?, releaseInfo releaseInfo: UnsafeMutableRawPointer?)
     init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32)
    var data: UnsafeMutableRawPointer? { get }
    var width: Int { get }
    var height: Int { get }
    var bitsPerComponent: Int { get }
    var bitsPerPixel: Int { get }
    var bytesPerRow: Int { get }
    var colorSpace: CGColorSpace? { get }
    var alphaInfo: CGImageAlphaInfo { get }
    var bitmapInfo: CGBitmapInfo { get }
    func makeImage() -> CGImage?
}
extension CGContext {
    class var typeID: CFTypeID { get }
    func saveGState()
    func restoreGState()
    func scaleBy(x sx: CGFloat, y sy: CGFloat)
    func translateBy(x tx: CGFloat, y ty: CGFloat)
    func rotate(by angle: CGFloat)
    func concatenate(_ transform: CGAffineTransform)
    var ctm: CGAffineTransform { get }
    func setLineWidth(_ width: CGFloat)
    func setLineCap(_ cap: CGLineCap)
    func setLineJoin(_ join: CGLineJoin)
    func setMiterLimit(_ limit: CGFloat)
    func __setLineDash(phase phase: CGFloat, lengths lengths: UnsafePointer<CGFloat>?, count count: Int)
    func setFlatness(_ flatness: CGFloat)
    func setAlpha(_ alpha: CGFloat)
    func setBlendMode(_ mode: CGBlendMode)
    func beginPath()
    func __moveTo(x x: CGFloat, y y: CGFloat)
    func __addLineTo(x x: CGFloat, y y: CGFloat)
    func __addCurveTo(cp1x cp1x: CGFloat, cp1y cp1y: CGFloat, cp2x cp2x: CGFloat, cp2y cp2y: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func __addQuadCurveTo(cpx cpx: CGFloat, cpy cpy: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func closePath()
    func addRect(_ rect: CGRect)
    func __addRects(_ rects: UnsafePointer<CGRect>?, count count: Int)
    func __addLines(between points: UnsafePointer<CGPoint>?, count count: Int)
    func addEllipse(in rect: CGRect)
    func __addArc(centerX x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Int32)
    func __addArc(x1 x1: CGFloat, y1 y1: CGFloat, x2 x2: CGFloat, y2 y2: CGFloat, radius radius: CGFloat)
    func addPath(_ path: CGPath)
    func replacePathWithStrokedPath()
    var isPathEmpty: Bool { get }
    var currentPointOfPath: CGPoint { get }
    var boundingBoxOfPath: CGRect { get }
    var path: CGPath? { get }
    func pathContains(_ point: CGPoint, mode mode: CGPathDrawingMode) -> Bool
    func drawPath(using mode: CGPathDrawingMode)
    func __fillPath()
    func __eoFillPath()
    func strokePath()
    func fill(_ rect: CGRect)
    func __fill(_ rects: UnsafePointer<CGRect>?, count count: Int)
    func stroke(_ rect: CGRect)
    func stroke(_ rect: CGRect, width width: CGFloat)
    func clear(_ rect: CGRect)
    func fillEllipse(in rect: CGRect)
    func strokeEllipse(in rect: CGRect)
    func __strokeLineSegments(between points: UnsafePointer<CGPoint>?, count count: Int)
    func __clip()
    func __eoClip()
    func clip(to rect: CGRect, mask mask: CGImage)
    var boundingBoxOfClipPath: CGRect { get }
    func clip(to rect: CGRect)
    func __clip(to rects: UnsafePointer<CGRect>, count count: Int)
    func setFillColor(_ color: CGColor)
    func setStrokeColor(_ color: CGColor)
    func setFillColorSpace(_ space: CGColorSpace)
    func setStrokeColorSpace(_ space: CGColorSpace)
    func setFillColor(_ components: UnsafePointer<CGFloat>)
    func setStrokeColor(_ components: UnsafePointer<CGFloat>)
    func setFillPattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)
    func setStrokePattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)
    func setPatternPhase(_ phase: CGSize)
    func setFillColor(gray gray: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(gray gray: CGFloat, alpha alpha: CGFloat)
    func setFillColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)
    func setFillColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    func setStrokeColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)
    func setRenderingIntent(_ intent: CGColorRenderingIntent)
    func __draw(in rect: CGRect, image image: CGImage)
    func __draw(in rect: CGRect, byTiling image: CGImage)
    var interpolationQuality: CGInterpolationQuality
    func setShadow(offset offset: CGSize, blur blur: CGFloat, color color: CGColor?)
    func setShadow(offset offset: CGSize, blur blur: CGFloat)
    func drawLinearGradient(_ gradient: CGGradient, start startPoint: CGPoint, end endPoint: CGPoint, options options: CGGradientDrawingOptions)
    func drawRadialGradient(_ gradient: CGGradient, startCenter startCenter: CGPoint, startRadius startRadius: CGFloat, endCenter endCenter: CGPoint, endRadius endRadius: CGFloat, options options: CGGradientDrawingOptions)
    func drawShading(_ shading: CGShading)
    func setCharacterSpacing(_ spacing: CGFloat)
    func __setTextPosition(x x: CGFloat, y y: CGFloat)
    var __textPosition: CGPoint { get }
    var textMatrix: CGAffineTransform
    func setTextDrawingMode(_ mode: CGTextDrawingMode)
    func setFont(_ font: CGFont)
    func setFontSize(_ size: CGFloat)
    func __showGlyphs(_ glyphs: UnsafePointer<CGGlyph>, atPositions Lpositions: UnsafePointer<CGPoint>, count count: Int)
    func drawPDFPage(_ page: CGPDFPage)
    func beginPage(mediaBox mediaBox: UnsafePointer<CGRect>?)
    func endPage()
    func flush()
    func synchronize()
    func setShouldAntialias(_ shouldAntialias: Bool)
    func setAllowsAntialiasing(_ allowsAntialiasing: Bool)
    func setShouldSmoothFonts(_ shouldSmoothFonts: Bool)
    func setAllowsFontSmoothing(_ allowsFontSmoothing: Bool)
    func setShouldSubpixelPositionFonts(_ shouldSubpixelPositionFonts: Bool)
    func setAllowsFontSubpixelPositioning(_ allowsFontSubpixelPositioning: Bool)
    func setShouldSubpixelQuantizeFonts(_ shouldSubpixelQuantizeFonts: Bool)
    func setAllowsFontSubpixelQuantization(_ allowsFontSubpixelQuantization: Bool)
    func beginTransparencyLayer(auxiliaryInfo auxiliaryInfo: CFDictionary?)
    func beginTransparencyLayer(in rect: CGRect, auxiliaryInfo auxInfo: CFDictionary?)
    func endTransparencyLayer()
    var userSpaceToDeviceSpaceTransform: CGAffineTransform { get }
    func convertToDeviceSpace(_ point: CGPoint) -> CGPoint
    func convertToUserSpace(_ point: CGPoint) -> CGPoint
    func convertToDeviceSpace(_ size: CGSize) -> CGSize
    func convertToUserSpace(_ size: CGSize) -> CGSize
    func convertToDeviceSpace(_ rect: CGRect) -> CGRect
    func convertToUserSpace(_ rect: CGRect) -> CGRect
    func selectFont(name name: UnsafePointer<Int8>, size size: CGFloat, textEncoding textEncoding: CGTextEncoding)
    func showText(string string: UnsafePointer<Int8>, length length: Int)
    func showTextAtPoint(x x: CGFloat, y y: CGFloat, string string: UnsafePointer<Int8>, length length: Int)
    func showGlyphs(g g: UnsafePointer<CGGlyph>?, count count: Int)
    func showGlyphsAtPoint(x x: CGFloat, y y: CGFloat, glyphs glyphs: UnsafePointer<CGGlyph>?, count count: Int)
    func showGlyphsWithAdvances(glyphs glyphs: UnsafePointer<CGGlyph>?, advances advances: UnsafePointer<CGSize>?, count count: Int)
    func drawPDFDocument(_ rect: CGRect, document document: CGPDFDocument, page page: Int32)
}
extension CGContext {
    func __draw(in rect: CGRect, layer layer: CGLayer)
    func __draw(at point: CGPoint, layer layer: CGLayer)
}
extension CGContext {
     init?(consumer consumer: CGDataConsumer, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)
     init?(_ url: CFURL, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)
    func closePDF()
    func beginPDFPage(_ pageInfo: CFDictionary?)
    func endPDFPage()
    func addDocumentMetadata(_ metadata: CFData?)
    func setURL(_ url: CFURL, for rect: CGRect)
    func addDestination(_ name: CFString, at point: CGPoint)
    func setDestination(_ name: CFString, for rect: CGRect)
}
extension CGContext {
    func draw(_ layer: CGLayer, in rect: CGRect)
    func draw(_ layer: CGLayer, at point: CGPoint)
}
extension CGContext {
    func setLineDash(phase phase: CGFloat, lengths lengths: [CGFloat])
    func move(to point: CGPoint)
    func addLine(to point: CGPoint)
    func addCurve(to end: CGPoint, control1 control1: CGPoint, control2 control2: CGPoint)
    func addQuadCurve(to end: CGPoint, control control: CGPoint)
    func addRects(_ rects: [CGRect])
    func addLines(between points: [CGPoint])
    func addArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool)
    func addArc(tangent1End tangent1End: CGPoint, tangent2End tangent2End: CGPoint, radius radius: CGFloat)
    func fillPath(using rule: CGPathFillRule = default)
    func clip(using rule: CGPathFillRule = default)
    func fill(_ rects: [CGRect])
    func strokeLineSegments(between points: [CGPoint])
    func clip(to rects: [CGRect])
    func draw(_ image: CGImage, in rect: CGRect, byTiling byTiling: Bool = default)
    var textPosition: CGPoint
    func showGlyphs(_ glyphs: [CGGlyph], at positions: [CGPoint])
}

NameDeclaration
FromCGPDFContextAddDestinationAtPoint(_:_:_:)
func CGPDFContextAddDestinationAtPoint(_ context: CGContext?, _ name: CFString, _ point: CGPoint)
ToaddDestination(_:at:)
func addDestination(_ name: CFString, at point: CGPoint)

NameDeclaration
FromCGPDFContextAddDocumentMetadata(_:_:)
func CGPDFContextAddDocumentMetadata(_ context: CGContext?, _ metadata: CFData?)
ToaddDocumentMetadata(_:)
func addDocumentMetadata(_ metadata: CFData?)

NameDeclaration
FromCGContextAddEllipseInRect(_:_:)
func CGContextAddEllipseInRect(_ c: CGContext?, _ rect: CGRect)
ToaddEllipse(in:)
func addEllipse(in rect: CGRect)

NameDeclaration
FromCGContextAddPath(_:_:)
func CGContextAddPath(_ c: CGContext?, _ path: CGPath?)
ToaddPath(_:)
func addPath(_ path: CGPath)

NameDeclaration
FromCGContextAddRect(_:_:)
func CGContextAddRect(_ c: CGContext?, _ rect: CGRect)
ToaddRect(_:)
func addRect(_ rect: CGRect)

NameDeclarationReadonly
FromCGBitmapContextGetAlphaInfo(_:)
func CGBitmapContextGetAlphaInfo(_ context: CGContext?) -> CGImageAlphaInfo
--
ToalphaInfo
var alphaInfo: CGImageAlphaInfo { get }
yes

NameDeclaration
FromCGContextBeginPage(_:_:)
func CGContextBeginPage(_ c: CGContext?, _ mediaBox: UnsafePointer<CGRect>)
TobeginPage(mediaBox:)
func beginPage(mediaBox mediaBox: UnsafePointer<CGRect>?)

NameDeclaration
FromCGContextBeginPath(_:)
func CGContextBeginPath(_ c: CGContext?)
TobeginPath()
func beginPath()

NameDeclaration
FromCGPDFContextBeginPage(_:_:)
func CGPDFContextBeginPage(_ context: CGContext?, _ pageInfo: CFDictionary?)
TobeginPDFPage(_:)
func beginPDFPage(_ pageInfo: CFDictionary?)

NameDeclaration
FromCGContextBeginTransparencyLayer(_:_:)
func CGContextBeginTransparencyLayer(_ c: CGContext?, _ auxiliaryInfo: CFDictionary?)
TobeginTransparencyLayer(auxiliaryInfo:)
func beginTransparencyLayer(auxiliaryInfo auxiliaryInfo: CFDictionary?)

NameDeclaration
FromCGContextBeginTransparencyLayerWithRect(_:_:_:)
func CGContextBeginTransparencyLayerWithRect(_ c: CGContext?, _ rect: CGRect, _ auxInfo: CFDictionary?)
TobeginTransparencyLayer(in:auxiliaryInfo:)
func beginTransparencyLayer(in rect: CGRect, auxiliaryInfo auxInfo: CFDictionary?)

NameDeclarationReadonly
FromCGBitmapContextGetBitmapInfo(_:)
func CGBitmapContextGetBitmapInfo(_ context: CGContext?) -> CGBitmapInfo
--
TobitmapInfo
var bitmapInfo: CGBitmapInfo { get }
yes

NameDeclarationReadonly
FromCGBitmapContextGetBitsPerComponent(_:)
func CGBitmapContextGetBitsPerComponent(_ context: CGContext?) -> Int
--
TobitsPerComponent
var bitsPerComponent: Int { get }
yes

NameDeclarationReadonly
FromCGBitmapContextGetBitsPerPixel(_:)
func CGBitmapContextGetBitsPerPixel(_ context: CGContext?) -> Int
--
TobitsPerPixel
var bitsPerPixel: Int { get }
yes

NameDeclarationReadonly
FromCGContextGetClipBoundingBox(_:)
func CGContextGetClipBoundingBox(_ c: CGContext?) -> CGRect
--
ToboundingBoxOfClipPath
var boundingBoxOfClipPath: CGRect { get }
yes

NameDeclarationReadonly
FromCGContextGetPathBoundingBox(_:)
func CGContextGetPathBoundingBox(_ c: CGContext?) -> CGRect
--
ToboundingBoxOfPath
var boundingBoxOfPath: CGRect { get }
yes

NameDeclarationReadonly
FromCGBitmapContextGetBytesPerRow(_:)
func CGBitmapContextGetBytesPerRow(_ context: CGContext?) -> Int
--
TobytesPerRow
var bytesPerRow: Int { get }
yes

NameDeclaration
FromCGContextClearRect(_:_:)
func CGContextClearRect(_ c: CGContext?, _ rect: CGRect)
Toclear(_:)
func clear(_ rect: CGRect)

NameDeclaration
FromCGContextClipToRect(_:_:)
func CGContextClipToRect(_ c: CGContext?, _ rect: CGRect)
Toclip(to:)
func clip(to rect: CGRect)

NameDeclaration
FromCGContextClipToMask(_:_:_:)
func CGContextClipToMask(_ c: CGContext?, _ rect: CGRect, _ mask: CGImage?)
Toclip(to:mask:)
func clip(to rect: CGRect, mask mask: CGImage)

NameDeclaration
FromCGContextClosePath(_:)
func CGContextClosePath(_ c: CGContext?)
ToclosePath()
func closePath()

NameDeclaration
FromCGPDFContextClose(_:)
func CGPDFContextClose(_ context: CGContext?)
ToclosePDF()
func closePDF()

NameDeclarationReadonly
FromCGBitmapContextGetColorSpace(_:)
func CGBitmapContextGetColorSpace(_ context: CGContext?) -> CGColorSpace?
--
TocolorSpace
var colorSpace: CGColorSpace? { get }
yes

NameDeclaration
FromCGContextConcatCTM(_:_:)
func CGContextConcatCTM(_ c: CGContext?, _ transform: CGAffineTransform)
Toconcatenate(_:)
func concatenate(_ transform: CGAffineTransform)

NameDeclaration
FromCGContextConvertPointToDeviceSpace(_:_:)
func CGContextConvertPointToDeviceSpace(_ c: CGContext?, _ point: CGPoint) -> CGPoint
ToconvertToDeviceSpace(_:)
func convertToDeviceSpace(_ point: CGPoint) -> CGPoint

NameDeclaration
FromCGContextConvertRectToDeviceSpace(_:_:)
func CGContextConvertRectToDeviceSpace(_ c: CGContext?, _ rect: CGRect) -> CGRect
ToconvertToDeviceSpace(_:)
func convertToDeviceSpace(_ rect: CGRect) -> CGRect

NameDeclaration
FromCGContextConvertSizeToDeviceSpace(_:_:)
func CGContextConvertSizeToDeviceSpace(_ c: CGContext?, _ size: CGSize) -> CGSize
ToconvertToDeviceSpace(_:)
func convertToDeviceSpace(_ size: CGSize) -> CGSize

NameDeclaration
FromCGContextConvertRectToUserSpace(_:_:)
func CGContextConvertRectToUserSpace(_ c: CGContext?, _ rect: CGRect) -> CGRect
ToconvertToUserSpace(_:)
func convertToUserSpace(_ rect: CGRect) -> CGRect

NameDeclaration
FromCGContextConvertSizeToUserSpace(_:_:)
func CGContextConvertSizeToUserSpace(_ c: CGContext?, _ size: CGSize) -> CGSize
ToconvertToUserSpace(_:)
func convertToUserSpace(_ size: CGSize) -> CGSize

NameDeclaration
FromCGContextConvertPointToUserSpace(_:_:)
func CGContextConvertPointToUserSpace(_ c: CGContext?, _ point: CGPoint) -> CGPoint
ToconvertToUserSpace(_:)
func convertToUserSpace(_ point: CGPoint) -> CGPoint

NameDeclarationReadonly
FromCGContextGetCTM(_:)
func CGContextGetCTM(_ c: CGContext?) -> CGAffineTransform
--
Toctm
var ctm: CGAffineTransform { get }
yes

NameDeclarationReadonly
FromCGContextGetPathCurrentPoint(_:)
func CGContextGetPathCurrentPoint(_ c: CGContext?) -> CGPoint
--
TocurrentPointOfPath
var currentPointOfPath: CGPoint { get }
yes

NameDeclarationReadonly
FromCGBitmapContextGetData(_:)
func CGBitmapContextGetData(_ context: CGContext?) -> UnsafeMutablePointer<Void>
--
Todata
var data: UnsafeMutableRawPointer? { get }
yes

NameDeclaration
FromCGContextDrawLinearGradient(_:_:_:_:_:)
func CGContextDrawLinearGradient(_ c: CGContext?, _ gradient: CGGradient?, _ startPoint: CGPoint, _ endPoint: CGPoint, _ options: CGGradientDrawingOptions)
TodrawLinearGradient(_:start:end:options:)
func drawLinearGradient(_ gradient: CGGradient, start startPoint: CGPoint, end endPoint: CGPoint, options options: CGGradientDrawingOptions)

NameDeclaration
FromCGContextDrawPath(_:_:)
func CGContextDrawPath(_ c: CGContext?, _ mode: CGPathDrawingMode)
TodrawPath(using:)
func drawPath(using mode: CGPathDrawingMode)

NameDeclaration
FromCGContextDrawPDFPage(_:_:)
func CGContextDrawPDFPage(_ c: CGContext?, _ page: CGPDFPage?)
TodrawPDFPage(_:)
func drawPDFPage(_ page: CGPDFPage)

NameDeclaration
FromCGContextDrawRadialGradient(_:_:_:_:_:_:_:)
func CGContextDrawRadialGradient(_ c: CGContext?, _ gradient: CGGradient?, _ startCenter: CGPoint, _ startRadius: CGFloat, _ endCenter: CGPoint, _ endRadius: CGFloat, _ options: CGGradientDrawingOptions)
TodrawRadialGradient(_:startCenter:startRadius:endCenter:endRadius:options:)
func drawRadialGradient(_ gradient: CGGradient, startCenter startCenter: CGPoint, startRadius startRadius: CGFloat, endCenter endCenter: CGPoint, endRadius endRadius: CGFloat, options options: CGGradientDrawingOptions)

NameDeclaration
FromCGContextDrawShading(_:_:)
func CGContextDrawShading(_ c: CGContext?, _ shading: CGShading?)
TodrawShading(_:)
func drawShading(_ shading: CGShading)

NameDeclaration
FromCGContextEndPage(_:)
func CGContextEndPage(_ c: CGContext?)
ToendPage()
func endPage()

NameDeclaration
FromCGPDFContextEndPage(_:)
func CGPDFContextEndPage(_ context: CGContext?)
ToendPDFPage()
func endPDFPage()

NameDeclaration
FromCGContextEndTransparencyLayer(_:)
func CGContextEndTransparencyLayer(_ c: CGContext?)
ToendTransparencyLayer()
func endTransparencyLayer()

NameDeclaration
FromCGContextFillRect(_:_:)
func CGContextFillRect(_ c: CGContext?, _ rect: CGRect)
Tofill(_:)
func fill(_ rect: CGRect)

NameDeclaration
FromCGContextFillEllipseInRect(_:_:)
func CGContextFillEllipseInRect(_ c: CGContext?, _ rect: CGRect)
TofillEllipse(in:)
func fillEllipse(in rect: CGRect)

NameDeclaration
FromCGContextFlush(_:)
func CGContextFlush(_ c: CGContext?)
Toflush()
func flush()

NameDeclarationReadonly
FromCGBitmapContextGetHeight(_:)
func CGBitmapContextGetHeight(_ context: CGContext?) -> Int
--
Toheight
var height: Int { get }
yes

NameDeclaration
FromCGPDFContextCreateWithURL(_:_:_:)
func CGPDFContextCreateWithURL(_ url: CFURL?, _ mediaBox: UnsafePointer<CGRect>, _ auxiliaryInfo: CFDictionary?) -> CGContext?
Toinit(_:mediaBox:_:)
init?(_ url: CFURL, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)

NameDeclaration
FromCGPDFContextCreate(_:_:_:)
func CGPDFContextCreate(_ consumer: CGDataConsumer?, _ mediaBox: UnsafePointer<CGRect>, _ auxiliaryInfo: CFDictionary?) -> CGContext?
Toinit(consumer:mediaBox:_:)
init?(consumer consumer: CGDataConsumer, mediaBox mediaBox: UnsafePointer<CGRect>?, _ auxiliaryInfo: CFDictionary?)

NameDeclaration
FromCGBitmapContextCreate(_:_:_:_:_:_:_:)
func CGBitmapContextCreate(_ data: UnsafeMutablePointer<Void>, _ width: Int, _ height: Int, _ bitsPerComponent: Int, _ bytesPerRow: Int, _ space: CGColorSpace?, _ bitmapInfo: UInt32) -> CGContext?
Toinit(data:width:height:bitsPerComponent:bytesPerRow:space:bitmapInfo:)
init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32)

NameDeclaration
FromCGBitmapContextCreateWithData(_:_:_:_:_:_:_:_:_:)
func CGBitmapContextCreateWithData(_ data: UnsafeMutablePointer<Void>, _ width: Int, _ height: Int, _ bitsPerComponent: Int, _ bytesPerRow: Int, _ space: CGColorSpace?, _ bitmapInfo: UInt32, _ releaseCallback: CGBitmapContextReleaseDataCallback?, _ releaseInfo: UnsafeMutablePointer<Void>) -> CGContext?
Toinit(data:width:height:bitsPerComponent:bytesPerRow:space:bitmapInfo:releaseCallback:releaseInfo:)
init?(data data: UnsafeMutableRawPointer?, width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: UInt32, releaseCallback releaseCallback: CoreGraphics.CGBitmapContextReleaseDataCallback?, releaseInfo releaseInfo: UnsafeMutableRawPointer?)

NameDeclaration
FromCGContextGetInterpolationQuality(_:)
func CGContextGetInterpolationQuality(_ c: CGContext?) -> CGInterpolationQuality
TointerpolationQuality
var interpolationQuality: CGInterpolationQuality

NameDeclarationReadonly
FromCGContextIsPathEmpty(_:)
func CGContextIsPathEmpty(_ c: CGContext?) -> Bool
--
ToisPathEmpty
var isPathEmpty: Bool { get }
yes

NameDeclaration
FromCGBitmapContextCreateImage(_:)
func CGBitmapContextCreateImage(_ context: CGContext?) -> CGImage?
TomakeImage()
func makeImage() -> CGImage?

NameDeclarationReadonly
FromCGContextCopyPath(_:)
func CGContextCopyPath(_ c: CGContext?) -> CGPath?
--
Topath
var path: CGPath? { get }
yes

NameDeclaration
FromCGContextPathContainsPoint(_:_:_:)
func CGContextPathContainsPoint(_ c: CGContext?, _ point: CGPoint, _ mode: CGPathDrawingMode) -> Bool
TopathContains(_:mode:)
func pathContains(_ point: CGPoint, mode mode: CGPathDrawingMode) -> Bool

NameDeclaration
FromCGContextReplacePathWithStrokedPath(_:)
func CGContextReplacePathWithStrokedPath(_ c: CGContext?)
ToreplacePathWithStrokedPath()
func replacePathWithStrokedPath()

NameDeclaration
FromCGContextRestoreGState(_:)
func CGContextRestoreGState(_ c: CGContext?)
TorestoreGState()
func restoreGState()

NameDeclaration
FromCGContextRotateCTM(_:_:)
func CGContextRotateCTM(_ c: CGContext?, _ angle: CGFloat)
Torotate(by:)
func rotate(by angle: CGFloat)

NameDeclaration
FromCGContextSaveGState(_:)
func CGContextSaveGState(_ c: CGContext?)
TosaveGState()
func saveGState()

NameDeclaration
FromCGContextScaleCTM(_:_:_:)
func CGContextScaleCTM(_ c: CGContext?, _ sx: CGFloat, _ sy: CGFloat)
ToscaleBy(x:y:)
func scaleBy(x sx: CGFloat, y sy: CGFloat)

NameDeclaration
FromCGContextSetAllowsAntialiasing(_:_:)
func CGContextSetAllowsAntialiasing(_ c: CGContext?, _ allowsAntialiasing: Bool)
TosetAllowsAntialiasing(_:)
func setAllowsAntialiasing(_ allowsAntialiasing: Bool)

NameDeclaration
FromCGContextSetAllowsFontSmoothing(_:_:)
func CGContextSetAllowsFontSmoothing(_ c: CGContext?, _ allowsFontSmoothing: Bool)
TosetAllowsFontSmoothing(_:)
func setAllowsFontSmoothing(_ allowsFontSmoothing: Bool)

NameDeclaration
FromCGContextSetAllowsFontSubpixelPositioning(_:_:)
func CGContextSetAllowsFontSubpixelPositioning(_ c: CGContext?, _ allowsFontSubpixelPositioning: Bool)
TosetAllowsFontSubpixelPositioning(_:)
func setAllowsFontSubpixelPositioning(_ allowsFontSubpixelPositioning: Bool)

NameDeclaration
FromCGContextSetAllowsFontSubpixelQuantization(_:_:)
func CGContextSetAllowsFontSubpixelQuantization(_ c: CGContext?, _ allowsFontSubpixelQuantization: Bool)
TosetAllowsFontSubpixelQuantization(_:)
func setAllowsFontSubpixelQuantization(_ allowsFontSubpixelQuantization: Bool)

NameDeclaration
FromCGContextSetAlpha(_:_:)
func CGContextSetAlpha(_ c: CGContext?, _ alpha: CGFloat)
TosetAlpha(_:)
func setAlpha(_ alpha: CGFloat)

NameDeclaration
FromCGContextSetBlendMode(_:_:)
func CGContextSetBlendMode(_ c: CGContext?, _ mode: CGBlendMode)
TosetBlendMode(_:)
func setBlendMode(_ mode: CGBlendMode)

NameDeclaration
FromCGContextSetCharacterSpacing(_:_:)
func CGContextSetCharacterSpacing(_ c: CGContext?, _ spacing: CGFloat)
TosetCharacterSpacing(_:)
func setCharacterSpacing(_ spacing: CGFloat)

NameDeclaration
FromCGPDFContextSetDestinationForRect(_:_:_:)
func CGPDFContextSetDestinationForRect(_ context: CGContext?, _ name: CFString, _ rect: CGRect)
TosetDestination(_:for:)
func setDestination(_ name: CFString, for rect: CGRect)

NameDeclaration
FromCGContextSetFillColor(_:_:)
func CGContextSetFillColor(_ c: CGContext?, _ components: UnsafePointer<CGFloat>)
TosetFillColor(_:)
func setFillColor(_ components: UnsafePointer<CGFloat>)

NameDeclaration
FromCGContextSetFillColorWithColor(_:_:)
func CGContextSetFillColorWithColor(_ c: CGContext?, _ color: CGColor?)
TosetFillColor(_:)
func setFillColor(_ color: CGColor)

NameDeclaration
FromCGContextSetCMYKFillColor(_:_:_:_:_:_:)
func CGContextSetCMYKFillColor(_ c: CGContext?, _ cyan: CGFloat, _ magenta: CGFloat, _ yellow: CGFloat, _ black: CGFloat, _ alpha: CGFloat)
TosetFillColor(cyan:magenta:yellow:black:alpha:)
func setFillColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetGrayFillColor(_:_:_:)
func CGContextSetGrayFillColor(_ c: CGContext?, _ gray: CGFloat, _ alpha: CGFloat)
TosetFillColor(gray:alpha:)
func setFillColor(gray gray: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetRGBFillColor(_:_:_:_:_:)
func CGContextSetRGBFillColor(_ c: CGContext?, _ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat)
TosetFillColor(red:green:blue:alpha:)
func setFillColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetFillColorSpace(_:_:)
func CGContextSetFillColorSpace(_ c: CGContext?, _ space: CGColorSpace?)
TosetFillColorSpace(_:)
func setFillColorSpace(_ space: CGColorSpace)

NameDeclaration
FromCGContextSetFillPattern(_:_:_:)
func CGContextSetFillPattern(_ c: CGContext?, _ pattern: CGPattern?, _ components: UnsafePointer<CGFloat>)
TosetFillPattern(_:colorComponents:)
func setFillPattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)

NameDeclaration
FromCGContextSetFlatness(_:_:)
func CGContextSetFlatness(_ c: CGContext?, _ flatness: CGFloat)
TosetFlatness(_:)
func setFlatness(_ flatness: CGFloat)

NameDeclaration
FromCGContextSetFont(_:_:)
func CGContextSetFont(_ c: CGContext?, _ font: CGFont?)
TosetFont(_:)
func setFont(_ font: CGFont)

NameDeclaration
FromCGContextSetFontSize(_:_:)
func CGContextSetFontSize(_ c: CGContext?, _ size: CGFloat)
TosetFontSize(_:)
func setFontSize(_ size: CGFloat)

NameDeclaration
FromCGContextSetLineCap(_:_:)
func CGContextSetLineCap(_ c: CGContext?, _ cap: CGLineCap)
TosetLineCap(_:)
func setLineCap(_ cap: CGLineCap)

NameDeclaration
FromCGContextSetLineJoin(_:_:)
func CGContextSetLineJoin(_ c: CGContext?, _ join: CGLineJoin)
TosetLineJoin(_:)
func setLineJoin(_ join: CGLineJoin)

NameDeclaration
FromCGContextSetLineWidth(_:_:)
func CGContextSetLineWidth(_ c: CGContext?, _ width: CGFloat)
TosetLineWidth(_:)
func setLineWidth(_ width: CGFloat)

NameDeclaration
FromCGContextSetMiterLimit(_:_:)
func CGContextSetMiterLimit(_ c: CGContext?, _ limit: CGFloat)
TosetMiterLimit(_:)
func setMiterLimit(_ limit: CGFloat)

NameDeclaration
FromCGContextSetPatternPhase(_:_:)
func CGContextSetPatternPhase(_ c: CGContext?, _ phase: CGSize)
TosetPatternPhase(_:)
func setPatternPhase(_ phase: CGSize)

NameDeclaration
FromCGContextSetRenderingIntent(_:_:)
func CGContextSetRenderingIntent(_ c: CGContext?, _ intent: CGColorRenderingIntent)
TosetRenderingIntent(_:)
func setRenderingIntent(_ intent: CGColorRenderingIntent)

NameDeclaration
FromCGContextSetShadow(_:_:_:)
func CGContextSetShadow(_ c: CGContext?, _ offset: CGSize, _ blur: CGFloat)
TosetShadow(offset:blur:)
func setShadow(offset offset: CGSize, blur blur: CGFloat)

NameDeclaration
FromCGContextSetShadowWithColor(_:_:_:_:)
func CGContextSetShadowWithColor(_ c: CGContext?, _ offset: CGSize, _ blur: CGFloat, _ color: CGColor?)
TosetShadow(offset:blur:color:)
func setShadow(offset offset: CGSize, blur blur: CGFloat, color color: CGColor?)

NameDeclaration
FromCGContextSetShouldAntialias(_:_:)
func CGContextSetShouldAntialias(_ c: CGContext?, _ shouldAntialias: Bool)
TosetShouldAntialias(_:)
func setShouldAntialias(_ shouldAntialias: Bool)

NameDeclaration
FromCGContextSetShouldSmoothFonts(_:_:)
func CGContextSetShouldSmoothFonts(_ c: CGContext?, _ shouldSmoothFonts: Bool)
TosetShouldSmoothFonts(_:)
func setShouldSmoothFonts(_ shouldSmoothFonts: Bool)

NameDeclaration
FromCGContextSetShouldSubpixelPositionFonts(_:_:)
func CGContextSetShouldSubpixelPositionFonts(_ c: CGContext?, _ shouldSubpixelPositionFonts: Bool)
TosetShouldSubpixelPositionFonts(_:)
func setShouldSubpixelPositionFonts(_ shouldSubpixelPositionFonts: Bool)

NameDeclaration
FromCGContextSetShouldSubpixelQuantizeFonts(_:_:)
func CGContextSetShouldSubpixelQuantizeFonts(_ c: CGContext?, _ shouldSubpixelQuantizeFonts: Bool)
TosetShouldSubpixelQuantizeFonts(_:)
func setShouldSubpixelQuantizeFonts(_ shouldSubpixelQuantizeFonts: Bool)

NameDeclaration
FromCGContextSetStrokeColorWithColor(_:_:)
func CGContextSetStrokeColorWithColor(_ c: CGContext?, _ color: CGColor?)
TosetStrokeColor(_:)
func setStrokeColor(_ color: CGColor)

NameDeclaration
FromCGContextSetStrokeColor(_:_:)
func CGContextSetStrokeColor(_ c: CGContext?, _ components: UnsafePointer<CGFloat>)
TosetStrokeColor(_:)
func setStrokeColor(_ components: UnsafePointer<CGFloat>)

NameDeclaration
FromCGContextSetCMYKStrokeColor(_:_:_:_:_:_:)
func CGContextSetCMYKStrokeColor(_ c: CGContext?, _ cyan: CGFloat, _ magenta: CGFloat, _ yellow: CGFloat, _ black: CGFloat, _ alpha: CGFloat)
TosetStrokeColor(cyan:magenta:yellow:black:alpha:)
func setStrokeColor(cyan cyan: CGFloat, magenta magenta: CGFloat, yellow yellow: CGFloat, black black: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetGrayStrokeColor(_:_:_:)
func CGContextSetGrayStrokeColor(_ c: CGContext?, _ gray: CGFloat, _ alpha: CGFloat)
TosetStrokeColor(gray:alpha:)
func setStrokeColor(gray gray: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetRGBStrokeColor(_:_:_:_:_:)
func CGContextSetRGBStrokeColor(_ c: CGContext?, _ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat)
TosetStrokeColor(red:green:blue:alpha:)
func setStrokeColor(red red: CGFloat, green green: CGFloat, blue blue: CGFloat, alpha alpha: CGFloat)

NameDeclaration
FromCGContextSetStrokeColorSpace(_:_:)
func CGContextSetStrokeColorSpace(_ c: CGContext?, _ space: CGColorSpace?)
TosetStrokeColorSpace(_:)
func setStrokeColorSpace(_ space: CGColorSpace)

NameDeclaration
FromCGContextSetStrokePattern(_:_:_:)
func CGContextSetStrokePattern(_ c: CGContext?, _ pattern: CGPattern?, _ components: UnsafePointer<CGFloat>)
TosetStrokePattern(_:colorComponents:)
func setStrokePattern(_ pattern: CGPattern, colorComponents components: UnsafePointer<CGFloat>)

NameDeclaration
FromCGContextSetTextDrawingMode(_:_:)
func CGContextSetTextDrawingMode(_ c: CGContext?, _ mode: CGTextDrawingMode)
TosetTextDrawingMode(_:)
func setTextDrawingMode(_ mode: CGTextDrawingMode)

NameDeclaration
FromCGPDFContextSetURLForRect(_:_:_:)
func CGPDFContextSetURLForRect(_ context: CGContext?, _ url: CFURL, _ rect: CGRect)
TosetURL(_:for:)
func setURL(_ url: CFURL, for rect: CGRect)

NameDeclaration
FromCGContextStrokeRect(_:_:)
func CGContextStrokeRect(_ c: CGContext?, _ rect: CGRect)
Tostroke(_:)
func stroke(_ rect: CGRect)

NameDeclaration
FromCGContextStrokeRectWithWidth(_:_:_:)
func CGContextStrokeRectWithWidth(_ c: CGContext?, _ rect: CGRect, _ width: CGFloat)
Tostroke(_:width:)
func stroke(_ rect: CGRect, width width: CGFloat)

NameDeclaration
FromCGContextStrokeEllipseInRect(_:_:)
func CGContextStrokeEllipseInRect(_ c: CGContext?, _ rect: CGRect)
TostrokeEllipse(in:)
func strokeEllipse(in rect: CGRect)

NameDeclaration
FromCGContextStrokePath(_:)
func CGContextStrokePath(_ c: CGContext?)
TostrokePath()
func strokePath()

NameDeclaration
FromCGContextSynchronize(_:)
func CGContextSynchronize(_ c: CGContext?)
Tosynchronize()
func synchronize()

NameDeclaration
FromCGContextGetTextMatrix(_:)
func CGContextGetTextMatrix(_ c: CGContext?) -> CGAffineTransform
TotextMatrix
var textMatrix: CGAffineTransform

NameDeclaration
FromCGContextTranslateCTM(_:_:_:)
func CGContextTranslateCTM(_ c: CGContext?, _ tx: CGFloat, _ ty: CGFloat)
TotranslateBy(x:y:)
func translateBy(x tx: CGFloat, y ty: CGFloat)

NameDeclaration
FromCGContextGetTypeID()
func CGContextGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

NameDeclarationReadonly
FromCGContextGetUserSpaceToDeviceSpaceTransform(_:)
func CGContextGetUserSpaceToDeviceSpaceTransform(_ c: CGContext?) -> CGAffineTransform
--
TouserSpaceToDeviceSpaceTransform
var userSpaceToDeviceSpaceTransform: CGAffineTransform { get }
yes

NameDeclarationReadonly
FromCGBitmapContextGetWidth(_:)
func CGBitmapContextGetWidth(_ context: CGContext?) -> Int
--
Towidth
var width: Int { get }
yes

Declaration
From
class CGDataConsumer {
}
To
class CGDataConsumer {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, cbks cbks: UnsafePointer<CGDataConsumerCallbacks>)
    init?(url url: CFURL)
    init?(data data: CFMutableData)
}
extension CGDataConsumer {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, cbks cbks: UnsafePointer<CGDataConsumerCallbacks>)
    init?(url url: CFURL)
    init?(data data: CFMutableData)
}

NameDeclaration
FromCGDataConsumerCreateWithCFData(_:)
func CGDataConsumerCreateWithCFData(_ data: CFMutableData?) -> CGDataConsumer?
Toinit(data:)
init?(data data: CFMutableData)

NameDeclaration
FromCGDataConsumerCreate(_:_:)
func CGDataConsumerCreate(_ info: UnsafeMutablePointer<Void>, _ cbks: UnsafePointer<CGDataConsumerCallbacks>) -> CGDataConsumer?
Toinit(info:cbks:)
init?(info info: UnsafeMutableRawPointer?, cbks cbks: UnsafePointer<CGDataConsumerCallbacks>)

NameDeclaration
FromCGDataConsumerCreateWithURL(_:)
func CGDataConsumerCreateWithURL(_ url: CFURL?) -> CGDataConsumer?
Toinit(url:)
init?(url url: CFURL)

NameDeclaration
FromCGDataConsumerGetTypeID()
func CGDataConsumerGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
struct CGDataConsumerCallbacks {
    var putBytes: CGDataConsumerPutBytesCallback?
    var releaseConsumer: CGDataConsumerReleaseInfoCallback?
    init()
    init(putBytes putBytes: CGDataConsumerPutBytesCallback?, releaseConsumer releaseConsumer: CGDataConsumerReleaseInfoCallback?)
}
To
struct CGDataConsumerCallbacks {
    var putBytes: CoreGraphics.CGDataConsumerPutBytesCallback?
    var releaseConsumer: CoreGraphics.CGDataConsumerReleaseInfoCallback?
    init()
    init(putBytes putBytes: CoreGraphics.CGDataConsumerPutBytesCallback?, releaseConsumer releaseConsumer: CoreGraphics.CGDataConsumerReleaseInfoCallback?)
}

Declaration
From
var putBytes: CGDataConsumerPutBytesCallback?
To
var putBytes: CoreGraphics.CGDataConsumerPutBytesCallback?

Declaration
From
var releaseConsumer: CGDataConsumerReleaseInfoCallback?
To
var releaseConsumer: CoreGraphics.CGDataConsumerReleaseInfoCallback?

Declaration
From
class CGDataProvider {
}
To
class CGDataProvider {
    class var typeID: CFTypeID { get }
    init?(sequentialInfo info: UnsafeMutableRawPointer?, callbacks callbacks: UnsafePointer<CGDataProviderSequentialCallbacks>)
    init?(directInfo info: UnsafeMutableRawPointer?, size size: off_t, callbacks callbacks: UnsafePointer<CGDataProviderDirectCallbacks>)
    init?(dataInfo info: UnsafeMutableRawPointer?, data data: UnsafeRawPointer, size size: Int, releaseData releaseData: CoreGraphics.CGDataProviderReleaseDataCallback)
    init?(data data: CFData)
    init?(url url: CFURL)
    init?(filename filename: UnsafePointer<Int8>)
    var data: CFData? { get }
}
extension CGDataProvider {
    class var typeID: CFTypeID { get }
    init?(sequentialInfo info: UnsafeMutableRawPointer?, callbacks callbacks: UnsafePointer<CGDataProviderSequentialCallbacks>)
    init?(directInfo info: UnsafeMutableRawPointer?, size size: off_t, callbacks callbacks: UnsafePointer<CGDataProviderDirectCallbacks>)
    init?(dataInfo info: UnsafeMutableRawPointer?, data data: UnsafeRawPointer, size size: Int, releaseData releaseData: CoreGraphics.CGDataProviderReleaseDataCallback)
    init?(data data: CFData)
    init?(url url: CFURL)
    init?(filename filename: UnsafePointer<Int8>)
    var data: CFData? { get }
}

NameDeclarationReadonly
FromCGDataProviderCopyData(_:)
func CGDataProviderCopyData(_ provider: CGDataProvider?) -> CFData?
--
Todata
var data: CFData? { get }
yes

NameDeclaration
FromCGDataProviderCreateWithCFData(_:)
func CGDataProviderCreateWithCFData(_ data: CFData?) -> CGDataProvider?
Toinit(data:)
init?(data data: CFData)

NameDeclaration
FromCGDataProviderCreateWithData(_:_:_:_:)
func CGDataProviderCreateWithData(_ info: UnsafeMutablePointer<Void>, _ data: UnsafePointer<Void>, _ size: Int, _ releaseData: CGDataProviderReleaseDataCallback?) -> CGDataProvider?
Toinit(dataInfo:data:size:releaseData:)
init?(dataInfo info: UnsafeMutableRawPointer?, data data: UnsafeRawPointer, size size: Int, releaseData releaseData: CoreGraphics.CGDataProviderReleaseDataCallback)

NameDeclaration
FromCGDataProviderCreateDirect(_:_:_:)
func CGDataProviderCreateDirect(_ info: UnsafeMutablePointer<Void>, _ size: off_t, _ callbacks: UnsafePointer<CGDataProviderDirectCallbacks>) -> CGDataProvider?
Toinit(directInfo:size:callbacks:)
init?(directInfo info: UnsafeMutableRawPointer?, size size: off_t, callbacks callbacks: UnsafePointer<CGDataProviderDirectCallbacks>)

NameDeclaration
FromCGDataProviderCreateWithFilename(_:)
func CGDataProviderCreateWithFilename(_ filename: UnsafePointer<Int8>) -> CGDataProvider?
Toinit(filename:)
init?(filename filename: UnsafePointer<Int8>)

NameDeclaration
FromCGDataProviderCreateSequential(_:_:)
func CGDataProviderCreateSequential(_ info: UnsafeMutablePointer<Void>, _ callbacks: UnsafePointer<CGDataProviderSequentialCallbacks>) -> CGDataProvider?
Toinit(sequentialInfo:callbacks:)
init?(sequentialInfo info: UnsafeMutableRawPointer?, callbacks callbacks: UnsafePointer<CGDataProviderSequentialCallbacks>)

NameDeclaration
FromCGDataProviderCreateWithURL(_:)
func CGDataProviderCreateWithURL(_ url: CFURL?) -> CGDataProvider?
Toinit(url:)
init?(url url: CFURL)

NameDeclaration
FromCGDataProviderGetTypeID()
func CGDataProviderGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
struct CGDataProviderDirectCallbacks {
    var version: UInt32
    var getBytePointer: CGDataProviderGetBytePointerCallback?
    var releaseBytePointer: CGDataProviderReleaseBytePointerCallback?
    var getBytesAtPosition: CGDataProviderGetBytesAtPositionCallback?
    var releaseInfo: CGDataProviderReleaseInfoCallback?
    init()
    init(version version: UInt32, getBytePointer getBytePointer: CGDataProviderGetBytePointerCallback?, releaseBytePointer releaseBytePointer: CGDataProviderReleaseBytePointerCallback?, getBytesAtPosition getBytesAtPosition: CGDataProviderGetBytesAtPositionCallback?, releaseInfo releaseInfo: CGDataProviderReleaseInfoCallback?)
}
To
struct CGDataProviderDirectCallbacks {
    var version: UInt32
    var getBytePointer: CoreGraphics.CGDataProviderGetBytePointerCallback?
    var releaseBytePointer: CoreGraphics.CGDataProviderReleaseBytePointerCallback?
    var getBytesAtPosition: CoreGraphics.CGDataProviderGetBytesAtPositionCallback?
    var releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?
    init()
    init(version version: UInt32, getBytePointer getBytePointer: CoreGraphics.CGDataProviderGetBytePointerCallback?, releaseBytePointer releaseBytePointer: CoreGraphics.CGDataProviderReleaseBytePointerCallback?, getBytesAtPosition getBytesAtPosition: CoreGraphics.CGDataProviderGetBytesAtPositionCallback?, releaseInfo releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?)
}

Declaration
From
var getBytePointer: CGDataProviderGetBytePointerCallback?
To
var getBytePointer: CoreGraphics.CGDataProviderGetBytePointerCallback?

Declaration
From
var getBytesAtPosition: CGDataProviderGetBytesAtPositionCallback?
To
var getBytesAtPosition: CoreGraphics.CGDataProviderGetBytesAtPositionCallback?

Declaration
From
var releaseBytePointer: CGDataProviderReleaseBytePointerCallback?
To
var releaseBytePointer: CoreGraphics.CGDataProviderReleaseBytePointerCallback?

Declaration
From
var releaseInfo: CGDataProviderReleaseInfoCallback?
To
var releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?

Declaration
From
struct CGDataProviderSequentialCallbacks {
    var version: UInt32
    var getBytes: CGDataProviderGetBytesCallback?
    var skipForward: CGDataProviderSkipForwardCallback?
    var rewind: CGDataProviderRewindCallback?
    var releaseInfo: CGDataProviderReleaseInfoCallback?
    init()
    init(version version: UInt32, getBytes getBytes: CGDataProviderGetBytesCallback?, skipForward skipForward: CGDataProviderSkipForwardCallback?, rewind rewind: CGDataProviderRewindCallback?, releaseInfo releaseInfo: CGDataProviderReleaseInfoCallback?)
}
To
struct CGDataProviderSequentialCallbacks {
    var version: UInt32
    var getBytes: CoreGraphics.CGDataProviderGetBytesCallback?
    var skipForward: CoreGraphics.CGDataProviderSkipForwardCallback?
    var rewind: CoreGraphics.CGDataProviderRewindCallback?
    var releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?
    init()
    init(version version: UInt32, getBytes getBytes: CoreGraphics.CGDataProviderGetBytesCallback?, skipForward skipForward: CoreGraphics.CGDataProviderSkipForwardCallback?, rewind rewind: CoreGraphics.CGDataProviderRewindCallback?, releaseInfo releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?)
}

Declaration
From
var getBytes: CGDataProviderGetBytesCallback?
To
var getBytes: CoreGraphics.CGDataProviderGetBytesCallback?

Declaration
From
var releaseInfo: CGDataProviderReleaseInfoCallback?
To
var releaseInfo: CoreGraphics.CGDataProviderReleaseInfoCallback?

Declaration
From
var rewind: CGDataProviderRewindCallback?
To
var rewind: CoreGraphics.CGDataProviderRewindCallback?

Declaration
From
var skipForward: CGDataProviderSkipForwardCallback?
To
var skipForward: CoreGraphics.CGDataProviderSkipForwardCallback?

Declaration
From
enum CGError : Int32 {
    case Success
    case Failure
    case IllegalArgument
    case InvalidConnection
    case InvalidContext
    case CannotComplete
    case NotImplemented
    case RangeCheck
    case TypeCheck
    case InvalidOperation
    case NoneAvailable
}
To
enum CGError : Int32 {
    case success
    case failure
    case illegalArgument
    case invalidConnection
    case invalidContext
    case cannotComplete
    case notImplemented
    case rangeCheck
    case typeCheck
    case invalidOperation
    case noneAvailable
}

Declaration
From
case CannotComplete
To
case cannotComplete

Declaration
From
case Failure
To
case failure

Declaration
From
case IllegalArgument
To
case illegalArgument

Declaration
From
case InvalidConnection
To
case invalidConnection

Declaration
From
case InvalidContext
To
case invalidContext

Declaration
From
case InvalidOperation
To
case invalidOperation

Declaration
From
case NoneAvailable
To
case noneAvailable

Declaration
From
case NotImplemented
To
case notImplemented

Declaration
From
case RangeCheck
To
case rangeCheck

Declaration
From
case Success
To
case success

Declaration
From
case TypeCheck
To
case typeCheck

DeclarationProtocols
From
struct CGFloat {
    typealias NativeType = Float
    init()
    init(_ value: Float)
    init(_ value: Double)
    var native: NativeType
}
extension CGFloat : FloatingPointType {
    init(_ value: UInt8)
    init(_ value: Int8)
    init(_ value: UInt16)
    init(_ value: Int16)
    init(_ value: UInt32)
    init(_ value: Int32)
    init(_ value: UInt64)
    init(_ value: Int64)
    init(_ value: UInt)
    init(_ value: Int)
    static var infinity: CGFloat { get }
    static var NaN: CGFloat { get }
    static var quietNaN: CGFloat { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
    var floatingPointClass: FloatingPointClassification { get }
}
extension CGFloat {
    static var min: CGFloat { get }
    static var max: CGFloat { get }
}
extension CGFloat : _Reflectable {
}
extension CGFloat : CustomStringConvertible {
    var description: String { get }
}
extension CGFloat : Hashable {
    var hashValue: Int { get }
}
extension CGFloat : FloatLiteralConvertible {
    init(floatLiteral value: NativeType)
}
extension CGFloat : IntegerLiteralConvertible {
    init(integerLiteral value: Int)
}
extension CGFloat : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: CGFloat) -> CGFloat
}
extension CGFloat : Equatable {
}
extension CGFloat : Comparable {
}
extension CGFloat : Strideable {
    func distanceTo(_ other: CGFloat) -> CGFloat
    func advancedBy(_ amount: CGFloat) -> CGFloat
}
extension CGFloat : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}
extension CGFloat : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
AbsoluteValuable, Comparable, CustomStringConvertible, Equatable, FloatLiteralConvertible, FloatingPointType, Hashable, IntegerLiteralConvertible, Strideable
To
struct CGFloat {
    typealias NativeType = Double
    init()
    init(_ value: Float)
    init(_ value: Double)
    init(_ value: CGFloat)
    init(_ value: UInt8)
    init(_ value: Int8)
    init(_ value: UInt16)
    init(_ value: Int16)
    init(_ value: UInt32)
    init(_ value: Int32)
    init(_ value: UInt64)
    init(_ value: Int64)
    init(_ value: UInt)
    init(_ value: Int)
    var native: CGFloat.NativeType
    static var min: CGFloat { get }
    static var max: CGFloat { get }
}
extension CGFloat : BinaryFloatingPoint {
    typealias RawSignificand = UInt
    typealias Exponent = Int
    static var exponentBitCount: Int { get }
    static var significandBitCount: Int { get }
    var bitPattern: UInt { get }
    init(bitPattern bitPattern: UInt)
    var sign: FloatingPointSign { get }
    var exponentBitPattern: UInt { get }
    var significandBitPattern: UInt { get }
    init(sign sign: FloatingPointSign, exponentBitPattern exponentBitPattern: UInt, significandBitPattern significandBitPattern: UInt)
    init(nan payload: CGFloat.RawSignificand, signaling signaling: Bool)
    static var infinity: CGFloat { get }
    static var nan: CGFloat { get }
    static var signalingNaN: CGFloat { get }
    static var quietNaN: CGFloat { get }
    static var greatestFiniteMagnitude: CGFloat { get }
    static var pi: CGFloat { get }
    var ulp: CGFloat { get }
    static var leastNormalMagnitude: CGFloat { get }
    static var leastNonzeroMagnitude: CGFloat { get }
    var exponent: Int { get }
    var significand: CGFloat { get }
    init(sign sign: FloatingPointSign, exponent exponent: Int, significand significand: CGFloat)
    mutating func round(_ rule: FloatingPointRoundingRule)
    var nextUp: CGFloat { get }
    static func abs(_ x: CGFloat) -> CGFloat
    mutating func negate()
    mutating func add(_ other: CGFloat)
    mutating func subtract(_ other: CGFloat)
    mutating func multiply(by other: CGFloat)
    mutating func divide(by other: CGFloat)
    mutating func formTruncatingRemainder(dividingBy other: CGFloat)
    mutating func formRemainder(dividingBy other: CGFloat)
    mutating func formSquareRoot()
    mutating func addProduct(_ lhs: CGFloat, _ rhs: CGFloat)
    func isEqual(to other: CGFloat) -> Bool
    func isLess(than other: CGFloat) -> Bool
    func isLessThanOrEqualTo(_ other: CGFloat) -> Bool
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignalingNaN: Bool { get }
    var isSignaling: Bool { get }
    var isCanonical: Bool { get }
    var floatingPointClass: FloatingPointClassification { get }
    var binade: CGFloat { get }
    var significandWidth: Int { get }
    init(floatLiteral value: CGFloat.NativeType)
    init(integerLiteral value: Int)
}
extension CGFloat : CustomReflectable {
    var customMirror: Mirror { get }
}
extension CGFloat : CustomStringConvertible {
    var description: String { get }
}
extension CGFloat : Hashable {
    var hashValue: Int { get }
}
extension CGFloat : Strideable {
    func distance(to other: CGFloat) -> CGFloat
    func advanced(by amount: CGFloat) -> CGFloat
}
extension CGFloat {
    init(_ number: NSNumber)
}
BinaryFloatingPoint, CustomReflectable, CustomStringConvertible, Hashable, Strideable

Modified CGFloat.abs(_: CGFloat) -> CGFloat [static]
Declaration
From
@warn_unused_result
    static func abs(_ x: CGFloat) -> CGFloat
To
static func abs(_ x: CGFloat) -> CGFloat

DeclarationIntroduction
From
init(floatLiteral value: NativeType)
iOS 8.1
To
init(floatLiteral value: CGFloat.NativeType)
iOS 9.3

Declaration
From
var native: NativeType
To
var native: CGFloat.NativeType

Modified CGFont
Declaration
From
class CGFont {
}
To
class CGFont {
    class var typeID: CFTypeID { get }
    init?(platformFontPlatformFontReference platformFontReference: UnsafeMutableRawPointer)
     init(_ provider: CGDataProvider)
     init?(_ name: CFString)
    func copy(withVariations variations: CFDictionary?) -> CGFont?
    var numberOfGlyphs: Int { get }
    var unitsPerEm: Int32 { get }
    var postScriptName: CFString? { get }
    var fullName: CFString? { get }
    var ascent: Int32 { get }
    var descent: Int32 { get }
    var leading: Int32 { get }
    var capHeight: Int32 { get }
    var xHeight: Int32 { get }
    var fontBBox: CGRect { get }
    var italicAngle: CGFloat { get }
    var stemV: CGFloat { get }
    var variationAxes: CFArray? { get }
    var variations: CFDictionary? { get }
    func getGlyphAdvances(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, advances advances: UnsafeMutablePointer<Int32>) -> Bool
    func getGlyphBBoxes(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, bboxes bboxes: UnsafeMutablePointer<CGRect>) -> Bool
    func getGlyphWithGlyphName(name name: CFString) -> CGGlyph
    func name(for glyph: CGGlyph) -> CFString?
    func canCreatePostScriptSubset(_ format: CGFontPostScriptFormat) -> Bool
    func createPostScriptSubset(subsetName subsetName: CFString, format format: CGFontPostScriptFormat, glyphs glyphs: UnsafePointer<CGGlyph>?, count count: Int, encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?
    func createPostScriptEncoding(encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?
    var tableTags: CFArray? { get }
    func table(for tag: UInt32) -> CFData?
    class let variationAxisName: CFString
    class let variationAxisMinValue: CFString
    class let variationAxisMaxValue: CFString
    class let variationAxisDefaultValue: CFString
}
extension CGFont {
    class var typeID: CFTypeID { get }
    init?(platformFontPlatformFontReference platformFontReference: UnsafeMutableRawPointer)
     init(_ provider: CGDataProvider)
     init?(_ name: CFString)
    func copy(withVariations variations: CFDictionary?) -> CGFont?
    var numberOfGlyphs: Int { get }
    var unitsPerEm: Int32 { get }
    var postScriptName: CFString? { get }
    var fullName: CFString? { get }
    var ascent: Int32 { get }
    var descent: Int32 { get }
    var leading: Int32 { get }
    var capHeight: Int32 { get }
    var xHeight: Int32 { get }
    var fontBBox: CGRect { get }
    var italicAngle: CGFloat { get }
    var stemV: CGFloat { get }
    var variationAxes: CFArray? { get }
    var variations: CFDictionary? { get }
    func getGlyphAdvances(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, advances advances: UnsafeMutablePointer<Int32>) -> Bool
    func getGlyphBBoxes(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, bboxes bboxes: UnsafeMutablePointer<CGRect>) -> Bool
    func getGlyphWithGlyphName(name name: CFString) -> CGGlyph
    func name(for glyph: CGGlyph) -> CFString?
    func canCreatePostScriptSubset(_ format: CGFontPostScriptFormat) -> Bool
    func createPostScriptSubset(subsetName subsetName: CFString, format format: CGFontPostScriptFormat, glyphs glyphs: UnsafePointer<CGGlyph>?, count count: Int, encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?
    func createPostScriptEncoding(encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?
    var tableTags: CFArray? { get }
    func table(for tag: UInt32) -> CFData?
    class let variationAxisName: CFString
    class let variationAxisMinValue: CFString
    class let variationAxisMaxValue: CFString
    class let variationAxisDefaultValue: CFString
}

NameDeclarationReadonly
FromCGFontGetAscent(_:)
func CGFontGetAscent(_ font: CGFont?) -> Int32
--
Toascent
var ascent: Int32 { get }
yes

NameDeclaration
FromCGFontCanCreatePostScriptSubset(_:_:)
func CGFontCanCreatePostScriptSubset(_ font: CGFont?, _ format: CGFontPostScriptFormat) -> Bool
TocanCreatePostScriptSubset(_:)
func canCreatePostScriptSubset(_ format: CGFontPostScriptFormat) -> Bool

NameDeclarationReadonly
FromCGFontGetCapHeight(_:)
func CGFontGetCapHeight(_ font: CGFont?) -> Int32
--
TocapHeight
var capHeight: Int32 { get }
yes

NameDeclaration
FromCGFontCreateCopyWithVariations(_:_:)
func CGFontCreateCopyWithVariations(_ font: CGFont?, _ variations: CFDictionary?) -> CGFont?
Tocopy(withVariations:)
func copy(withVariations variations: CFDictionary?) -> CGFont?

NameDeclaration
FromCGFontCreatePostScriptEncoding(_:_:)
func CGFontCreatePostScriptEncoding(_ font: CGFont?, _ encoding: UnsafePointer<CGGlyph>) -> CFData?
TocreatePostScriptEncoding(encoding:)
func createPostScriptEncoding(encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?

NameDeclaration
FromCGFontCreatePostScriptSubset(_:_:_:_:_:_:)
func CGFontCreatePostScriptSubset(_ font: CGFont?, _ subsetName: CFString?, _ format: CGFontPostScriptFormat, _ glyphs: UnsafePointer<CGGlyph>, _ count: Int, _ encoding: UnsafePointer<CGGlyph>) -> CFData?
TocreatePostScriptSubset(subsetName:format:glyphs:count:encoding:)
func createPostScriptSubset(subsetName subsetName: CFString, format format: CGFontPostScriptFormat, glyphs glyphs: UnsafePointer<CGGlyph>?, count count: Int, encoding encoding: UnsafePointer<CGGlyph>!) -> CFData?

NameDeclarationReadonly
FromCGFontGetDescent(_:)
func CGFontGetDescent(_ font: CGFont?) -> Int32
--
Todescent
var descent: Int32 { get }
yes

NameDeclarationReadonly
FromCGFontGetFontBBox(_:)
func CGFontGetFontBBox(_ font: CGFont?) -> CGRect
--
TofontBBox
var fontBBox: CGRect { get }
yes

NameDeclarationReadonly
FromCGFontCopyFullName(_:)
func CGFontCopyFullName(_ font: CGFont?) -> CFString?
--
TofullName
var fullName: CFString? { get }
yes

NameDeclaration
FromCGFontGetGlyphAdvances(_:_:_:_:)
func CGFontGetGlyphAdvances(_ font: CGFont?, _ glyphs: UnsafePointer<CGGlyph>, _ count: Int, _ advances: UnsafeMutablePointer<Int32>) -> Bool
TogetGlyphAdvances(glyphs:count:advances:)
func getGlyphAdvances(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, advances advances: UnsafeMutablePointer<Int32>) -> Bool

NameDeclaration
FromCGFontGetGlyphBBoxes(_:_:_:_:)
func CGFontGetGlyphBBoxes(_ font: CGFont?, _ glyphs: UnsafePointer<CGGlyph>, _ count: Int, _ bboxes: UnsafeMutablePointer<CGRect>) -> Bool
TogetGlyphBBoxes(glyphs:count:bboxes:)
func getGlyphBBoxes(glyphs glyphs: UnsafePointer<CGGlyph>, count count: Int, bboxes bboxes: UnsafeMutablePointer<CGRect>) -> Bool

NameDeclaration
FromCGFontGetGlyphWithGlyphName(_:_:)
func CGFontGetGlyphWithGlyphName(_ font: CGFont?, _ name: CFString?) -> CGGlyph
TogetGlyphWithGlyphName(name:)
func getGlyphWithGlyphName(name name: CFString) -> CGGlyph

NameDeclaration
FromCGFontCreateWithDataProvider(_:)
func CGFontCreateWithDataProvider(_ provider: CGDataProvider?) -> CGFont?
Toinit(_:)
init(_ provider: CGDataProvider)

NameDeclaration
FromCGFontCreateWithFontName(_:)
func CGFontCreateWithFontName(_ name: CFString?) -> CGFont?
Toinit(_:)
init?(_ name: CFString)

NameDeclarationReadonly
FromCGFontGetItalicAngle(_:)
func CGFontGetItalicAngle(_ font: CGFont?) -> CGFloat
--
ToitalicAngle
var italicAngle: CGFloat { get }
yes

NameDeclarationReadonly
FromCGFontGetLeading(_:)
func CGFontGetLeading(_ font: CGFont?) -> Int32
--
Toleading
var leading: Int32 { get }
yes

NameDeclaration
FromCGFontCopyGlyphNameForGlyph(_:_:)
func CGFontCopyGlyphNameForGlyph(_ font: CGFont?, _ glyph: CGGlyph) -> CFString?
Toname(for:)
func name(for glyph: CGGlyph) -> CFString?

NameDeclarationReadonly
FromCGFontGetNumberOfGlyphs(_:)
func CGFontGetNumberOfGlyphs(_ font: CGFont?) -> Int
--
TonumberOfGlyphs
var numberOfGlyphs: Int { get }
yes

NameDeclarationReadonly
FromCGFontCopyPostScriptName(_:)
func CGFontCopyPostScriptName(_ font: CGFont?) -> CFString?
--
TopostScriptName
var postScriptName: CFString? { get }
yes

NameDeclarationReadonly
FromCGFontGetStemV(_:)
func CGFontGetStemV(_ font: CGFont?) -> CGFloat
--
TostemV
var stemV: CGFloat { get }
yes

NameDeclaration
FromCGFontCopyTableForTag(_:_:)
func CGFontCopyTableForTag(_ font: CGFont?, _ tag: UInt32) -> CFData?
Totable(for:)
func table(for tag: UInt32) -> CFData?

NameDeclarationReadonly
FromCGFontCopyTableTags(_:)
func CGFontCopyTableTags(_ font: CGFont?) -> CFArray?
--
TotableTags
var tableTags: CFArray? { get }
yes

NameDeclaration
FromCGFontGetTypeID()
func CGFontGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

NameDeclarationReadonly
FromCGFontGetUnitsPerEm(_:)
func CGFontGetUnitsPerEm(_ font: CGFont?) -> Int32
--
TounitsPerEm
var unitsPerEm: Int32 { get }
yes

NameDeclarationReadonly
FromCGFontCopyVariationAxes(_:)
func CGFontCopyVariationAxes(_ font: CGFont?) -> CFArray?
--
TovariationAxes
var variationAxes: CFArray? { get }
yes

NameDeclaration
FromkCGFontVariationAxisDefaultValue
let kCGFontVariationAxisDefaultValue: CFString
TovariationAxisDefaultValue
class let variationAxisDefaultValue: CFString

NameDeclaration
FromkCGFontVariationAxisMaxValue
let kCGFontVariationAxisMaxValue: CFString
TovariationAxisMaxValue
class let variationAxisMaxValue: CFString

NameDeclaration
FromkCGFontVariationAxisMinValue
let kCGFontVariationAxisMinValue: CFString
TovariationAxisMinValue
class let variationAxisMinValue: CFString

NameDeclaration
FromkCGFontVariationAxisName
let kCGFontVariationAxisName: CFString
TovariationAxisName
class let variationAxisName: CFString

NameDeclarationReadonly
FromCGFontCopyVariations(_:)
func CGFontCopyVariations(_ font: CGFont?) -> CFDictionary?
--
Tovariations
var variations: CFDictionary? { get }
yes

NameDeclarationReadonly
FromCGFontGetXHeight(_:)
func CGFontGetXHeight(_ font: CGFont?) -> Int32
--
ToxHeight
var xHeight: Int32 { get }
yes

Declaration
From
enum CGFontPostScriptFormat : Int32 {
    case Type1
    case Type3
    case Type42
}
To
enum CGFontPostScriptFormat : Int32 {
    case type1
    case type3
    case type42
}

Declaration
From
case Type1
To
case type1

Declaration
From
case Type3
To
case type3

Declaration
From
case Type42
To
case type42

Modified CGFunction
Declaration
From
class CGFunction {
}
To
class CGFunction {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, domainDimension domainDimension: Int, domain domain: UnsafePointer<CGFloat>?, rangeDimension rangeDimension: Int, range range: UnsafePointer<CGFloat>?, callbacks callbacks: UnsafePointer<CGFunctionCallbacks>)
}
extension CGFunction {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, domainDimension domainDimension: Int, domain domain: UnsafePointer<CGFloat>?, rangeDimension rangeDimension: Int, range range: UnsafePointer<CGFloat>?, callbacks callbacks: UnsafePointer<CGFunctionCallbacks>)
}

NameDeclaration
FromCGFunctionCreate(_:_:_:_:_:_:)
func CGFunctionCreate(_ info: UnsafeMutablePointer<Void>, _ domainDimension: Int, _ domain: UnsafePointer<CGFloat>, _ rangeDimension: Int, _ range: UnsafePointer<CGFloat>, _ callbacks: UnsafePointer<CGFunctionCallbacks>) -> CGFunction?
Toinit(info:domainDimension:domain:rangeDimension:range:callbacks:)
init?(info info: UnsafeMutableRawPointer?, domainDimension domainDimension: Int, domain domain: UnsafePointer<CGFloat>?, rangeDimension rangeDimension: Int, range range: UnsafePointer<CGFloat>?, callbacks callbacks: UnsafePointer<CGFunctionCallbacks>)

NameDeclaration
FromCGFunctionGetTypeID()
func CGFunctionGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
struct CGFunctionCallbacks {
    var version: UInt32
    var evaluate: CGFunctionEvaluateCallback?
    var releaseInfo: CGFunctionReleaseInfoCallback?
    init()
    init(version version: UInt32, evaluate evaluate: CGFunctionEvaluateCallback?, releaseInfo releaseInfo: CGFunctionReleaseInfoCallback?)
}
To
struct CGFunctionCallbacks {
    var version: UInt32
    var evaluate: CoreGraphics.CGFunctionEvaluateCallback?
    var releaseInfo: CoreGraphics.CGFunctionReleaseInfoCallback?
    init()
    init(version version: UInt32, evaluate evaluate: CoreGraphics.CGFunctionEvaluateCallback?, releaseInfo releaseInfo: CoreGraphics.CGFunctionReleaseInfoCallback?)
}

Declaration
From
var evaluate: CGFunctionEvaluateCallback?
To
var evaluate: CoreGraphics.CGFunctionEvaluateCallback?

Declaration
From
var releaseInfo: CGFunctionReleaseInfoCallback?
To
var releaseInfo: CoreGraphics.CGFunctionReleaseInfoCallback?

Declaration
From
enum CGGlyphDeprecatedEnum : Int32 {
    case Min
    case Max
}
To
enum CGGlyphDeprecatedEnum : Int32 {
    case min
    case max
}

Declaration
From
case Max
To
case max

Declaration
From
case Min
To
case min

Modified CGGradient
Declaration
From
class CGGradient {
}
To
class CGGradient {
    class var typeID: CFTypeID { get }
     init?(colorSpace space: CGColorSpace, colorComponents components: UnsafePointer<CGFloat>, locations locations: UnsafePointer<CGFloat>?, count count: Int)
    init?(colorsSpace space: CGColorSpace?, colors colors: CFArray, locations locations: UnsafePointer<CGFloat>?)
}
extension CGGradient {
    class var typeID: CFTypeID { get }
     init?(colorSpace space: CGColorSpace, colorComponents components: UnsafePointer<CGFloat>, locations locations: UnsafePointer<CGFloat>?, count count: Int)
    init?(colorsSpace space: CGColorSpace?, colors colors: CFArray, locations locations: UnsafePointer<CGFloat>?)
}

NameDeclaration
FromCGGradientCreateWithColorComponents(_:_:_:_:)
func CGGradientCreateWithColorComponents(_ space: CGColorSpace?, _ components: UnsafePointer<CGFloat>, _ locations: UnsafePointer<CGFloat>, _ count: Int) -> CGGradient?
Toinit(colorSpace:colorComponents:locations:count:)
init?(colorSpace space: CGColorSpace, colorComponents components: UnsafePointer<CGFloat>, locations locations: UnsafePointer<CGFloat>?, count count: Int)

NameDeclaration
FromCGGradientCreateWithColors(_:_:_:)
func CGGradientCreateWithColors(_ space: CGColorSpace?, _ colors: CFArray?, _ locations: UnsafePointer<CGFloat>) -> CGGradient?
Toinit(colorsSpace:colors:locations:)
init?(colorsSpace space: CGColorSpace?, colors colors: CFArray, locations locations: UnsafePointer<CGFloat>?)

NameDeclaration
FromCGGradientGetTypeID()
func CGGradientGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

DeclarationProtocols
From
struct CGGradientDrawingOptions : OptionSetType {
    init(rawValue rawValue: UInt32)
    static var DrawsBeforeStartLocation: CGGradientDrawingOptions { get }
    static var DrawsAfterEndLocation: CGGradientDrawingOptions { get }
}
OptionSetType
To
struct CGGradientDrawingOptions : OptionSet {
    init(rawValue rawValue: UInt32)
    static var drawsBeforeStartLocation: CGGradientDrawingOptions { get }
    static var drawsAfterEndLocation: CGGradientDrawingOptions { get }
    func intersect(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
    func exclusiveOr(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
    mutating func unionInPlace(_ other: CGGradientDrawingOptions)
    mutating func intersectInPlace(_ other: CGGradientDrawingOptions)
    mutating func exclusiveOrInPlace(_ other: CGGradientDrawingOptions)
    func isSubsetOf(_ other: CGGradientDrawingOptions) -> Bool
    func isDisjointWith(_ other: CGGradientDrawingOptions) -> Bool
    func isSupersetOf(_ other: CGGradientDrawingOptions) -> Bool
    mutating func subtractInPlace(_ other: CGGradientDrawingOptions)
    func isStrictSupersetOf(_ other: CGGradientDrawingOptions) -> Bool
    func isStrictSubsetOf(_ other: CGGradientDrawingOptions) -> Bool
}
extension CGGradientDrawingOptions {
    func union(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
    func intersection(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
    func symmetricDifference(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
}
extension CGGradientDrawingOptions {
    func contains(_ member: CGGradientDrawingOptions) -> Bool
    mutating func insert(_ newMember: CGGradientDrawingOptions) -> (inserted: Bool, memberAfterInsert: CGGradientDrawingOptions)
    mutating func remove(_ member: CGGradientDrawingOptions) -> CGGradientDrawingOptions?
    mutating func update(with newMember: CGGradientDrawingOptions) -> CGGradientDrawingOptions?
}
extension CGGradientDrawingOptions {
    convenience init()
    mutating func formUnion(_ other: CGGradientDrawingOptions)
    mutating func formIntersection(_ other: CGGradientDrawingOptions)
    mutating func formSymmetricDifference(_ other: CGGradientDrawingOptions)
}
extension CGGradientDrawingOptions {
    convenience init<S : Sequence where S.Iterator.Element == CGGradientDrawingOptions>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: CGGradientDrawingOptions...)
    mutating func subtract(_ other: CGGradientDrawingOptions)
    func isSubset(of other: CGGradientDrawingOptions) -> Bool
    func isSuperset(of other: CGGradientDrawingOptions) -> Bool
    func isDisjoint(with other: CGGradientDrawingOptions) -> Bool
    func subtracting(_ other: CGGradientDrawingOptions) -> CGGradientDrawingOptions
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: CGGradientDrawingOptions) -> Bool
    func isStrictSubset(of other: CGGradientDrawingOptions) -> Bool
}
OptionSet

Declaration
From
static var DrawsAfterEndLocation: CGGradientDrawingOptions { get }
To
static var drawsAfterEndLocation: CGGradientDrawingOptions { get }

Declaration
From
static var DrawsBeforeStartLocation: CGGradientDrawingOptions { get }
To
static var drawsBeforeStartLocation: CGGradientDrawingOptions { get }

Modified CGImage
Declaration
From
class CGImage {
}
To
class CGImage {
    func copy(maskingColorComponents components: [CGFloat]) -> CGImage?
    class var typeID: CFTypeID { get }
    init?(width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: CGBitmapInfo, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    init?(maskWidth width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool)
    func copy() -> CGImage?
    init?(jpegDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    init?(pngDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    func cropping(to rect: CGRect) -> CGImage?
    func masking(_ mask: CGImage) -> CGImage?
    func __copy(maskingColorComponents components: UnsafePointer<CGFloat>) -> CGImage?
    func copy(colorSpace space: CGColorSpace) -> CGImage?
    var isMask: Bool { get }
    var width: Int { get }
    var height: Int { get }
    var bitsPerComponent: Int { get }
    var bitsPerPixel: Int { get }
    var bytesPerRow: Int { get }
    var colorSpace: CGColorSpace? { get }
    var alphaInfo: CGImageAlphaInfo { get }
    var dataProvider: CGDataProvider? { get }
    var decode: UnsafePointer<CGFloat>? { get }
    var shouldInterpolate: Bool { get }
    var renderingIntent: CGColorRenderingIntent { get }
    var bitmapInfo: CGBitmapInfo { get }
    var utType: CFString? { get }
}
extension CGImage {
    class var typeID: CFTypeID { get }
    init?(width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: CGBitmapInfo, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    init?(maskWidth width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool)
    func copy() -> CGImage?
    init?(jpegDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    init?(pngDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)
    func cropping(to rect: CGRect) -> CGImage?
    func masking(_ mask: CGImage) -> CGImage?
    func __copy(maskingColorComponents components: UnsafePointer<CGFloat>) -> CGImage?
    func copy(colorSpace space: CGColorSpace) -> CGImage?
    var isMask: Bool { get }
    var width: Int { get }
    var height: Int { get }
    var bitsPerComponent: Int { get }
    var bitsPerPixel: Int { get }
    var bytesPerRow: Int { get }
    var colorSpace: CGColorSpace? { get }
    var alphaInfo: CGImageAlphaInfo { get }
    var dataProvider: CGDataProvider? { get }
    var decode: UnsafePointer<CGFloat>? { get }
    var shouldInterpolate: Bool { get }
    var renderingIntent: CGColorRenderingIntent { get }
    var bitmapInfo: CGBitmapInfo { get }
    var utType: CFString? { get }
}
extension CGImage {
    func copy(maskingColorComponents components: [CGFloat]) -> CGImage?
}

NameDeclarationReadonly
FromCGImageGetAlphaInfo(_:)
func CGImageGetAlphaInfo(_ image: CGImage?) -> CGImageAlphaInfo
--
ToalphaInfo
var alphaInfo: CGImageAlphaInfo { get }
yes

NameDeclarationReadonly
FromCGImageGetBitmapInfo(_:)
func CGImageGetBitmapInfo(_ image: CGImage?) -> CGBitmapInfo
--
TobitmapInfo
var bitmapInfo: CGBitmapInfo { get }
yes

NameDeclarationReadonly
FromCGImageGetBitsPerComponent(_:)
func CGImageGetBitsPerComponent(_ image: CGImage?) -> Int
--
TobitsPerComponent
var bitsPerComponent: Int { get }
yes

NameDeclarationReadonly
FromCGImageGetBitsPerPixel(_:)
func CGImageGetBitsPerPixel(_ image: CGImage?) -> Int
--
TobitsPerPixel
var bitsPerPixel: Int { get }
yes

NameDeclarationReadonly
FromCGImageGetBytesPerRow(_:)
func CGImageGetBytesPerRow(_ image: CGImage?) -> Int
--
TobytesPerRow
var bytesPerRow: Int { get }
yes

NameDeclarationReadonly
FromCGImageGetColorSpace(_:)
func CGImageGetColorSpace(_ image: CGImage?) -> CGColorSpace?
--
TocolorSpace
var colorSpace: CGColorSpace? { get }
yes

NameDeclaration
FromCGImageCreateCopy(_:)
func CGImageCreateCopy(_ image: CGImage?) -> CGImage?
Tocopy()
func copy() -> CGImage?

NameDeclaration
FromCGImageCreateCopyWithColorSpace(_:_:)
func CGImageCreateCopyWithColorSpace(_ image: CGImage?, _ space: CGColorSpace?) -> CGImage?
Tocopy(colorSpace:)
func copy(colorSpace space: CGColorSpace) -> CGImage?

NameDeclaration
FromCGImageCreateWithImageInRect(_:_:)
func CGImageCreateWithImageInRect(_ image: CGImage?, _ rect: CGRect) -> CGImage?
Tocropping(to:)
func cropping(to rect: CGRect) -> CGImage?

NameDeclarationReadonly
FromCGImageGetDataProvider(_:)
func CGImageGetDataProvider(_ image: CGImage?) -> CGDataProvider?
--
TodataProvider
var dataProvider: CGDataProvider? { get }
yes

NameDeclarationReadonly
FromCGImageGetDecode(_:)
func CGImageGetDecode(_ image: CGImage?) -> UnsafePointer<CGFloat>
--
Todecode
var decode: UnsafePointer<CGFloat>? { get }
yes

NameDeclarationReadonly
FromCGImageGetHeight(_:)
func CGImageGetHeight(_ image: CGImage?) -> Int
--
Toheight
var height: Int { get }
yes

NameDeclaration
FromCGImageCreateWithJPEGDataProvider(_:_:_:_:)
func CGImageCreateWithJPEGDataProvider(_ source: CGDataProvider?, _ decode: UnsafePointer<CGFloat>, _ shouldInterpolate: Bool, _ intent: CGColorRenderingIntent) -> CGImage?
Toinit(jpegDataProviderSource:decode:shouldInterpolate:intent:)
init?(jpegDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)

NameDeclaration
FromCGImageMaskCreate(_:_:_:_:_:_:_:_:)
func CGImageMaskCreate(_ width: Int, _ height: Int, _ bitsPerComponent: Int, _ bitsPerPixel: Int, _ bytesPerRow: Int, _ provider: CGDataProvider?, _ decode: UnsafePointer<CGFloat>, _ shouldInterpolate: Bool) -> CGImage?
Toinit(maskWidth:height:bitsPerComponent:bitsPerPixel:bytesPerRow:provider:decode:shouldInterpolate:)
init?(maskWidth width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool)

NameDeclaration
FromCGImageCreateWithPNGDataProvider(_:_:_:_:)
func CGImageCreateWithPNGDataProvider(_ source: CGDataProvider?, _ decode: UnsafePointer<CGFloat>, _ shouldInterpolate: Bool, _ intent: CGColorRenderingIntent) -> CGImage?
Toinit(pngDataProviderSource:decode:shouldInterpolate:intent:)
init?(pngDataProviderSource source: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)

NameDeclaration
FromCGImageCreate(_:_:_:_:_:_:_:_:_:_:_:)
func CGImageCreate(_ width: Int, _ height: Int, _ bitsPerComponent: Int, _ bitsPerPixel: Int, _ bytesPerRow: Int, _ space: CGColorSpace?, _ bitmapInfo: CGBitmapInfo, _ provider: CGDataProvider?, _ decode: UnsafePointer<CGFloat>, _ shouldInterpolate: Bool, _ intent: CGColorRenderingIntent) -> CGImage?
Toinit(width:height:bitsPerComponent:bitsPerPixel:bytesPerRow:space:bitmapInfo:provider:decode:shouldInterpolate:intent:)
init?(width width: Int, height height: Int, bitsPerComponent bitsPerComponent: Int, bitsPerPixel bitsPerPixel: Int, bytesPerRow bytesPerRow: Int, space space: CGColorSpace, bitmapInfo bitmapInfo: CGBitmapInfo, provider provider: CGDataProvider, decode decode: UnsafePointer<CGFloat>?, shouldInterpolate shouldInterpolate: Bool, intent intent: CGColorRenderingIntent)

NameDeclarationReadonly
FromCGImageIsMask(_:)
func CGImageIsMask(_ image: CGImage?) -> Bool
--
ToisMask
var isMask: Bool { get }
yes

NameDeclaration
FromCGImageCreateWithMask(_:_:)
func CGImageCreateWithMask(_ image: CGImage?, _ mask: CGImage?) -> CGImage?
Tomasking(_:)
func masking(_ mask: CGImage) -> CGImage?

NameDeclarationReadonly
FromCGImageGetRenderingIntent(_:)
func CGImageGetRenderingIntent(_ image: CGImage?) -> CGColorRenderingIntent
--
TorenderingIntent
var renderingIntent: CGColorRenderingIntent { get }
yes

NameDeclarationReadonly
FromCGImageGetShouldInterpolate(_:)
func CGImageGetShouldInterpolate(_ image: CGImage?) -> Bool
--
ToshouldInterpolate
var shouldInterpolate: Bool { get }
yes

NameDeclaration
FromCGImageGetTypeID()
func CGImageGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

NameDeclarationReadonly
FromCGImageGetUTType(_:)
func CGImageGetUTType(_ image: CGImage?) -> CFString?
--
ToutType
var utType: CFString? { get }
yes

NameDeclarationReadonly
FromCGImageGetWidth(_:)
func CGImageGetWidth(_ image: CGImage?) -> Int
--
Towidth
var width: Int { get }
yes

Declaration
From
enum CGImageAlphaInfo : UInt32 {
    case None
    case PremultipliedLast
    case PremultipliedFirst
    case Last
    case First
    case NoneSkipLast
    case NoneSkipFirst
    case Only
}
To
enum CGImageAlphaInfo : UInt32 {
    case none
    case premultipliedLast
    case premultipliedFirst
    case last
    case first
    case noneSkipLast
    case noneSkipFirst
    case alphaOnly
}

Declaration
From
case Only
To
case alphaOnly

Declaration
From
case First
To
case first

Declaration
From
case Last
To
case last

Declaration
From
case None
To
case none

Declaration
From
case NoneSkipFirst
To
case noneSkipFirst

Declaration
From
case NoneSkipLast
To
case noneSkipLast

Declaration
From
case PremultipliedFirst
To
case premultipliedFirst

Declaration
From
case PremultipliedLast
To
case premultipliedLast

Declaration
From
enum CGInterpolationQuality : Int32 {
    case Default
    case None
    case Low
    case Medium
    case High
}
To
enum CGInterpolationQuality : Int32 {
    case `default`
    case none
    case low
    case medium
    case high
}

Declaration
From
case Default
To
case `default`

Declaration
From
case High
To
case high

Declaration
From
case Low
To
case low

Declaration
From
case Medium
To
case medium

Declaration
From
case None
To
case none

Modified CGLayer
Declaration
From
class CGLayer {
}
To
class CGLayer {
     init?(_ context: CGContext, size size: CGSize, auxiliaryInfo auxiliaryInfo: CFDictionary?)
    var size: CGSize { get }
    var context: CGContext? { get }
    class var typeID: CFTypeID { get }
}
extension CGLayer {
     init?(_ context: CGContext, size size: CGSize, auxiliaryInfo auxiliaryInfo: CFDictionary?)
    var size: CGSize { get }
    var context: CGContext? { get }
    class var typeID: CFTypeID { get }
}

NameDeclarationReadonly
FromCGLayerGetContext(_:)
func CGLayerGetContext(_ layer: CGLayer?) -> CGContext?
--
Tocontext
var context: CGContext? { get }
yes

NameDeclaration
FromCGLayerCreateWithContext(_:_:_:)
func CGLayerCreateWithContext(_ context: CGContext?, _ size: CGSize, _ auxiliaryInfo: CFDictionary?) -> CGLayer?
Toinit(_:size:auxiliaryInfo:)
init?(_ context: CGContext, size size: CGSize, auxiliaryInfo auxiliaryInfo: CFDictionary?)

NameDeclarationReadonly
FromCGLayerGetSize(_:)
func CGLayerGetSize(_ layer: CGLayer?) -> CGSize
--
Tosize
var size: CGSize { get }
yes

NameDeclaration
FromCGLayerGetTypeID()
func CGLayerGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
enum CGLineCap : Int32 {
    case Butt
    case Round
    case Square
}
To
enum CGLineCap : Int32 {
    case butt
    case round
    case square
}

Declaration
From
case Butt
To
case butt

Declaration
From
case Round
To
case round

Declaration
From
case Square
To
case square

Declaration
From
enum CGLineJoin : Int32 {
    case Miter
    case Round
    case Bevel
}
To
enum CGLineJoin : Int32 {
    case miter
    case round
    case bevel
}

Declaration
From
case Bevel
To
case bevel

Declaration
From
case Miter
To
case miter

Declaration
From
case Round
To
case round

Modified CGMutablePath
Declaration
From
class CGMutablePath {
}
To
class CGMutablePath {
    func addRoundedRect(in rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat, transform transform: CGAffineTransform = default)
    func move(to point: CGPoint, transform transform: CGAffineTransform = default)
    func addLine(to point: CGPoint, transform transform: CGAffineTransform = default)
    func addQuadCurve(to end: CGPoint, control control: CGPoint, transform transform: CGAffineTransform = default)
    func addCurve(to end: CGPoint, control1 control1: CGPoint, control2 control2: CGPoint, transform transform: CGAffineTransform = default)
    func addRect(_ rect: CGRect, transform transform: CGAffineTransform = default)
    func addRects(_ rects: [CGRect], transform transform: CGAffineTransform = default)
    func addLines(between points: [CGPoint], transform transform: CGAffineTransform = default)
    func addEllipse(in rect: CGRect, transform transform: CGAffineTransform = default)
    func addRelativeArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, delta delta: CGFloat, transform transform: CGAffineTransform = default)
    func addArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool, transform transform: CGAffineTransform = default)
    func addArc(tangent1End tangent1End: CGPoint, tangent2End tangent2End: CGPoint, radius radius: CGFloat, transform transform: CGAffineTransform = default)
    func addPath(_ path: CGPath, transform transform: CGAffineTransform = default)
    init()
    func __addRoundedRect(transform transform: UnsafePointer<CGAffineTransform>?, rect rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat)
    func __moveTo(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat)
    func __addLineTo(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat)
    func __addQuadCurve(transform m: UnsafePointer<CGAffineTransform>?, cpx cpx: CGFloat, cpy cpy: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func __addCurve(transform m: UnsafePointer<CGAffineTransform>?, cp1x cp1x: CGFloat, cp1y cp1y: CGFloat, cp2x cp2x: CGFloat, cp2y cp2y: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func closeSubpath()
    func __addRect(transform m: UnsafePointer<CGAffineTransform>?, rect rect: CGRect)
    func __addRects(transform m: UnsafePointer<CGAffineTransform>?, rects rects: UnsafePointer<CGRect>?, count count: Int)
    func __addLines(transform m: UnsafePointer<CGAffineTransform>?, between points: UnsafePointer<CGPoint>?, count count: Int)
    func __addEllipse(transform m: UnsafePointer<CGAffineTransform>?, rect rect: CGRect)
    func __addRelativeArc(transform matrix: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, delta delta: CGFloat)
    func __addArc(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool)
    func __addArc(transform m: UnsafePointer<CGAffineTransform>?, x1 x1: CGFloat, y1 y1: CGFloat, x2 x2: CGFloat, y2 y2: CGFloat, radius radius: CGFloat)
    func __addPath(transform m: UnsafePointer<CGAffineTransform>?, path path2: CGPath)
}
extension CGMutablePath {
    init()
    func __addRoundedRect(transform transform: UnsafePointer<CGAffineTransform>?, rect rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat)
    func __moveTo(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat)
    func __addLineTo(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat)
    func __addQuadCurve(transform m: UnsafePointer<CGAffineTransform>?, cpx cpx: CGFloat, cpy cpy: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func __addCurve(transform m: UnsafePointer<CGAffineTransform>?, cp1x cp1x: CGFloat, cp1y cp1y: CGFloat, cp2x cp2x: CGFloat, cp2y cp2y: CGFloat, endingAtX x: CGFloat, y y: CGFloat)
    func closeSubpath()
    func __addRect(transform m: UnsafePointer<CGAffineTransform>?, rect rect: CGRect)
    func __addRects(transform m: UnsafePointer<CGAffineTransform>?, rects rects: UnsafePointer<CGRect>?, count count: Int)
    func __addLines(transform m: UnsafePointer<CGAffineTransform>?, between points: UnsafePointer<CGPoint>?, count count: Int)
    func __addEllipse(transform m: UnsafePointer<CGAffineTransform>?, rect rect: CGRect)
    func __addRelativeArc(transform matrix: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, delta delta: CGFloat)
    func __addArc(transform m: UnsafePointer<CGAffineTransform>?, x x: CGFloat, y y: CGFloat, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool)
    func __addArc(transform m: UnsafePointer<CGAffineTransform>?, x1 x1: CGFloat, y1 y1: CGFloat, x2 x2: CGFloat, y2 y2: CGFloat, radius radius: CGFloat)
    func __addPath(transform m: UnsafePointer<CGAffineTransform>?, path path2: CGPath)
}
extension CGMutablePath {
    func addRoundedRect(in rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat, transform transform: CGAffineTransform = default)
    func move(to point: CGPoint, transform transform: CGAffineTransform = default)
    func addLine(to point: CGPoint, transform transform: CGAffineTransform = default)
    func addQuadCurve(to end: CGPoint, control control: CGPoint, transform transform: CGAffineTransform = default)
    func addCurve(to end: CGPoint, control1 control1: CGPoint, control2 control2: CGPoint, transform transform: CGAffineTransform = default)
    func addRect(_ rect: CGRect, transform transform: CGAffineTransform = default)
    func addRects(_ rects: [CGRect], transform transform: CGAffineTransform = default)
    func addLines(between points: [CGPoint], transform transform: CGAffineTransform = default)
    func addEllipse(in rect: CGRect, transform transform: CGAffineTransform = default)
    func addRelativeArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, delta delta: CGFloat, transform transform: CGAffineTransform = default)
    func addArc(center center: CGPoint, radius radius: CGFloat, startAngle startAngle: CGFloat, endAngle endAngle: CGFloat, clockwise clockwise: Bool, transform transform: CGAffineTransform = default)
    func addArc(tangent1End tangent1End: CGPoint, tangent2End tangent2End: CGPoint, radius radius: CGFloat, transform transform: CGAffineTransform = default)
    func addPath(_ path: CGPath, transform transform: CGAffineTransform = default)
}

NameDeclaration
FromCGPathCloseSubpath(_:)
func CGPathCloseSubpath(_ path: CGMutablePath?)
TocloseSubpath()
func closeSubpath()

NameDeclaration
FromCGPathCreateMutable()
func CGPathCreateMutable() -> CGMutablePath
Toinit()
init()

Modified CGPath
DeclarationProtocols
From
class CGPath {
}
--
To
class CGPath {
    func copy(dashingWithPhase phase: CGFloat, lengths lengths: [CGFloat], transform transform: CGAffineTransform = default) -> CGPath
    func copy(strokingWithWidth lineWidth: CGFloat, lineCap lineCap: CGLineCap, lineJoin lineJoin: CGLineJoin, miterLimit miterLimit: CGFloat, transform transform: CGAffineTransform = default) -> CGPath
    func contains(_ point: CGPoint, using rule: CGPathFillRule = default, transform transform: CGAffineTransform = default) -> Bool
    class var typeID: CFTypeID { get }
    func copy() -> CGPath?
    func copy(using transform: UnsafePointer<CGAffineTransform>?) -> CGPath?
    func mutableCopy() -> CGMutablePath?
    func mutableCopy(using transform: UnsafePointer<CGAffineTransform>?) -> CGMutablePath?
    init(rect rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)
    init(ellipseIn rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)
    init(roundedRect rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat, transform transform: UnsafePointer<CGAffineTransform>?)
     init?(__byDashing path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, phase phase: CGFloat, lengths lengths: UnsafePointer<CGFloat>?, count count: Int)
     init?(__byStroking path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, lineWidth lineWidth: CGFloat, lineCap lineCap: CGLineCap, lineJoin lineJoin: CGLineJoin, miterLimit miterLimit: CGFloat)
    func __equalTo(_ path2: CGPath) -> Bool
    var isEmpty: Bool { get }
    func isRect(_ rect: UnsafeMutablePointer<CGRect>?) -> Bool
    var currentPoint: CGPoint { get }
    var boundingBox: CGRect { get }
    var boundingBoxOfPath: CGRect { get }
    func __containsPoint(transform m: UnsafePointer<CGAffineTransform>?, point point: CGPoint, eoFill eoFill: Bool) -> Bool
    func apply(info info: UnsafeMutableRawPointer?, function function: CoreGraphics.CGPathApplierFunction)
}
extension CGPath {
    class var typeID: CFTypeID { get }
    func copy() -> CGPath?
    func copy(using transform: UnsafePointer<CGAffineTransform>?) -> CGPath?
    func mutableCopy() -> CGMutablePath?
    func mutableCopy(using transform: UnsafePointer<CGAffineTransform>?) -> CGMutablePath?
    init(rect rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)
    init(ellipseIn rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)
    init(roundedRect rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat, transform transform: UnsafePointer<CGAffineTransform>?)
     init?(__byDashing path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, phase phase: CGFloat, lengths lengths: UnsafePointer<CGFloat>?, count count: Int)
     init?(__byStroking path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, lineWidth lineWidth: CGFloat, lineCap lineCap: CGLineCap, lineJoin lineJoin: CGLineJoin, miterLimit miterLimit: CGFloat)
    func __equalTo(_ path2: CGPath) -> Bool
    var isEmpty: Bool { get }
    func isRect(_ rect: UnsafeMutablePointer<CGRect>?) -> Bool
    var currentPoint: CGPoint { get }
    var boundingBox: CGRect { get }
    var boundingBoxOfPath: CGRect { get }
    func __containsPoint(transform m: UnsafePointer<CGAffineTransform>?, point point: CGPoint, eoFill eoFill: Bool) -> Bool
    func apply(info info: UnsafeMutableRawPointer?, function function: CoreGraphics.CGPathApplierFunction)
}
extension CGPath : Equatable {
}
extension CGPath {
    func copy(dashingWithPhase phase: CGFloat, lengths lengths: [CGFloat], transform transform: CGAffineTransform = default) -> CGPath
    func copy(strokingWithWidth lineWidth: CGFloat, lineCap lineCap: CGLineCap, lineJoin lineJoin: CGLineJoin, miterLimit miterLimit: CGFloat, transform transform: CGAffineTransform = default) -> CGPath
    func contains(_ point: CGPoint, using rule: CGPathFillRule = default, transform transform: CGAffineTransform = default) -> Bool
}
Equatable

NameDeclaration
FromCGPathApply(_:_:_:)
func CGPathApply(_ path: CGPath?, _ info: UnsafeMutablePointer<Void>, _ function: CGPathApplierFunction?)
Toapply(info:function:)
func apply(info info: UnsafeMutableRawPointer?, function function: CoreGraphics.CGPathApplierFunction)

NameDeclarationReadonly
FromCGPathGetBoundingBox(_:)
func CGPathGetBoundingBox(_ path: CGPath?) -> CGRect
--
ToboundingBox
var boundingBox: CGRect { get }
yes

NameDeclarationReadonly
FromCGPathGetPathBoundingBox(_:)
func CGPathGetPathBoundingBox(_ path: CGPath?) -> CGRect
--
ToboundingBoxOfPath
var boundingBoxOfPath: CGRect { get }
yes

NameDeclaration
FromCGPathCreateCopy(_:)
func CGPathCreateCopy(_ path: CGPath?) -> CGPath?
Tocopy()
func copy() -> CGPath?

NameDeclaration
FromCGPathCreateCopyByTransformingPath(_:_:)
func CGPathCreateCopyByTransformingPath(_ path: CGPath?, _ transform: UnsafePointer<CGAffineTransform>) -> CGPath?
Tocopy(using:)
func copy(using transform: UnsafePointer<CGAffineTransform>?) -> CGPath?

NameDeclarationReadonly
FromCGPathGetCurrentPoint(_:)
func CGPathGetCurrentPoint(_ path: CGPath?) -> CGPoint
--
TocurrentPoint
var currentPoint: CGPoint { get }
yes

NameDeclaration
FromCGPathCreateCopyByDashingPath(_:_:_:_:_:)
func CGPathCreateCopyByDashingPath(_ path: CGPath?, _ transform: UnsafePointer<CGAffineTransform>, _ phase: CGFloat, _ lengths: UnsafePointer<CGFloat>, _ count: Int) -> CGPath?
Toinit(__byDashing:transform:phase:lengths:count:)
init?(__byDashing path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, phase phase: CGFloat, lengths lengths: UnsafePointer<CGFloat>?, count count: Int)

NameDeclaration
FromCGPathCreateCopyByStrokingPath(_:_:_:_:_:_:)
func CGPathCreateCopyByStrokingPath(_ path: CGPath?, _ transform: UnsafePointer<CGAffineTransform>, _ lineWidth: CGFloat, _ lineCap: CGLineCap, _ lineJoin: CGLineJoin, _ miterLimit: CGFloat) -> CGPath?
Toinit(__byStroking:transform:lineWidth:lineCap:lineJoin:miterLimit:)
init?(__byStroking path: CGPath, transform transform: UnsafePointer<CGAffineTransform>?, lineWidth lineWidth: CGFloat, lineCap lineCap: CGLineCap, lineJoin lineJoin: CGLineJoin, miterLimit miterLimit: CGFloat)

NameDeclaration
FromCGPathCreateWithEllipseInRect(_:_:)
func CGPathCreateWithEllipseInRect(_ rect: CGRect, _ transform: UnsafePointer<CGAffineTransform>) -> CGPath
Toinit(ellipseIn:transform:)
init(ellipseIn rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)

NameDeclaration
FromCGPathCreateWithRect(_:_:)
func CGPathCreateWithRect(_ rect: CGRect, _ transform: UnsafePointer<CGAffineTransform>) -> CGPath
Toinit(rect:transform:)
init(rect rect: CGRect, transform transform: UnsafePointer<CGAffineTransform>?)

NameDeclaration
FromCGPathCreateWithRoundedRect(_:_:_:_:)
func CGPathCreateWithRoundedRect(_ rect: CGRect, _ cornerWidth: CGFloat, _ cornerHeight: CGFloat, _ transform: UnsafePointer<CGAffineTransform>) -> CGPath
Toinit(roundedRect:cornerWidth:cornerHeight:transform:)
init(roundedRect rect: CGRect, cornerWidth cornerWidth: CGFloat, cornerHeight cornerHeight: CGFloat, transform transform: UnsafePointer<CGAffineTransform>?)

NameDeclarationReadonly
FromCGPathIsEmpty(_:)
func CGPathIsEmpty(_ path: CGPath?) -> Bool
--
ToisEmpty
var isEmpty: Bool { get }
yes

NameDeclaration
FromCGPathIsRect(_:_:)
func CGPathIsRect(_ path: CGPath?, _ rect: UnsafeMutablePointer<CGRect>) -> Bool
ToisRect(_:)
func isRect(_ rect: UnsafeMutablePointer<CGRect>?) -> Bool

NameDeclaration
FromCGPathCreateMutableCopy(_:)
func CGPathCreateMutableCopy(_ path: CGPath?) -> CGMutablePath?
TomutableCopy()
func mutableCopy() -> CGMutablePath?

NameDeclaration
FromCGPathCreateMutableCopyByTransformingPath(_:_:)
func CGPathCreateMutableCopyByTransformingPath(_ path: CGPath?, _ transform: UnsafePointer<CGAffineTransform>) -> CGMutablePath?
TomutableCopy(using:)
func mutableCopy(using transform: UnsafePointer<CGAffineTransform>?) -> CGMutablePath?

NameDeclaration
FromCGPathGetTypeID()
func CGPathGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
enum CGPathDrawingMode : Int32 {
    case Fill
    case EOFill
    case Stroke
    case FillStroke
    case EOFillStroke
}
To
enum CGPathDrawingMode : Int32 {
    case fill
    case eoFill
    case stroke
    case fillStroke
    case eoFillStroke
}

Declaration
From
case EOFill
To
case eoFill

Declaration
From
case EOFillStroke
To
case eoFillStroke

Declaration
From
case Fill
To
case fill

Declaration
From
case FillStroke
To
case fillStroke

Declaration
From
case Stroke
To
case stroke

Declaration
From
enum CGPathElementType : Int32 {
    case MoveToPoint
    case AddLineToPoint
    case AddQuadCurveToPoint
    case AddCurveToPoint
    case CloseSubpath
}
To
enum CGPathElementType : Int32 {
    case moveToPoint
    case addLineToPoint
    case addQuadCurveToPoint
    case addCurveToPoint
    case closeSubpath
}

Declaration
From
case AddCurveToPoint
To
case addCurveToPoint

Declaration
From
case AddLineToPoint
To
case addLineToPoint

Declaration
From
case AddQuadCurveToPoint
To
case addQuadCurveToPoint

Declaration
From
case CloseSubpath
To
case closeSubpath

Declaration
From
case MoveToPoint
To
case moveToPoint

Modified CGPattern
Declaration
From
class CGPattern {
}
To
class CGPattern {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, bounds bounds: CGRect, matrix matrix: CGAffineTransform, xStep xStep: CGFloat, yStep yStep: CGFloat, tiling tiling: CGPatternTiling, isColored isColored: Bool, callbacks callbacks: UnsafePointer<CGPatternCallbacks>)
}
extension CGPattern {
    class var typeID: CFTypeID { get }
    init?(info info: UnsafeMutableRawPointer?, bounds bounds: CGRect, matrix matrix: CGAffineTransform, xStep xStep: CGFloat, yStep yStep: CGFloat, tiling tiling: CGPatternTiling, isColored isColored: Bool, callbacks callbacks: UnsafePointer<CGPatternCallbacks>)
}

NameDeclaration
FromCGPatternCreate(_:_:_:_:_:_:_:_:)
func CGPatternCreate(_ info: UnsafeMutablePointer<Void>, _ bounds: CGRect, _ matrix: CGAffineTransform, _ xStep: CGFloat, _ yStep: CGFloat, _ tiling: CGPatternTiling, _ isColored: Bool, _ callbacks: UnsafePointer<CGPatternCallbacks>) -> CGPattern?
Toinit(info:bounds:matrix:xStep:yStep:tiling:isColored:callbacks:)
init?(info info: UnsafeMutableRawPointer?, bounds bounds: CGRect, matrix matrix: CGAffineTransform, xStep xStep: CGFloat, yStep yStep: CGFloat, tiling tiling: CGPatternTiling, isColored isColored: Bool, callbacks callbacks: UnsafePointer<CGPatternCallbacks>)

NameDeclaration
FromCGPatternGetTypeID()
func CGPatternGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

Declaration
From
struct CGPatternCallbacks {
    var version: UInt32
    var drawPattern: CGPatternDrawPatternCallback?
    var releaseInfo: CGPatternReleaseInfoCallback?
    init()
    init(version version: UInt32, drawPattern drawPattern: CGPatternDrawPatternCallback?, releaseInfo releaseInfo: CGPatternReleaseInfoCallback?)
}
To
struct CGPatternCallbacks {
    var version: UInt32
    var drawPattern: CoreGraphics.CGPatternDrawPatternCallback?
    var releaseInfo: CoreGraphics.CGPatternReleaseInfoCallback?
    init()
    init(version version: UInt32, drawPattern drawPattern: CoreGraphics.CGPatternDrawPatternCallback?, releaseInfo releaseInfo: CoreGraphics.CGPatternReleaseInfoCallback?)
}

Declaration
From
var drawPattern: CGPatternDrawPatternCallback?
To
var drawPattern: CoreGraphics.CGPatternDrawPatternCallback?

Declaration
From
var releaseInfo: CGPatternReleaseInfoCallback?
To
var releaseInfo: CoreGraphics.CGPatternReleaseInfoCallback?

Declaration
From
enum CGPatternTiling : Int32 {
    case NoDistortion
    case ConstantSpacingMinimalDistortion
    case ConstantSpacing
}
To
enum CGPatternTiling : Int32 {
    case noDistortion
    case constantSpacingMinimalDistortion
    case constantSpacing
}

Declaration
From
case ConstantSpacing
To
case constantSpacing

Declaration
From
case ConstantSpacingMinimalDistortion
To
case constantSpacingMinimalDistortion

Declaration
From
case NoDistortion
To
case noDistortion

Declaration
From
enum CGPDFBox : Int32 {
    case MediaBox
    case CropBox
    case BleedBox
    case TrimBox
    case ArtBox
}
To
enum CGPDFBox : Int32 {
    case mediaBox
    case cropBox
    case bleedBox
    case trimBox
    case artBox
}

Declaration
From
case ArtBox
To
case artBox

Declaration
From
case BleedBox
To
case bleedBox

Declaration
From
case CropBox
To
case cropBox

Declaration
From
case MediaBox
To
case mediaBox

Declaration
From
case TrimBox
To
case trimBox

Declaration
From
enum CGPDFDataFormat : Int32 {
    case Raw
    case JPEGEncoded
    case JPEG2000
}
To
enum CGPDFDataFormat : Int32 {
    case raw
    case jpegEncoded
    case JPEG2000
}

Declaration
From
case JPEGEncoded
To
case jpegEncoded

Declaration
From
case Raw
To
case raw

Modified CGPDFDocument
Declaration
From
class CGPDFDocument {
}
To
class CGPDFDocument {
     init?(_ provider: CGDataProvider)
     init?(_ url: CFURL)
    func getVersion(majorVersion majorVersion: UnsafeMutablePointer<Int32>, minorVersion minorVersion: UnsafeMutablePointer<Int32>)
    var isEncrypted: Bool { get }
    func unlockWithPassword(_ password: UnsafePointer<Int8>) -> Bool
    var isUnlocked: Bool { get }
    var allowsPrinting: Bool { get }
    var allowsCopying: Bool { get }
    var numberOfPages: Int { get }
    func page(at pageNumber: Int) -> CGPDFPage?
    var catalog: CGPDFDictionaryRef? { get }
    var info: CGPDFDictionaryRef? { get }
    var fileIdentifier: CGPDFArrayRef? { get }
    class var typeID: CFTypeID { get }
    func getMediaBox(page page: Int32) -> CGRect
    func getCropBox(page page: Int32) -> CGRect
    func getBleedBox(page page: Int32) -> CGRect
    func getTrimBox(page page: Int32) -> CGRect
    func getArtBox(page page: Int32) -> CGRect
    func getRotationAngle(page page: Int32) -> Int32
}
extension CGPDFDocument {
     init?(_ provider: CGDataProvider)
     init?(_ url: CFURL)
    func getVersion(majorVersion majorVersion: UnsafeMutablePointer<Int32>, minorVersion minorVersion: UnsafeMutablePointer<Int32>)
    var isEncrypted: Bool { get }
    func unlockWithPassword(_ password: UnsafePointer<Int8>) -> Bool
    var isUnlocked: Bool { get }
    var allowsPrinting: Bool { get }
    var allowsCopying: Bool { get }
    var numberOfPages: Int { get }
    func page(at pageNumber: Int) -> CGPDFPage?
    var catalog: CGPDFDictionaryRef? { get }
    var info: CGPDFDictionaryRef? { get }
    var fileIdentifier: CGPDFArrayRef? { get }
    class var typeID: CFTypeID { get }
    func getMediaBox(page page: Int32) -> CGRect
    func getCropBox(page page: Int32) -> CGRect
    func getBleedBox(page page: Int32) -> CGRect
    func getTrimBox(page page: Int32) -> CGRect
    func getArtBox(page page: Int32) -> CGRect
    func getRotationAngle(page page: Int32) -> Int32
}

NameDeclarationReadonly
FromCGPDFDocumentAllowsCopying(_:)
func CGPDFDocumentAllowsCopying(_ document: CGPDFDocument?) -> Bool
--
ToallowsCopying
var allowsCopying: Bool { get }
yes

NameDeclarationReadonly
FromCGPDFDocumentAllowsPrinting(_:)
func CGPDFDocumentAllowsPrinting(_ document: CGPDFDocument?) -> Bool
--
ToallowsPrinting
var allowsPrinting: Bool { get }
yes

NameDeclarationReadonly
FromCGPDFDocumentGetCatalog(_:)
func CGPDFDocumentGetCatalog(_ document: CGPDFDocument?) -> CGPDFDictionaryRef
--
Tocatalog
var catalog: CGPDFDictionaryRef? { get }
yes

NameDeclarationReadonly
FromCGPDFDocumentGetID(_:)
func CGPDFDocumentGetID(_ document: CGPDFDocument?) -> CGPDFArrayRef
--
TofileIdentifier
var fileIdentifier: CGPDFArrayRef? { get }
yes

NameDeclaration
FromCGPDFDocumentGetVersion(_:_:_:)
func CGPDFDocumentGetVersion(_ document: CGPDFDocument?, _ majorVersion: UnsafeMutablePointer<Int32>, _ minorVersion: UnsafeMutablePointer<Int32>)
TogetVersion(majorVersion:minorVersion:)
func getVersion(majorVersion majorVersion: UnsafeMutablePointer<Int32>, minorVersion minorVersion: UnsafeMutablePointer<Int32>)

NameDeclarationReadonly
FromCGPDFDocumentGetInfo(_:)
func CGPDFDocumentGetInfo(_ document: CGPDFDocument?) -> CGPDFDictionaryRef
--
Toinfo
var info: CGPDFDictionaryRef? { get }
yes

NameDeclaration
FromCGPDFDocumentCreateWithURL(_:)
func CGPDFDocumentCreateWithURL(_ url: CFURL?) -> CGPDFDocument?
Toinit(_:)
init?(_ url: CFURL)

NameDeclaration
FromCGPDFDocumentCreateWithProvider(_:)
func CGPDFDocumentCreateWithProvider(_ provider: CGDataProvider?) -> CGPDFDocument?
Toinit(_:)
init?(_ provider: CGDataProvider)

NameDeclarationReadonly
FromCGPDFDocumentIsEncrypted(_:)
func CGPDFDocumentIsEncrypted(_ document: CGPDFDocument?) -> Bool
--
ToisEncrypted
var isEncrypted: Bool { get }
yes

NameDeclarationReadonly
FromCGPDFDocumentIsUnlocked(_:)
func CGPDFDocumentIsUnlocked(_ document: CGPDFDocument?) -> Bool
--
ToisUnlocked
var isUnlocked: Bool { get }
yes

NameDeclarationReadonly
FromCGPDFDocumentGetNumberOfPages(_:)
func CGPDFDocumentGetNumberOfPages(_ document: CGPDFDocument?) -> Int
--
TonumberOfPages
var numberOfPages: Int { get }
yes

NameDeclaration
FromCGPDFDocumentGetPage(_:_:)
func CGPDFDocumentGetPage(_ document: CGPDFDocument?, _ pageNumber: Int) -> CGPDFPage?
Topage(at:)
func page(at pageNumber: Int) -> CGPDFPage?

NameDeclaration
FromCGPDFDocumentGetTypeID()
func CGPDFDocumentGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

NameDeclaration
FromCGPDFDocumentUnlockWithPassword(_:_:)
func CGPDFDocumentUnlockWithPassword(_ document: CGPDFDocument?, _ password: UnsafePointer<Int8>) -> Bool
TounlockWithPassword(_:)
func unlockWithPassword(_ password: UnsafePointer<Int8>) -> Bool

Declaration
From
enum CGPDFObjectType : Int32 {
    case Null
    case Boolean
    case Integer
    case Real
    case Name
    case String
    case Array
    case Dictionary
    case Stream
}
To
enum CGPDFObjectType : Int32 {
    case null
    case boolean
    case integer
    case real
    case name
    case string
    case array
    case dictionary
    case stream
}

Declaration
From
case Array
To
case array

Declaration
From
case Boolean
To
case boolean

Declaration
From
case Dictionary
To
case dictionary

Declaration
From
case Integer
To
case integer

Declaration
From
case Name
To
case name

Declaration
From
case Null
To
case null

Declaration
From
case Real
To
case real

Declaration
From
case Stream
To
case stream

Declaration
From
case String
To
case string

Modified CGPDFPage
Declaration
From
class CGPDFPage {
}
To
class CGPDFPage {
    var document: CGPDFDocument? { get }
    var pageNumber: Int { get }
    func getBoxRect(_ box: CGPDFBox) -> CGRect
    var rotationAngle: Int32 { get }
    func getDrawingTransform(_ box: CGPDFBox, rect rect: CGRect, rotate rotate: Int32, preserveAspectRatio preserveAspectRatio: Bool) -> CGAffineTransform
    var dictionary: CGPDFDictionaryRef? { get }
    class var typeID: CFTypeID { get }
}
extension CGPDFPage {
    var document: CGPDFDocument? { get }
    var pageNumber: Int { get }
    func getBoxRect(_ box: CGPDFBox) -> CGRect
    var rotationAngle: Int32 { get }
    func getDrawingTransform(_ box: CGPDFBox, rect rect: CGRect, rotate rotate: Int32, preserveAspectRatio preserveAspectRatio: Bool) -> CGAffineTransform
    var dictionary: CGPDFDictionaryRef? { get }
    class var typeID: CFTypeID { get }
}

NameDeclarationReadonly
FromCGPDFPageGetDictionary(_:)
func CGPDFPageGetDictionary(_ page: CGPDFPage?) -> CGPDFDictionaryRef
--
Todictionary
var dictionary: CGPDFDictionaryRef? { get }
yes

NameDeclarationReadonly
FromCGPDFPageGetDocument(_:)
func CGPDFPageGetDocument(_ page: CGPDFPage?) -> CGPDFDocument?
--
Todocument
var document: CGPDFDocument? { get }
yes

NameDeclaration
FromCGPDFPageGetBoxRect(_:_:)
func CGPDFPageGetBoxRect(_ page: CGPDFPage?, _ box: CGPDFBox) -> CGRect
TogetBoxRect(_:)
func getBoxRect(_ box: CGPDFBox) -> CGRect

NameDeclaration
FromCGPDFPageGetDrawingTransform(_:_:_:_:_:)
func CGPDFPageGetDrawingTransform(_ page: CGPDFPage?, _ box: CGPDFBox, _ rect: CGRect, _ rotate: Int32, _ preserveAspectRatio: Bool) -> CGAffineTransform
TogetDrawingTransform(_:rect:rotate:preserveAspectRatio:)
func getDrawingTransform(_ box: CGPDFBox, rect rect: CGRect, rotate rotate: Int32, preserveAspectRatio preserveAspectRatio: Bool) -> CGAffineTransform

NameDeclarationReadonly
FromCGPDFPageGetPageNumber(_:)
func CGPDFPageGetPageNumber(_ page: CGPDFPage?) -> Int
--
TopageNumber
var pageNumber: Int { get }
yes

NameDeclarationReadonly
FromCGPDFPageGetRotationAngle(_:)
func CGPDFPageGetRotationAngle(_ page: CGPDFPage?) -> Int32
--
TorotationAngle
var rotationAngle: Int32 { get }
yes

NameDeclaration
FromCGPDFPageGetTypeID()
func CGPDFPageGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

DeclarationProtocols
From
struct CGPoint {
    var x: CGFloat
    var y: CGFloat
    init()
    init(x x: CGFloat, y y: CGFloat)
}
extension CGPoint {
    static var zero: CGPoint { get }
    init(x x: Int, y y: Int)
    init(x x: Double, y y: Double)
    static var zeroPoint: CGPoint { get }
}
extension CGPoint : Equatable {
}
extension CGPoint : _Reflectable {
}
extension CGPoint {
    static var zero: CGPoint { get }
    init(x x: Int, y y: Int)
    init(x x: Double, y y: Double)
    static var zeroPoint: CGPoint { get }
}
extension CGPoint : Equatable {
}
extension CGPoint : _Reflectable {
}
Equatable
To
struct CGPoint {
    var x: CGFloat
    var y: CGFloat
    init()
    init(x x: CGFloat, y y: CGFloat)
    func applying(_ t: CGAffineTransform) -> CGPoint
    static let zero: CGPoint
    init(x x: CGFloat, y y: CGFloat)
    func equalTo(_ point2: CGPoint) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ point: UnsafeMutablePointer<CGPoint>) -> Bool
    static var zero: CGPoint { get }
    init(x x: Int, y y: Int)
    init(x x: Double, y y: Double)
    init?(dictionaryRepresentation dict: CFDictionary)
}
extension CGPoint {
    func applying(_ t: CGAffineTransform) -> CGPoint
}
extension CGPoint : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGPoint : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGPoint {
    static let zero: CGPoint
    init(x x: CGFloat, y y: CGFloat)
    func equalTo(_ point2: CGPoint) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ point: UnsafeMutablePointer<CGPoint>) -> Bool
}
extension CGPoint : Equatable {
}
extension CGPoint : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGPoint : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGPoint {
    static var zero: CGPoint { get }
    init(x x: Int, y y: Int)
    init(x x: Double, y y: Double)
    init?(dictionaryRepresentation dict: CFDictionary)
}
CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Equatable

NameDeclaration
FromCGPointApplyAffineTransform(_:_:)
func CGPointApplyAffineTransform(_ point: CGPoint, _ t: CGAffineTransform) -> CGPoint
Toapplying(_:)
func applying(_ t: CGAffineTransform) -> CGPoint

NameDeclarationReadonly
FromCGPointCreateDictionaryRepresentation(_:)
func CGPointCreateDictionaryRepresentation(_ point: CGPoint) -> CFDictionary
--
TodictionaryRepresentation
var dictionaryRepresentation: CFDictionary { get }
yes

NameDeclaration
FromCGPointEqualToPoint(_:_:)
func CGPointEqualToPoint(_ point1: CGPoint, _ point2: CGPoint) -> Bool
ToequalTo(_:)
func equalTo(_ point2: CGPoint) -> Bool

DeclarationProtocols
From
struct CGRect {
    var origin: CGPoint
    var size: CGSize
    init()
    init(origin origin: CGPoint, size size: CGSize)
}
extension CGRect {
    static var zero: CGRect { get }
    static var null: CGRect { get }
    static var infinite: CGRect { get }
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    init(x x: Double, y y: Double, width width: Double, height height: Double)
    init(x x: Int, y y: Int, width width: Int, height height: Int)
    var width: CGFloat { get }
    var height: CGFloat { get }
    var minX: CGFloat { get }
    var midX: CGFloat { get }
    var maxX: CGFloat { get }
    var minY: CGFloat { get }
    var midY: CGFloat { get }
    var maxY: CGFloat { get }
    var isNull: Bool { get }
    var isEmpty: Bool { get }
    var isInfinite: Bool { get }
    var standardized: CGRect { get }
    var integral: CGRect { get }
    mutating func standardizeInPlace()
    mutating func makeIntegralInPlace()
    @warn_unused_result(mutable_variant="insetInPlace")
    func insetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    mutating func insetInPlace(dx dx: CGFloat, dy dy: CGFloat)
    @warn_unused_result(mutable_variant="offsetInPlace")
    func offsetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    mutating func offsetInPlace(dx dx: CGFloat, dy dy: CGFloat)
    @warn_unused_result(mutable_variant="unionInPlace")
    func union(_ rect: CGRect) -> CGRect
    mutating func unionInPlace(_ rect: CGRect)
    @warn_unused_result(mutable_variant="intersectInPlace")
    func intersect(_ rect: CGRect) -> CGRect
    mutating func intersectInPlace(_ rect: CGRect)
    @warn_unused_result
    func divide(_ atDistance: CGFloat, fromEdge fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
    @warn_unused_result
    func contains(_ rect: CGRect) -> Bool
    @warn_unused_result
    func contains(_ point: CGPoint) -> Bool
    @warn_unused_result
    func intersects(_ rect: CGRect) -> Bool
    static var zeroRect: CGRect { get }
    static var infiniteRect: CGRect { get }
    static var nullRect: CGRect { get }
    var standardizedRect: CGRect { get }
    var integerRect: CGRect { get }
    mutating func standardize() -> CGRect
    mutating func integerize()
    func rectByInsetting(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func inset(dx dx: CGFloat, dy dy: CGFloat)
    func rectByOffsetting(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func offset(dx dx: CGFloat, dy dy: CGFloat)
    mutating func union(_ withRect: CGRect)
    func rectByUnion(_ withRect: CGRect) -> CGRect
    mutating func intersect(_ withRect: CGRect)
    func rectByIntersecting(_ withRect: CGRect) -> CGRect
    func rectsByDividing(_ atDistance: CGFloat, fromEdge fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
}
extension CGRect : Equatable {
}
extension CGRect : _Reflectable {
}
extension CGRect {
    static var zero: CGRect { get }
    static var null: CGRect { get }
    static var infinite: CGRect { get }
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    init(x x: Double, y y: Double, width width: Double, height height: Double)
    init(x x: Int, y y: Int, width width: Int, height height: Int)
    var width: CGFloat { get }
    var height: CGFloat { get }
    var minX: CGFloat { get }
    var midX: CGFloat { get }
    var maxX: CGFloat { get }
    var minY: CGFloat { get }
    var midY: CGFloat { get }
    var maxY: CGFloat { get }
    var isNull: Bool { get }
    var isEmpty: Bool { get }
    var isInfinite: Bool { get }
    var standardized: CGRect { get }
    var integral: CGRect { get }
    mutating func standardizeInPlace()
    mutating func makeIntegralInPlace()
    @warn_unused_result(mutable_variant="insetInPlace")
    func insetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    mutating func insetInPlace(dx dx: CGFloat, dy dy: CGFloat)
    @warn_unused_result(mutable_variant="offsetInPlace")
    func offsetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    mutating func offsetInPlace(dx dx: CGFloat, dy dy: CGFloat)
    @warn_unused_result(mutable_variant="unionInPlace")
    func union(_ rect: CGRect) -> CGRect
    mutating func unionInPlace(_ rect: CGRect)
    @warn_unused_result(mutable_variant="intersectInPlace")
    func intersect(_ rect: CGRect) -> CGRect
    mutating func intersectInPlace(_ rect: CGRect)
    @warn_unused_result
    func divide(_ atDistance: CGFloat, fromEdge fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
    @warn_unused_result
    func contains(_ rect: CGRect) -> Bool
    @warn_unused_result
    func contains(_ point: CGPoint) -> Bool
    @warn_unused_result
    func intersects(_ rect: CGRect) -> Bool
    static var zeroRect: CGRect { get }
    static var infiniteRect: CGRect { get }
    static var nullRect: CGRect { get }
    var standardizedRect: CGRect { get }
    var integerRect: CGRect { get }
    mutating func standardize() -> CGRect
    mutating func integerize()
    func rectByInsetting(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func inset(dx dx: CGFloat, dy dy: CGFloat)
    func rectByOffsetting(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func offset(dx dx: CGFloat, dy dy: CGFloat)
    mutating func union(_ withRect: CGRect)
    func rectByUnion(_ withRect: CGRect) -> CGRect
    mutating func intersect(_ withRect: CGRect)
    func rectByIntersecting(_ withRect: CGRect) -> CGRect
    func rectsByDividing(_ atDistance: CGFloat, fromEdge fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
}
extension CGRect : Equatable {
}
extension CGRect : _Reflectable {
}
Equatable
To
struct CGRect {
    var origin: CGPoint
    var size: CGSize
    init()
    init(origin origin: CGPoint, size size: CGSize)
    func applying(_ t: CGAffineTransform) -> CGRect
    static let zero: CGRect
    static let null: CGRect
    static let infinite: CGRect
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    var minX: CGFloat { get }
    var midX: CGFloat { get }
    var maxX: CGFloat { get }
    var minY: CGFloat { get }
    var midY: CGFloat { get }
    var maxY: CGFloat { get }
    var width: CGFloat { get }
    var height: CGFloat { get }
    func equalTo(_ rect2: CGRect) -> Bool
    var standardized: CGRect { get }
    var isEmpty: Bool { get }
    var isNull: Bool { get }
    var isInfinite: Bool { get }
    func insetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    var integral: CGRect { get }
    func union(_ r2: CGRect) -> CGRect
    func intersection(_ r2: CGRect) -> CGRect
    func offsetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func __divided(slice slice: UnsafeMutablePointer<CGRect>, remainder remainder: UnsafeMutablePointer<CGRect>, atDistance amount: CGFloat, from edge: CGRectEdge)
    func contains(_ point: CGPoint) -> Bool
    func contains(_ rect2: CGRect) -> Bool
    func intersects(_ rect2: CGRect) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ rect: UnsafeMutablePointer<CGRect>) -> Bool
    static var zero: CGRect { get }
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    init(x x: Double, y y: Double, width width: Double, height height: Double)
    init(x x: Int, y y: Int, width width: Int, height height: Int)
    init?(dictionaryRepresentation dict: CFDictionary)
    func divided(atDistance atDistance: CGFloat, from fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
}
extension CGRect {
    func applying(_ t: CGAffineTransform) -> CGRect
}
extension CGRect : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGRect : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGRect {
    static let zero: CGRect
    static let null: CGRect
    static let infinite: CGRect
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    var minX: CGFloat { get }
    var midX: CGFloat { get }
    var maxX: CGFloat { get }
    var minY: CGFloat { get }
    var midY: CGFloat { get }
    var maxY: CGFloat { get }
    var width: CGFloat { get }
    var height: CGFloat { get }
    func equalTo(_ rect2: CGRect) -> Bool
    var standardized: CGRect { get }
    var isEmpty: Bool { get }
    var isNull: Bool { get }
    var isInfinite: Bool { get }
    func insetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    var integral: CGRect { get }
    func union(_ r2: CGRect) -> CGRect
    func intersection(_ r2: CGRect) -> CGRect
    func offsetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect
    func __divided(slice slice: UnsafeMutablePointer<CGRect>, remainder remainder: UnsafeMutablePointer<CGRect>, atDistance amount: CGFloat, from edge: CGRectEdge)
    func contains(_ point: CGPoint) -> Bool
    func contains(_ rect2: CGRect) -> Bool
    func intersects(_ rect2: CGRect) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ rect: UnsafeMutablePointer<CGRect>) -> Bool
}
extension CGRect : Equatable {
}
extension CGRect : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGRect : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGRect {
    static var zero: CGRect { get }
    init(x x: CGFloat, y y: CGFloat, width width: CGFloat, height height: CGFloat)
    init(x x: Double, y y: Double, width width: Double, height height: Double)
    init(x x: Int, y y: Int, width width: Int, height height: Int)
    init?(dictionaryRepresentation dict: CFDictionary)
    func divided(atDistance atDistance: CGFloat, from fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect)
}
CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Equatable

NameDeclaration
FromCGRectApplyAffineTransform(_:_:)
func CGRectApplyAffineTransform(_ rect: CGRect, _ t: CGAffineTransform) -> CGRect
Toapplying(_:)
func applying(_ t: CGAffineTransform) -> CGRect

NameDeclaration
FromCGRectContainsPoint(_:_:)
func CGRectContainsPoint(_ rect: CGRect, _ point: CGPoint) -> Bool
Tocontains(_:)
func contains(_ point: CGPoint) -> Bool

NameDeclaration
FromCGRectContainsRect(_:_:)
func CGRectContainsRect(_ rect1: CGRect, _ rect2: CGRect) -> Bool
Tocontains(_:)
func contains(_ rect2: CGRect) -> Bool

NameDeclarationReadonly
FromCGRectCreateDictionaryRepresentation(_:)
func CGRectCreateDictionaryRepresentation(_ _: CGRect) -> CFDictionary
--
TodictionaryRepresentation
var dictionaryRepresentation: CFDictionary { get }
yes

NameDeclaration
FromCGRectEqualToRect(_:_:)
func CGRectEqualToRect(_ rect1: CGRect, _ rect2: CGRect) -> Bool
ToequalTo(_:)
func equalTo(_ rect2: CGRect) -> Bool

NameDeclarationReadonly
FromCGRectGetHeight(_:)
func CGRectGetHeight(_ rect: CGRect) -> CGFloat
--
Toheight
var height: CGFloat { get }
yes

NameDeclaration
FromCGRectInfinite
let CGRectInfinite: CGRect
Toinfinite
static let infinite: CGRect

NameDeclaration
FromCGRectInset(_:_:_:)
func CGRectInset(_ rect: CGRect, _ dx: CGFloat, _ dy: CGFloat) -> CGRect
ToinsetBy(dx:dy:)
func insetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect

NameDeclarationReadonly
FromCGRectIntegral(_:)
func CGRectIntegral(_ rect: CGRect) -> CGRect
--
Tointegral
var integral: CGRect { get }
yes

NameDeclaration
FromCGRectIntersection(_:_:)
func CGRectIntersection(_ r1: CGRect, _ r2: CGRect) -> CGRect
Tointersection(_:)
func intersection(_ r2: CGRect) -> CGRect

NameDeclaration
FromCGRectIntersectsRect(_:_:)
func CGRectIntersectsRect(_ rect1: CGRect, _ rect2: CGRect) -> Bool
Tointersects(_:)
func intersects(_ rect2: CGRect) -> Bool

NameDeclarationReadonly
FromCGRectIsEmpty(_:)
func CGRectIsEmpty(_ rect: CGRect) -> Bool
--
ToisEmpty
var isEmpty: Bool { get }
yes

NameDeclarationReadonly
FromCGRectIsInfinite(_:)
func CGRectIsInfinite(_ rect: CGRect) -> Bool
--
ToisInfinite
var isInfinite: Bool { get }
yes

NameDeclarationReadonly
FromCGRectIsNull(_:)
func CGRectIsNull(_ rect: CGRect) -> Bool
--
ToisNull
var isNull: Bool { get }
yes

NameDeclarationReadonly
FromCGRectGetMaxX(_:)
func CGRectGetMaxX(_ rect: CGRect) -> CGFloat
--
TomaxX
var maxX: CGFloat { get }
yes

NameDeclarationReadonly
FromCGRectGetMaxY(_:)
func CGRectGetMaxY(_ rect: CGRect) -> CGFloat
--
TomaxY
var maxY: CGFloat { get }
yes

NameDeclarationReadonly
FromCGRectGetMidX(_:)
func CGRectGetMidX(_ rect: CGRect) -> CGFloat
--
TomidX
var midX: CGFloat { get }
yes

NameDeclarationReadonly
FromCGRectGetMidY(_:)
func CGRectGetMidY(_ rect: CGRect) -> CGFloat
--
TomidY
var midY: CGFloat { get }
yes

NameDeclarationReadonly
FromCGRectGetMinX(_:)
func CGRectGetMinX(_ rect: CGRect) -> CGFloat
--
TominX
var minX: CGFloat { get }
yes

NameDeclarationReadonly
FromCGRectGetMinY(_:)
func CGRectGetMinY(_ rect: CGRect) -> CGFloat
--
TominY
var minY: CGFloat { get }
yes

Modified CGRect.null
NameDeclaration
FromCGRectNull
let CGRectNull: CGRect
Tonull
static let null: CGRect

NameDeclaration
FromCGRectOffset(_:_:_:)
func CGRectOffset(_ rect: CGRect, _ dx: CGFloat, _ dy: CGFloat) -> CGRect
TooffsetBy(dx:dy:)
func offsetBy(dx dx: CGFloat, dy dy: CGFloat) -> CGRect

NameDeclarationReadonly
FromCGRectStandardize(_:)
func CGRectStandardize(_ rect: CGRect) -> CGRect
--
Tostandardized
var standardized: CGRect { get }
yes

NameDeclaration
FromCGRectUnion(_:_:)
func CGRectUnion(_ r1: CGRect, _ r2: CGRect) -> CGRect
Tounion(_:)
func union(_ r2: CGRect) -> CGRect

NameDeclarationReadonly
FromCGRectGetWidth(_:)
func CGRectGetWidth(_ rect: CGRect) -> CGFloat
--
Towidth
var width: CGFloat { get }
yes

Declaration
From
enum CGRectEdge : UInt32 {
    case MinXEdge
    case MinYEdge
    case MaxXEdge
    case MaxYEdge
}
To
enum CGRectEdge : UInt32 {
    case minXEdge
    case minYEdge
    case maxXEdge
    case maxYEdge
}

Declaration
From
case MaxXEdge
To
case maxXEdge

Declaration
From
case MaxYEdge
To
case maxYEdge

Declaration
From
case MinXEdge
To
case minXEdge

Declaration
From
case MinYEdge
To
case minYEdge

Modified CGShading
Declaration
From
class CGShading {
}
To
class CGShading {
    class var typeID: CFTypeID { get }
    init?(axialSpace space: CGColorSpace, start start: CGPoint, end end: CGPoint, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)
    init?(radialSpace space: CGColorSpace, start start: CGPoint, startRadius startRadius: CGFloat, end end: CGPoint, endRadius endRadius: CGFloat, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)
}
extension CGShading {
    class var typeID: CFTypeID { get }
    init?(axialSpace space: CGColorSpace, start start: CGPoint, end end: CGPoint, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)
    init?(radialSpace space: CGColorSpace, start start: CGPoint, startRadius startRadius: CGFloat, end end: CGPoint, endRadius endRadius: CGFloat, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)
}

NameDeclaration
FromCGShadingCreateAxial(_:_:_:_:_:_:)
func CGShadingCreateAxial(_ space: CGColorSpace?, _ start: CGPoint, _ end: CGPoint, _ function: CGFunction?, _ extendStart: Bool, _ extendEnd: Bool) -> CGShading?
Toinit(axialSpace:start:end:function:extendStart:extendEnd:)
init?(axialSpace space: CGColorSpace, start start: CGPoint, end end: CGPoint, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)

NameDeclaration
FromCGShadingCreateRadial(_:_:_:_:_:_:_:_:)
func CGShadingCreateRadial(_ space: CGColorSpace?, _ start: CGPoint, _ startRadius: CGFloat, _ end: CGPoint, _ endRadius: CGFloat, _ function: CGFunction?, _ extendStart: Bool, _ extendEnd: Bool) -> CGShading?
Toinit(radialSpace:start:startRadius:end:endRadius:function:extendStart:extendEnd:)
init?(radialSpace space: CGColorSpace, start start: CGPoint, startRadius startRadius: CGFloat, end end: CGPoint, endRadius endRadius: CGFloat, function function: CGFunction, extendStart extendStart: Bool, extendEnd extendEnd: Bool)

NameDeclaration
FromCGShadingGetTypeID()
func CGShadingGetTypeID() -> CFTypeID
TotypeID
class var typeID: CFTypeID { get }

DeclarationProtocols
From
struct CGSize {
    var width: CGFloat
    var height: CGFloat
    init()
    init(width width: CGFloat, height height: CGFloat)
}
extension CGSize {
    static var zero: CGSize { get }
    init(width width: Int, height height: Int)
    init(width width: Double, height height: Double)
    static var zeroSize: CGSize { get }
}
extension CGSize : Equatable {
}
extension CGSize : _Reflectable {
}
extension CGSize : _Reflectable {
}
extension CGSize : Equatable {
}
extension CGSize {
    static var zero: CGSize { get }
    init(width width: Int, height height: Int)
    init(width width: Double, height height: Double)
    static var zeroSize: CGSize { get }
}
Equatable
To
struct CGSize {
    var width: CGFloat
    var height: CGFloat
    init()
    init(width width: CGFloat, height height: CGFloat)
    func applying(_ t: CGAffineTransform) -> CGSize
    static let zero: CGSize
    init(width width: CGFloat, height height: CGFloat)
    func equalTo(_ size2: CGSize) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ size: UnsafeMutablePointer<CGSize>) -> Bool
    static var zero: CGSize { get }
    init(width width: Int, height height: Int)
    init(width width: Double, height height: Double)
    init?(dictionaryRepresentation dict: CFDictionary)
}
extension CGSize {
    func applying(_ t: CGAffineTransform) -> CGSize
}
extension CGSize : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGSize : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGSize {
    static let zero: CGSize
    init(width width: CGFloat, height height: CGFloat)
    func equalTo(_ size2: CGSize) -> Bool
    var dictionaryRepresentation: CFDictionary { get }
    static func __setFromDictionaryRepresentation(_ dict: CFDictionary, _ size: UnsafeMutablePointer<CGSize>) -> Bool
}
extension CGSize : Equatable {
}
extension CGSize : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension CGSize : CustomReflectable, CustomPlaygroundQuickLookable {
    var customMirror: Mirror { get }
    var customPlaygroundQuickLook: PlaygroundQuickLook { get }
}
extension CGSize {
    static var zero: CGSize { get }
    init(width width: Int, height height: Int)
    init(width width: Double, height height: Double)
    init?(dictionaryRepresentation dict: CFDictionary)
}
CustomDebugStringConvertible, CustomPlaygroundQuickLookable, CustomReflectable, Equatable

NameDeclaration
FromCGSizeApplyAffineTransform(_:_:)
func CGSizeApplyAffineTransform(_ size: CGSize, _ t: CGAffineTransform) -> CGSize
Toapplying(_:)
func applying(_ t: CGAffineTransform) -> CGSize

NameDeclarationReadonly
FromCGSizeCreateDictionaryRepresentation(_:)
func CGSizeCreateDictionaryRepresentation(_ size: CGSize) -> CFDictionary
--
TodictionaryRepresentation
var dictionaryRepresentation: CFDictionary { get }
yes

NameDeclaration
FromCGSizeEqualToSize(_:_:)
func CGSizeEqualToSize(_ size1: CGSize, _ size2: CGSize) -> Bool
ToequalTo(_:)
func equalTo(_ size2: CGSize) -> Bool

Declaration
From
enum CGTextDrawingMode : Int32 {
    case Fill
    case Stroke
    case FillStroke
    case Invisible
    case FillClip
    case StrokeClip
    case FillStrokeClip
    case Clip
}
To
enum CGTextDrawingMode : Int32 {
    case fill
    case stroke
    case fillStroke
    case invisible
    case fillClip
    case strokeClip
    case fillStrokeClip
    case clip
}

Declaration
From
case Clip
To
case clip

Declaration
From
case Fill
To
case fill

Declaration
From
case FillClip
To
case fillClip

Declaration
From
case FillStroke
To
case fillStroke

Declaration
From
case FillStrokeClip
To
case fillStrokeClip

Declaration
From
case Invisible
To
case invisible

Declaration
From
case Stroke
To
case stroke

Declaration
From
case StrokeClip
To
case strokeClip

Declaration
From
struct CGVector {
    var dx: CGFloat
    var dy: CGFloat
    init()
    init(dx dx: CGFloat, dy dy: CGFloat)
}
extension CGVector {
    static var zero: CGVector { get }
    init(dx dx: Int, dy dy: Int)
    init(dx dx: Double, dy dy: Double)
    static var zeroVector: CGVector { get }
}
extension CGVector : Equatable {
}
extension CGVector : Equatable {
}
extension CGVector {
    static var zero: CGVector { get }
    init(dx dx: Int, dy dy: Int)
    init(dx dx: Double, dy dy: Double)
    static var zeroVector: CGVector { get }
}
To
struct CGVector {
    var dx: CGFloat
    var dy: CGFloat
    init()
    init(dx dx: CGFloat, dy dy: CGFloat)
    init(dx dx: CGFloat, dy dy: CGFloat)
    static var zero: CGVector { get }
    init(dx dx: Int, dy dy: Int)
    init(dx dx: Double, dy dy: Double)
}
extension CGVector {
    init(dx dx: CGFloat, dy dy: CGFloat)
}
extension CGVector : Equatable {
}
extension CGVector {
    static var zero: CGVector { get }
    init(dx dx: Int, dy dy: Int)
    init(dx dx: Double, dy dy: Double)
}

Modified *(_: CGFloat, _: CGFloat) -> CGFloat
Declaration
From
@warn_unused_result
func *(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func *(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Modified *=(_: CGFloat, _: CGFloat)
Declaration
From
func *=(inout _ lhs: CGFloat, _ rhs: CGFloat)
To
func *=(_ lhs: inout CGFloat, _ rhs: CGFloat)

Modified +(_: CGFloat, _: CGFloat) -> CGFloat
Declaration
From
@warn_unused_result
func +(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func +(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Modified +=(_: CGFloat, _: CGFloat)
Declaration
From
func +=(inout _ lhs: CGFloat, _ rhs: CGFloat)
To
func +=(_ lhs: inout CGFloat, _ rhs: CGFloat)

Modified -(_: CGFloat, _: CGFloat) -> CGFloat
Declaration
From
@warn_unused_result
func -(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func -(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Modified -=(_: CGFloat, _: CGFloat)
Declaration
From
func -=(inout _ lhs: CGFloat, _ rhs: CGFloat)
To
func -=(_ lhs: inout CGFloat, _ rhs: CGFloat)

Modified /(_: CGFloat, _: CGFloat) -> CGFloat
Declaration
From
@warn_unused_result
func /(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func /(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Modified /=(_: CGFloat, _: CGFloat)
Declaration
From
func /=(inout _ lhs: CGFloat, _ rhs: CGFloat)
To
func /=(_ lhs: inout CGFloat, _ rhs: CGFloat)

Modified ==(_: CGRect, _: CGRect) -> Bool
Declaration
From
@warn_unused_result
func ==(_ lhs: CGRect, _ rhs: CGRect) -> Bool
To
func ==(_ lhs: CGRect, _ rhs: CGRect) -> Bool

Modified ==(_: CGSize, _: CGSize) -> Bool
Declaration
From
@warn_unused_result
func ==(_ lhs: CGSize, _ rhs: CGSize) -> Bool
To
func ==(_ lhs: CGSize, _ rhs: CGSize) -> Bool

Modified ==(_: CGPoint, _: CGPoint) -> Bool
Declaration
From
@warn_unused_result
func ==(_ lhs: CGPoint, _ rhs: CGPoint) -> Bool
To
func ==(_ lhs: CGPoint, _ rhs: CGPoint) -> Bool

Modified ==(_: CGVector, _: CGVector) -> Bool
Declaration
From
@warn_unused_result
func ==(_ lhs: CGVector, _ rhs: CGVector) -> Bool
To
func ==(_ lhs: CGVector, _ rhs: CGVector) -> Bool

Declaration
From
@warn_unused_result
func acos(_ x: CGFloat) -> CGFloat
To
func acos(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func acosh(_ x: CGFloat) -> CGFloat
To
func acosh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func asin(_ x: CGFloat) -> CGFloat
To
func asin(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func asinh(_ x: CGFloat) -> CGFloat
To
func asinh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func atan(_ x: CGFloat) -> CGFloat
To
func atan(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func atan2(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func atan2(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func atanh(_ x: CGFloat) -> CGFloat
To
func atanh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func cbrt(_ x: CGFloat) -> CGFloat
To
func cbrt(_ x: CGFloat) -> CGFloat

Declaration
From
typealias CGBitmapContextReleaseDataCallback = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>) -> Void
To
typealias CGBitmapContextReleaseDataCallback = (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
func CGColorSpaceCreateDeviceCMYK() -> CGColorSpace?
To
func CGColorSpaceCreateDeviceCMYK() -> CGColorSpace

Declaration
From
func CGColorSpaceCreateDeviceGray() -> CGColorSpace?
To
func CGColorSpaceCreateDeviceGray() -> CGColorSpace

Declaration
From
func CGColorSpaceCreateDeviceRGB() -> CGColorSpace?
To
func CGColorSpaceCreateDeviceRGB() -> CGColorSpace

Declaration
From
typealias CGDataConsumerPutBytesCallback = (UnsafeMutablePointer<Void>, UnsafePointer<Void>, Int) -> Int
To
typealias CGDataConsumerPutBytesCallback = (UnsafeMutableRawPointer?, UnsafeRawPointer, Int) -> Int

Declaration
From
typealias CGDataConsumerReleaseInfoCallback = (UnsafeMutablePointer<Void>) -> Void
To
typealias CGDataConsumerReleaseInfoCallback = (UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
typealias CGDataProviderGetBytePointerCallback = (UnsafeMutablePointer<Void>) -> UnsafePointer<Void>
To
typealias CGDataProviderGetBytePointerCallback = (UnsafeMutableRawPointer?) -> UnsafeRawPointer?

Declaration
From
typealias CGDataProviderGetBytesAtPositionCallback = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, off_t, Int) -> Int
To
typealias CGDataProviderGetBytesAtPositionCallback = (UnsafeMutableRawPointer?, UnsafeMutableRawPointer, off_t, Int) -> Int

Declaration
From
typealias CGDataProviderGetBytesCallback = (UnsafeMutablePointer<Void>, UnsafeMutablePointer<Void>, Int) -> Int
To
typealias CGDataProviderGetBytesCallback = (UnsafeMutableRawPointer?, UnsafeMutableRawPointer, Int) -> Int

Declaration
From
typealias CGDataProviderReleaseBytePointerCallback = (UnsafeMutablePointer<Void>, UnsafePointer<Void>) -> Void
To
typealias CGDataProviderReleaseBytePointerCallback = (UnsafeMutableRawPointer?, UnsafeRawPointer) -> Swift.Void

Declaration
From
typealias CGDataProviderReleaseDataCallback = (UnsafeMutablePointer<Void>, UnsafePointer<Void>, Int) -> Void
To
typealias CGDataProviderReleaseDataCallback = (UnsafeMutableRawPointer?, UnsafeRawPointer, Int) -> Swift.Void

Declaration
From
typealias CGDataProviderReleaseInfoCallback = (UnsafeMutablePointer<Void>) -> Void
To
typealias CGDataProviderReleaseInfoCallback = (UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
typealias CGDataProviderRewindCallback = (UnsafeMutablePointer<Void>) -> Void
To
typealias CGDataProviderRewindCallback = (UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
typealias CGDataProviderSkipForwardCallback = (UnsafeMutablePointer<Void>, off_t) -> off_t
To
typealias CGDataProviderSkipForwardCallback = (UnsafeMutableRawPointer?, off_t) -> off_t

Declaration
From
typealias NativeType = Float
To
typealias NativeType = Double

Modified CGFLOAT_MAX
Declaration
From
var CGFLOAT_MAX: Float { get }
To
var CGFLOAT_MAX: Double { get }

Modified CGFLOAT_MIN
Declaration
From
var CGFLOAT_MIN: Float { get }
To
var CGFLOAT_MIN: Double { get }

Declaration
From
typealias CGFunctionEvaluateCallback = (UnsafeMutablePointer<Void>, UnsafePointer<CGFloat>, UnsafeMutablePointer<CGFloat>) -> Void
To
typealias CGFunctionEvaluateCallback = (UnsafeMutableRawPointer?, UnsafePointer<CGFloat>, UnsafeMutablePointer<CGFloat>) -> Swift.Void

Declaration
From
typealias CGFunctionReleaseInfoCallback = (UnsafeMutablePointer<Void>) -> Void
To
typealias CGFunctionReleaseInfoCallback = (UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
typealias CGPathApplierFunction = (UnsafeMutablePointer<Void>, UnsafePointer<CGPathElement>) -> Void
To
typealias CGPathApplierFunction = (UnsafeMutableRawPointer?, UnsafePointer<CGPathElement>) -> Swift.Void

Declaration
From
typealias CGPatternDrawPatternCallback = (UnsafeMutablePointer<Void>, CGContext?) -> Void
To
typealias CGPatternDrawPatternCallback = (UnsafeMutableRawPointer?, CGContext) -> Swift.Void

Declaration
From
typealias CGPatternReleaseInfoCallback = (UnsafeMutablePointer<Void>) -> Void
To
typealias CGPatternReleaseInfoCallback = (UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
func CGPDFArrayGetArray(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFArrayRef>) -> Bool
To
func CGPDFArrayGetArray(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFArrayRef?>?) -> Bool

Declaration
From
func CGPDFArrayGetBoolean(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFBoolean>) -> Bool
To
func CGPDFArrayGetBoolean(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFBoolean>?) -> Bool

Declaration
From
func CGPDFArrayGetDictionary(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFDictionaryRef>) -> Bool
To
func CGPDFArrayGetDictionary(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFDictionaryRef?>?) -> Bool

Declaration
From
func CGPDFArrayGetInteger(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFInteger>) -> Bool
To
func CGPDFArrayGetInteger(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFInteger>?) -> Bool

Declaration
From
func CGPDFArrayGetName(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<UnsafePointer<Int8>>) -> Bool
To
func CGPDFArrayGetName(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<UnsafePointer<Int8>?>?) -> Bool

Declaration
From
func CGPDFArrayGetNumber(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFReal>) -> Bool
To
func CGPDFArrayGetNumber(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFReal>?) -> Bool

Declaration
From
func CGPDFArrayGetObject(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFObjectRef>) -> Bool
To
func CGPDFArrayGetObject(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFObjectRef?>?) -> Bool

Declaration
From
func CGPDFArrayGetStream(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFStreamRef>) -> Bool
To
func CGPDFArrayGetStream(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFStreamRef?>?) -> Bool

Declaration
From
func CGPDFArrayGetString(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFStringRef>) -> Bool
To
func CGPDFArrayGetString(_ array: CGPDFArrayRef, _ index: Int, _ value: UnsafeMutablePointer<CGPDFStringRef?>?) -> Bool

Modified CGPDFArrayRef
Declaration
From
typealias CGPDFArrayRef = COpaquePointer
To
typealias CGPDFArrayRef = OpaquePointer

Declaration
From
func CGPDFContentStreamCreateWithPage(_ page: CGPDFPage!) -> CGPDFContentStreamRef
To
func CGPDFContentStreamCreateWithPage(_ page: CGPDFPage) -> CGPDFContentStreamRef

Declaration
From
func CGPDFContentStreamGetResource(_ cs: CGPDFContentStreamRef, _ category: UnsafePointer<Int8>, _ name: UnsafePointer<Int8>) -> CGPDFObjectRef
To
func CGPDFContentStreamGetResource(_ cs: CGPDFContentStreamRef, _ category: UnsafePointer<Int8>, _ name: UnsafePointer<Int8>) -> CGPDFObjectRef?

Declaration
From
func CGPDFContentStreamGetStreams(_ cs: CGPDFContentStreamRef) -> CFArray!
To
func CGPDFContentStreamGetStreams(_ cs: CGPDFContentStreamRef) -> CFArray?

Declaration
From
typealias CGPDFContentStreamRef = COpaquePointer
To
typealias CGPDFContentStreamRef = OpaquePointer

Declaration
From
typealias CGPDFDictionaryApplierFunction = (UnsafePointer<Int8>, CGPDFObjectRef, UnsafeMutablePointer<Void>) -> Void
To
typealias CGPDFDictionaryApplierFunction = (UnsafePointer<Int8>, CGPDFObjectRef, UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
func CGPDFDictionaryApplyFunction(_ dict: CGPDFDictionaryRef, _ function: CGPDFDictionaryApplierFunction?, _ info: UnsafeMutablePointer<Void>)
To
func CGPDFDictionaryApplyFunction(_ dict: CGPDFDictionaryRef, _ function: CoreGraphics.CGPDFDictionaryApplierFunction, _ info: UnsafeMutableRawPointer?)

Declaration
From
func CGPDFDictionaryGetArray(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFArrayRef>) -> Bool
To
func CGPDFDictionaryGetArray(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFArrayRef?>?) -> Bool

Declaration
From
func CGPDFDictionaryGetBoolean(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFBoolean>) -> Bool
To
func CGPDFDictionaryGetBoolean(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFBoolean>?) -> Bool

Declaration
From
func CGPDFDictionaryGetDictionary(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFDictionaryRef>) -> Bool
To
func CGPDFDictionaryGetDictionary(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFDictionaryRef?>?) -> Bool

Declaration
From
func CGPDFDictionaryGetInteger(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFInteger>) -> Bool
To
func CGPDFDictionaryGetInteger(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFInteger>?) -> Bool

Declaration
From
func CGPDFDictionaryGetName(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<UnsafePointer<Int8>>) -> Bool
To
func CGPDFDictionaryGetName(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<UnsafePointer<Int8>?>?) -> Bool

Declaration
From
func CGPDFDictionaryGetNumber(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFReal>) -> Bool
To
func CGPDFDictionaryGetNumber(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFReal>?) -> Bool

Declaration
From
func CGPDFDictionaryGetObject(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFObjectRef>) -> Bool
To
func CGPDFDictionaryGetObject(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFObjectRef?>?) -> Bool

Declaration
From
func CGPDFDictionaryGetStream(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFStreamRef>) -> Bool
To
func CGPDFDictionaryGetStream(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFStreamRef?>?) -> Bool

Declaration
From
func CGPDFDictionaryGetString(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFStringRef>) -> Bool
To
func CGPDFDictionaryGetString(_ dict: CGPDFDictionaryRef, _ key: UnsafePointer<Int8>, _ value: UnsafeMutablePointer<CGPDFStringRef?>?) -> Bool

Declaration
From
typealias CGPDFDictionaryRef = COpaquePointer
To
typealias CGPDFDictionaryRef = OpaquePointer

Declaration
From
func CGPDFObjectGetValue(_ object: CGPDFObjectRef, _ type: CGPDFObjectType, _ value: UnsafeMutablePointer<Void>) -> Bool
To
func CGPDFObjectGetValue(_ object: CGPDFObjectRef, _ type: CGPDFObjectType, _ value: UnsafeMutableRawPointer?) -> Bool

Declaration
From
typealias CGPDFObjectRef = COpaquePointer
To
typealias CGPDFObjectRef = OpaquePointer

Declaration
From
typealias CGPDFOperatorCallback = (CGPDFScannerRef, UnsafeMutablePointer<Void>) -> Void
To
typealias CGPDFOperatorCallback = (CGPDFScannerRef, UnsafeMutableRawPointer?) -> Swift.Void

Declaration
From
func CGPDFOperatorTableCreate() -> CGPDFOperatorTableRef
To
func CGPDFOperatorTableCreate() -> CGPDFOperatorTableRef?

Declaration
From
typealias CGPDFOperatorTableRef = COpaquePointer
To
typealias CGPDFOperatorTableRef = OpaquePointer

Declaration
From
func CGPDFOperatorTableSetCallback(_ table: CGPDFOperatorTableRef, _ name: UnsafePointer<Int8>, _ callback: CGPDFOperatorCallback?)
To
func CGPDFOperatorTableSetCallback(_ table: CGPDFOperatorTableRef, _ name: UnsafePointer<Int8>, _ callback: CoreGraphics.CGPDFOperatorCallback)

Declaration
From
func CGPDFScannerCreate(_ cs: CGPDFContentStreamRef, _ table: CGPDFOperatorTableRef, _ info: UnsafeMutablePointer<Void>) -> CGPDFScannerRef
To
func CGPDFScannerCreate(_ cs: CGPDFContentStreamRef, _ table: CGPDFOperatorTableRef?, _ info: UnsafeMutableRawPointer?) -> CGPDFScannerRef

Declaration
From
func CGPDFScannerPopArray(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFArrayRef>) -> Bool
To
func CGPDFScannerPopArray(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFArrayRef?>?) -> Bool

Declaration
From
func CGPDFScannerPopBoolean(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFBoolean>) -> Bool
To
func CGPDFScannerPopBoolean(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFBoolean>?) -> Bool

Declaration
From
func CGPDFScannerPopDictionary(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFDictionaryRef>) -> Bool
To
func CGPDFScannerPopDictionary(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFDictionaryRef?>?) -> Bool

Declaration
From
func CGPDFScannerPopInteger(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFInteger>) -> Bool
To
func CGPDFScannerPopInteger(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFInteger>?) -> Bool

Declaration
From
func CGPDFScannerPopName(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<UnsafePointer<Int8>>) -> Bool
To
func CGPDFScannerPopName(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<UnsafePointer<Int8>?>?) -> Bool

Declaration
From
func CGPDFScannerPopNumber(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFReal>) -> Bool
To
func CGPDFScannerPopNumber(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFReal>?) -> Bool

Declaration
From
func CGPDFScannerPopObject(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFObjectRef>) -> Bool
To
func CGPDFScannerPopObject(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFObjectRef?>?) -> Bool

Declaration
From
func CGPDFScannerPopStream(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFStreamRef>) -> Bool
To
func CGPDFScannerPopStream(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFStreamRef?>?) -> Bool

Declaration
From
func CGPDFScannerPopString(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFStringRef>) -> Bool
To
func CGPDFScannerPopString(_ scanner: CGPDFScannerRef, _ value: UnsafeMutablePointer<CGPDFStringRef?>?) -> Bool

Declaration
From
typealias CGPDFScannerRef = COpaquePointer
To
typealias CGPDFScannerRef = OpaquePointer

Declaration
From
func CGPDFStreamGetDictionary(_ stream: CGPDFStreamRef) -> CGPDFDictionaryRef
To
func CGPDFStreamGetDictionary(_ stream: CGPDFStreamRef) -> CGPDFDictionaryRef?

Declaration
From
typealias CGPDFStreamRef = COpaquePointer
To
typealias CGPDFStreamRef = OpaquePointer

Declaration
From
func CGPDFStringGetBytePtr(_ string: CGPDFStringRef) -> UnsafePointer<UInt8>
To
func CGPDFStringGetBytePtr(_ string: CGPDFStringRef) -> UnsafePointer<UInt8>?

Declaration
From
typealias CGPDFStringRef = COpaquePointer
To
typealias CGPDFStringRef = OpaquePointer

Declaration
From
@warn_unused_result
func copysign(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func copysign(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func cos(_ x: CGFloat) -> CGFloat
To
func cos(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func cosh(_ x: CGFloat) -> CGFloat
To
func cosh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func erf(_ x: CGFloat) -> CGFloat
To
func erf(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func erfc(_ x: CGFloat) -> CGFloat
To
func erfc(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func exp(_ x: CGFloat) -> CGFloat
To
func exp(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func exp2(_ x: CGFloat) -> CGFloat
To
func exp2(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func expm1(_ x: CGFloat) -> CGFloat
To
func expm1(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func fdim(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func fdim(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func fmax(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func fmax(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func fmin(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func fmin(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Modified frexp(_: CGFloat) -> (CGFloat, Int)
Declaration
From
@warn_unused_result
func frexp(_ x: CGFloat) -> (CGFloat, Int)
To
func frexp(_ x: CGFloat) -> (CGFloat, Int)

Declaration
From
@warn_unused_result
func hypot(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func hypot(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func ilogb(_ x: CGFloat) -> Int
To
func ilogb(_ x: CGFloat) -> Int

Declaration
From
@warn_unused_result
func j0(_ x: CGFloat) -> CGFloat
To
func j0(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func j1(_ x: CGFloat) -> CGFloat
To
func j1(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func jn(_ n: Int, _ x: CGFloat) -> CGFloat
To
func jn(_ n: Int, _ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func ldexp(_ x: CGFloat, _ n: Int) -> CGFloat
To
func ldexp(_ x: CGFloat, _ n: Int) -> CGFloat

Declaration
From
@warn_unused_result
func lgamma(_ x: CGFloat) -> (CGFloat, Int)
To
func lgamma(_ x: CGFloat) -> (CGFloat, Int)

Declaration
From
@warn_unused_result
func log(_ x: CGFloat) -> CGFloat
To
func log(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func log10(_ x: CGFloat) -> CGFloat
To
func log10(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func log1p(_ x: CGFloat) -> CGFloat
To
func log1p(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func log2(_ x: CGFloat) -> CGFloat
To
func log2(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func logb(_ x: CGFloat) -> CGFloat
To
func logb(_ x: CGFloat) -> CGFloat

Modified modf(_: CGFloat) -> (CGFloat, CGFloat)
Declaration
From
@warn_unused_result
func modf(_ x: CGFloat) -> (CGFloat, CGFloat)
To
func modf(_ x: CGFloat) -> (CGFloat, CGFloat)

Declaration
From
@warn_unused_result
func nan(_ tag: String) -> CGFloat
To
func nan(_ tag: String) -> CGFloat

Declaration
From
@warn_unused_result
func nearbyint(_ x: CGFloat) -> CGFloat
To
func nearbyint(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func nextafter(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func nextafter(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func pow(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
To
func pow(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int)
To
func remquo(_ x: CGFloat, _ y: CGFloat) -> (CGFloat, Int)

Declaration
From
@warn_unused_result
func rint(_ x: CGFloat) -> CGFloat
To
func rint(_ x: CGFloat) -> CGFloat

Modified scalbn(_: CGFloat, _: Int) -> CGFloat
Declaration
From
@warn_unused_result
func scalbn(_ x: CGFloat, _ n: Int) -> CGFloat
To
func scalbn(_ x: CGFloat, _ n: Int) -> CGFloat

Declaration
From
@warn_unused_result
func sin(_ x: CGFloat) -> CGFloat
To
func sin(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func sinh(_ x: CGFloat) -> CGFloat
To
func sinh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func tan(_ x: CGFloat) -> CGFloat
To
func tan(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func tanh(_ x: CGFloat) -> CGFloat
To
func tanh(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func tgamma(_ x: CGFloat) -> CGFloat
To
func tgamma(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func y0(_ x: CGFloat) -> CGFloat
To
func y0(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func y1(_ x: CGFloat) -> CGFloat
To
func y1(_ x: CGFloat) -> CGFloat

Declaration
From
@warn_unused_result
func yn(_ n: Int, _ x: CGFloat) -> CGFloat
To
func yn(_ n: Int, _ x: CGFloat) -> CGFloat