Guides and Sample Code Developer
Search

CoreText Changes for Swift

CoreText

Removed KerxIndexArrayHeader.glyphCount
Removed KerxIndexArrayHeader.init(glyphCount: UInt16, kernValueCount: UInt16, leftClassCount: UInt16, rightClassCount: UInt16, flags: UInt16, kernValue: (Int16), leftClass: (UInt16), rightClass: (UInt16), kernIndex: (UInt16))
Removed KerxIndexArrayHeader.kernIndex
Removed KerxIndexArrayHeader.kernValue
Removed KerxIndexArrayHeader.kernValueCount
Removed KerxIndexArrayHeader.leftClass
Removed KerxIndexArrayHeader.leftClassCount
Removed KerxIndexArrayHeader.rightClass
Removed KerxIndexArrayHeader.rightClassCount
Removed KerxSubtableHeader.init(length: UInt32, stInfo: KerxSubtableCoverage, tupleIndex: UInt32, fsHeader: KerxFormatSpecificHeader)
Removed KerxSubtableHeader.tupleIndex
Added KerxIndexArrayHeader.columnCount
Added KerxIndexArrayHeader.columnIndexTableOffset
Added KerxIndexArrayHeader.init(flags: UInt32, rowCount: UInt16, columnCount: UInt16, rowIndexTableOffset: UInt32, columnIndexTableOffset: UInt32, kerningArrayOffset: UInt32, kerningVectorOffset: UInt32)
Added KerxIndexArrayHeader.kerningArrayOffset
Added KerxIndexArrayHeader.kerningVectorOffset
Added KerxIndexArrayHeader.rowCount
Added KerxIndexArrayHeader.rowIndexTableOffset
Added KerxSubtableHeader.init(length: UInt32, stInfo: KerxSubtableCoverage, tupleCount: UInt32, fsHeader: KerxFormatSpecificHeader)
Added KerxSubtableHeader.tupleCount
Added SFNTLookupFormatSpecificHeader.init(vector: SFNTLookupVectorHeader)
Added SFNTLookupFormatSpecificHeader.vector
Added kSFNTLookupVector
Declaration
From
enum CTCharacterCollection : UInt16 {
    case IdentityMapping
    case AdobeCNS1
    case AdobeGB1
    case AdobeJapan1
    case AdobeJapan2
    case AdobeKorea1
    static var kCTIdentityMappingCharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeCNS1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeGB1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeJapan1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeJapan2CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeKorea1CharacterCollection: CTCharacterCollection { get }
}
To
enum CTCharacterCollection : UInt16 {
    case identityMapping
    case adobeCNS1
    case adobeGB1
    case adobeJapan1
    case adobeJapan2
    case adobeKorea1
    static var kCTIdentityMappingCharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeCNS1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeGB1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeJapan1CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeJapan2CharacterCollection: CTCharacterCollection { get }
    static var kCTAdobeKorea1CharacterCollection: CTCharacterCollection { get }
}

Declaration
From
case AdobeCNS1
To
case adobeCNS1

Declaration
From
case AdobeGB1
To
case adobeGB1

Declaration
From
case AdobeJapan1
To
case adobeJapan1

Declaration
From
case AdobeJapan2
To
case adobeJapan2

Declaration
From
case AdobeKorea1
To
case adobeKorea1

Declaration
From
case IdentityMapping
To
case identityMapping

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

Declaration
From
static var StandardSort: CTFontCollectionCopyOptions { get }
To
static var standardSort: CTFontCollectionCopyOptions { get }

Declaration
From
static var Unique: CTFontCollectionCopyOptions { get }
To
static var unique: CTFontCollectionCopyOptions { get }

Declaration
From
enum CTFontDescriptorMatchingState : UInt32 {
    case DidBegin
    case DidFinish
    case WillBeginQuerying
    case Stalled
    case WillBeginDownloading
    case Downloading
    case DidFinishDownloading
    case DidMatch
    case DidFailWithError
}
To
enum CTFontDescriptorMatchingState : UInt32 {
    case didBegin
    case didFinish
    case willBeginQuerying
    case stalled
    case willBeginDownloading
    case downloading
    case didFinishDownloading
    case didMatch
    case didFailWithError
}

Declaration
From
case DidBegin
To
case didBegin

Declaration
From
case DidFailWithError
To
case didFailWithError

Declaration
From
case DidFinish
To
case didFinish

Declaration
From
case DidFinishDownloading
To
case didFinishDownloading

Declaration
From
case DidMatch
To
case didMatch

Declaration
From
case Downloading
To
case downloading

Declaration
From
case Stalled
To
case stalled

Declaration
From
case WillBeginDownloading
To
case willBeginDownloading

Declaration
From
case WillBeginQuerying
To
case willBeginQuerying

Declaration
From
enum CTFontFormat : UInt32 {
    case Unrecognized
    case OpenTypePostScript
    case OpenTypeTrueType
    case TrueType
    case PostScript
    case Bitmap
}
To
enum CTFontFormat : UInt32 {
    case unrecognized
    case openTypePostScript
    case openTypeTrueType
    case trueType
    case postScript
    case bitmap
}

Declaration
From
case Bitmap
To
case bitmap

Declaration
From
case OpenTypePostScript
To
case openTypePostScript

Declaration
From
case OpenTypeTrueType
To
case openTypeTrueType

Declaration
From
case PostScript
To
case postScript

Declaration
From
case TrueType
To
case trueType

Declaration
From
case Unrecognized
To
case unrecognized

Declaration
From
enum CTFontManagerAutoActivationSetting : UInt32 {
    case Default
    case Disabled
    case Enabled
    case PromptUser
}
To
enum CTFontManagerAutoActivationSetting : UInt32 {
    case `default`
    case disabled
    case enabled
    case promptUser
}

Declaration
From
case Default
To
case `default`

Declaration
From
case Disabled
To
case disabled

Declaration
From
case Enabled
To
case enabled

Declaration
From
case PromptUser
To
case promptUser

Declaration
From
enum CTFontManagerError : CFIndex {
    case FileNotFound
    case InsufficientPermissions
    case UnrecognizedFormat
    case InvalidFontData
    case AlreadyRegistered
    case NotRegistered
    case InUse
    case SystemRequired
}
To
enum CTFontManagerError : CFIndex {
    case fileNotFound
    case insufficientPermissions
    case unrecognizedFormat
    case invalidFontData
    case alreadyRegistered
    case notRegistered
    case inUse
    case systemRequired
}

Declaration
From
case AlreadyRegistered
To
case alreadyRegistered

Declaration
From
case FileNotFound
To
case fileNotFound

Declaration
From
case InsufficientPermissions
To
case insufficientPermissions

Declaration
From
case InUse
To
case inUse

Declaration
From
case InvalidFontData
To
case invalidFontData

Declaration
From
case NotRegistered
To
case notRegistered

Declaration
From
case SystemRequired
To
case systemRequired

Declaration
From
case UnrecognizedFormat
To
case unrecognizedFormat

Declaration
From
enum CTFontManagerScope : UInt32 {
    case None
    case Process
    case User
    case Session
}
To
enum CTFontManagerScope : UInt32 {
    case none
    case process
    case user
    case session
}

Declaration
From
case None
To
case none

Declaration
From
case Process
To
case process

Declaration
From
case Session
To
case session

Declaration
From
case User
To
case user

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

Declaration
From
static var PreferSystemFont: CTFontOptions { get }
To
static var preferSystemFont: CTFontOptions { get }

Declaration
From
static var PreventAutoActivation: CTFontOptions { get }
To
static var preventAutoActivation: CTFontOptions { get }

Declaration
From
enum CTFontOrientation : UInt32 {
    case Default
    case Horizontal
    case Vertical
    static var kCTFontDefaultOrientation: CTFontOrientation { get }
    static var kCTFontHorizontalOrientation: CTFontOrientation { get }
    static var kCTFontVerticalOrientation: CTFontOrientation { get }
}
To
enum CTFontOrientation : UInt32 {
    case `default`
    case horizontal
    case vertical
    static var kCTFontDefaultOrientation: CTFontOrientation { get }
    static var kCTFontHorizontalOrientation: CTFontOrientation { get }
    static var kCTFontVerticalOrientation: CTFontOrientation { get }
}

Declaration
From
case Default
To
case `default`

Declaration
From
case Horizontal
To
case horizontal

Declaration
From
case Vertical
To
case vertical

DeclarationProtocols
From
struct CTFontStylisticClass : OptionSetType {
    init(rawValue rawValue: UInt32)
    static var ClassUnknown: CTFontStylisticClass { get }
    static var ClassOldStyleSerifs: CTFontStylisticClass { get }
    static var ClassTransitionalSerifs: CTFontStylisticClass { get }
    static var ClassModernSerifs: CTFontStylisticClass { get }
    static var ClassClarendonSerifs: CTFontStylisticClass { get }
    static var ClassSlabSerifs: CTFontStylisticClass { get }
    static var ClassFreeformSerifs: CTFontStylisticClass { get }
    static var ClassSansSerif: CTFontStylisticClass { get }
    static var ClassOrnamentals: CTFontStylisticClass { get }
    static var ClassScripts: CTFontStylisticClass { get }
    static var ClassSymbolic: CTFontStylisticClass { get }
    static var UnknownClass: CTFontStylisticClass { get }
    static var OldStyleSerifsClass: CTFontStylisticClass { get }
    static var TransitionalSerifsClass: CTFontStylisticClass { get }
    static var ModernSerifsClass: CTFontStylisticClass { get }
    static var ClarendonSerifsClass: CTFontStylisticClass { get }
    static var SlabSerifsClass: CTFontStylisticClass { get }
    static var FreeformSerifsClass: CTFontStylisticClass { get }
    static var SansSerifClass: CTFontStylisticClass { get }
    static var OrnamentalsClass: CTFontStylisticClass { get }
    static var ScriptsClass: CTFontStylisticClass { get }
    static var SymbolicClass: CTFontStylisticClass { get }
}
OptionSetType
To
struct CTFontStylisticClass : OptionSet {
    init(rawValue rawValue: UInt32)
    static var classUnknown: CTFontStylisticClass { get }
    static var classOldStyleSerifs: CTFontStylisticClass { get }
    static var classTransitionalSerifs: CTFontStylisticClass { get }
    static var classModernSerifs: CTFontStylisticClass { get }
    static var classClarendonSerifs: CTFontStylisticClass { get }
    static var classSlabSerifs: CTFontStylisticClass { get }
    static var classFreeformSerifs: CTFontStylisticClass { get }
    static var classSansSerif: CTFontStylisticClass { get }
    static var classOrnamentals: CTFontStylisticClass { get }
    static var classScripts: CTFontStylisticClass { get }
    static var classSymbolic: CTFontStylisticClass { get }
    static var unknownClass: CTFontStylisticClass { get }
    static var oldStyleSerifsClass: CTFontStylisticClass { get }
    static var transitionalSerifsClass: CTFontStylisticClass { get }
    static var modernSerifsClass: CTFontStylisticClass { get }
    static var clarendonSerifsClass: CTFontStylisticClass { get }
    static var slabSerifsClass: CTFontStylisticClass { get }
    static var freeformSerifsClass: CTFontStylisticClass { get }
    static var sansSerifClass: CTFontStylisticClass { get }
    static var ornamentalsClass: CTFontStylisticClass { get }
    static var scriptsClass: CTFontStylisticClass { get }
    static var symbolicClass: CTFontStylisticClass { get }
    func intersect(_ other: CTFontStylisticClass) -> CTFontStylisticClass
    func exclusiveOr(_ other: CTFontStylisticClass) -> CTFontStylisticClass
    mutating func unionInPlace(_ other: CTFontStylisticClass)
    mutating func intersectInPlace(_ other: CTFontStylisticClass)
    mutating func exclusiveOrInPlace(_ other: CTFontStylisticClass)
    func isSubsetOf(_ other: CTFontStylisticClass) -> Bool
    func isDisjointWith(_ other: CTFontStylisticClass) -> Bool
    func isSupersetOf(_ other: CTFontStylisticClass) -> Bool
    mutating func subtractInPlace(_ other: CTFontStylisticClass)
    func isStrictSupersetOf(_ other: CTFontStylisticClass) -> Bool
    func isStrictSubsetOf(_ other: CTFontStylisticClass) -> Bool
}
extension CTFontStylisticClass {
    func union(_ other: CTFontStylisticClass) -> CTFontStylisticClass
    func intersection(_ other: CTFontStylisticClass) -> CTFontStylisticClass
    func symmetricDifference(_ other: CTFontStylisticClass) -> CTFontStylisticClass
}
extension CTFontStylisticClass {
    func contains(_ member: CTFontStylisticClass) -> Bool
    mutating func insert(_ newMember: CTFontStylisticClass) -> (inserted: Bool, memberAfterInsert: CTFontStylisticClass)
    mutating func remove(_ member: CTFontStylisticClass) -> CTFontStylisticClass?
    mutating func update(with newMember: CTFontStylisticClass) -> CTFontStylisticClass?
}
extension CTFontStylisticClass {
    convenience init()
    mutating func formUnion(_ other: CTFontStylisticClass)
    mutating func formIntersection(_ other: CTFontStylisticClass)
    mutating func formSymmetricDifference(_ other: CTFontStylisticClass)
}
extension CTFontStylisticClass {
    convenience init<S : Sequence where S.Iterator.Element == CTFontStylisticClass>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: CTFontStylisticClass...)
    mutating func subtract(_ other: CTFontStylisticClass)
    func isSubset(of other: CTFontStylisticClass) -> Bool
    func isSuperset(of other: CTFontStylisticClass) -> Bool
    func isDisjoint(with other: CTFontStylisticClass) -> Bool
    func subtracting(_ other: CTFontStylisticClass) -> CTFontStylisticClass
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: CTFontStylisticClass) -> Bool
    func isStrictSubset(of other: CTFontStylisticClass) -> Bool
}
OptionSet

Declaration
From
static var ClarendonSerifsClass: CTFontStylisticClass { get }
To
static var clarendonSerifsClass: CTFontStylisticClass { get }

Declaration
From
static var ClassClarendonSerifs: CTFontStylisticClass { get }
To
static var classClarendonSerifs: CTFontStylisticClass { get }

Declaration
From
static var ClassFreeformSerifs: CTFontStylisticClass { get }
To
static var classFreeformSerifs: CTFontStylisticClass { get }

Declaration
From
static var ClassModernSerifs: CTFontStylisticClass { get }
To
static var classModernSerifs: CTFontStylisticClass { get }

Declaration
From
static var ClassOldStyleSerifs: CTFontStylisticClass { get }
To
static var classOldStyleSerifs: CTFontStylisticClass { get }

Declaration
From
static var ClassOrnamentals: CTFontStylisticClass { get }
To
static var classOrnamentals: CTFontStylisticClass { get }

Declaration
From
static var ClassSansSerif: CTFontStylisticClass { get }
To
static var classSansSerif: CTFontStylisticClass { get }

Declaration
From
static var ClassScripts: CTFontStylisticClass { get }
To
static var classScripts: CTFontStylisticClass { get }

Declaration
From
static var ClassSlabSerifs: CTFontStylisticClass { get }
To
static var classSlabSerifs: CTFontStylisticClass { get }

Declaration
From
static var ClassSymbolic: CTFontStylisticClass { get }
To
static var classSymbolic: CTFontStylisticClass { get }

Declaration
From
static var ClassTransitionalSerifs: CTFontStylisticClass { get }
To
static var classTransitionalSerifs: CTFontStylisticClass { get }

Declaration
From
static var FreeformSerifsClass: CTFontStylisticClass { get }
To
static var freeformSerifsClass: CTFontStylisticClass { get }

Declaration
From
static var ModernSerifsClass: CTFontStylisticClass { get }
To
static var modernSerifsClass: CTFontStylisticClass { get }

Declaration
From
static var OldStyleSerifsClass: CTFontStylisticClass { get }
To
static var oldStyleSerifsClass: CTFontStylisticClass { get }

Declaration
From
static var OrnamentalsClass: CTFontStylisticClass { get }
To
static var ornamentalsClass: CTFontStylisticClass { get }

Declaration
From
static var SansSerifClass: CTFontStylisticClass { get }
To
static var sansSerifClass: CTFontStylisticClass { get }

Declaration
From
static var ScriptsClass: CTFontStylisticClass { get }
To
static var scriptsClass: CTFontStylisticClass { get }

Declaration
From
static var SlabSerifsClass: CTFontStylisticClass { get }
To
static var slabSerifsClass: CTFontStylisticClass { get }

Declaration
From
static var SymbolicClass: CTFontStylisticClass { get }
To
static var symbolicClass: CTFontStylisticClass { get }

Declaration
From
static var TransitionalSerifsClass: CTFontStylisticClass { get }
To
static var transitionalSerifsClass: CTFontStylisticClass { get }

DeclarationProtocols
From
struct CTFontSymbolicTraits : OptionSetType {
    init(rawValue rawValue: UInt32)
    static var TraitItalic: CTFontSymbolicTraits { get }
    static var TraitBold: CTFontSymbolicTraits { get }
    static var TraitExpanded: CTFontSymbolicTraits { get }
    static var TraitCondensed: CTFontSymbolicTraits { get }
    static var TraitMonoSpace: CTFontSymbolicTraits { get }
    static var TraitVertical: CTFontSymbolicTraits { get }
    static var TraitUIOptimized: CTFontSymbolicTraits { get }
    static var TraitColorGlyphs: CTFontSymbolicTraits { get }
    static var TraitComposite: CTFontSymbolicTraits { get }
    static var TraitClassMask: CTFontSymbolicTraits { get }
    static var ItalicTrait: CTFontSymbolicTraits { get }
    static var BoldTrait: CTFontSymbolicTraits { get }
    static var ExpandedTrait: CTFontSymbolicTraits { get }
    static var CondensedTrait: CTFontSymbolicTraits { get }
    static var MonoSpaceTrait: CTFontSymbolicTraits { get }
    static var VerticalTrait: CTFontSymbolicTraits { get }
    static var UIOptimizedTrait: CTFontSymbolicTraits { get }
    static var ColorGlyphsTrait: CTFontSymbolicTraits { get }
    static var CompositeTrait: CTFontSymbolicTraits { get }
    static var ClassMaskTrait: CTFontSymbolicTraits { get }
}
OptionSetType
To
struct CTFontSymbolicTraits : OptionSet {
    init(rawValue rawValue: UInt32)
    static var traitItalic: CTFontSymbolicTraits { get }
    static var traitBold: CTFontSymbolicTraits { get }
    static var traitExpanded: CTFontSymbolicTraits { get }
    static var traitCondensed: CTFontSymbolicTraits { get }
    static var traitMonoSpace: CTFontSymbolicTraits { get }
    static var traitVertical: CTFontSymbolicTraits { get }
    static var traitUIOptimized: CTFontSymbolicTraits { get }
    static var traitColorGlyphs: CTFontSymbolicTraits { get }
    static var traitComposite: CTFontSymbolicTraits { get }
    static var traitClassMask: CTFontSymbolicTraits { get }
    static var italicTrait: CTFontSymbolicTraits { get }
    static var boldTrait: CTFontSymbolicTraits { get }
    static var expandedTrait: CTFontSymbolicTraits { get }
    static var condensedTrait: CTFontSymbolicTraits { get }
    static var monoSpaceTrait: CTFontSymbolicTraits { get }
    static var verticalTrait: CTFontSymbolicTraits { get }
    static var uiOptimizedTrait: CTFontSymbolicTraits { get }
    static var colorGlyphsTrait: CTFontSymbolicTraits { get }
    static var compositeTrait: CTFontSymbolicTraits { get }
    static var classMaskTrait: CTFontSymbolicTraits { get }
    func intersect(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
    func exclusiveOr(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
    mutating func unionInPlace(_ other: CTFontSymbolicTraits)
    mutating func intersectInPlace(_ other: CTFontSymbolicTraits)
    mutating func exclusiveOrInPlace(_ other: CTFontSymbolicTraits)
    func isSubsetOf(_ other: CTFontSymbolicTraits) -> Bool
    func isDisjointWith(_ other: CTFontSymbolicTraits) -> Bool
    func isSupersetOf(_ other: CTFontSymbolicTraits) -> Bool
    mutating func subtractInPlace(_ other: CTFontSymbolicTraits)
    func isStrictSupersetOf(_ other: CTFontSymbolicTraits) -> Bool
    func isStrictSubsetOf(_ other: CTFontSymbolicTraits) -> Bool
}
extension CTFontSymbolicTraits {
    func union(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
    func intersection(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
    func symmetricDifference(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
}
extension CTFontSymbolicTraits {
    func contains(_ member: CTFontSymbolicTraits) -> Bool
    mutating func insert(_ newMember: CTFontSymbolicTraits) -> (inserted: Bool, memberAfterInsert: CTFontSymbolicTraits)
    mutating func remove(_ member: CTFontSymbolicTraits) -> CTFontSymbolicTraits?
    mutating func update(with newMember: CTFontSymbolicTraits) -> CTFontSymbolicTraits?
}
extension CTFontSymbolicTraits {
    convenience init()
    mutating func formUnion(_ other: CTFontSymbolicTraits)
    mutating func formIntersection(_ other: CTFontSymbolicTraits)
    mutating func formSymmetricDifference(_ other: CTFontSymbolicTraits)
}
extension CTFontSymbolicTraits {
    convenience init<S : Sequence where S.Iterator.Element == CTFontSymbolicTraits>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: CTFontSymbolicTraits...)
    mutating func subtract(_ other: CTFontSymbolicTraits)
    func isSubset(of other: CTFontSymbolicTraits) -> Bool
    func isSuperset(of other: CTFontSymbolicTraits) -> Bool
    func isDisjoint(with other: CTFontSymbolicTraits) -> Bool
    func subtracting(_ other: CTFontSymbolicTraits) -> CTFontSymbolicTraits
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: CTFontSymbolicTraits) -> Bool
    func isStrictSubset(of other: CTFontSymbolicTraits) -> Bool
}
OptionSet

Declaration
From
static var BoldTrait: CTFontSymbolicTraits { get }
To
static var boldTrait: CTFontSymbolicTraits { get }

Declaration
From
static var ClassMaskTrait: CTFontSymbolicTraits { get }
To
static var classMaskTrait: CTFontSymbolicTraits { get }

Declaration
From
static var ColorGlyphsTrait: CTFontSymbolicTraits { get }
To
static var colorGlyphsTrait: CTFontSymbolicTraits { get }

Declaration
From
static var CompositeTrait: CTFontSymbolicTraits { get }
To
static var compositeTrait: CTFontSymbolicTraits { get }

Declaration
From
static var CondensedTrait: CTFontSymbolicTraits { get }
To
static var condensedTrait: CTFontSymbolicTraits { get }

Declaration
From
static var ExpandedTrait: CTFontSymbolicTraits { get }
To
static var expandedTrait: CTFontSymbolicTraits { get }

Declaration
From
static var ItalicTrait: CTFontSymbolicTraits { get }
To
static var italicTrait: CTFontSymbolicTraits { get }

Declaration
From
static var MonoSpaceTrait: CTFontSymbolicTraits { get }
To
static var monoSpaceTrait: CTFontSymbolicTraits { get }

Declaration
From
static var TraitBold: CTFontSymbolicTraits { get }
To
static var traitBold: CTFontSymbolicTraits { get }

Declaration
From
static var TraitClassMask: CTFontSymbolicTraits { get }
To
static var traitClassMask: CTFontSymbolicTraits { get }

Declaration
From
static var TraitColorGlyphs: CTFontSymbolicTraits { get }
To
static var traitColorGlyphs: CTFontSymbolicTraits { get }

Declaration
From
static var TraitComposite: CTFontSymbolicTraits { get }
To
static var traitComposite: CTFontSymbolicTraits { get }

Declaration
From
static var TraitCondensed: CTFontSymbolicTraits { get }
To
static var traitCondensed: CTFontSymbolicTraits { get }

Declaration
From
static var TraitExpanded: CTFontSymbolicTraits { get }
To
static var traitExpanded: CTFontSymbolicTraits { get }

Declaration
From
static var TraitItalic: CTFontSymbolicTraits { get }
To
static var traitItalic: CTFontSymbolicTraits { get }

Declaration
From
static var TraitMonoSpace: CTFontSymbolicTraits { get }
To
static var traitMonoSpace: CTFontSymbolicTraits { get }

Declaration
From
static var TraitUIOptimized: CTFontSymbolicTraits { get }
To
static var traitUIOptimized: CTFontSymbolicTraits { get }

Declaration
From
static var TraitVertical: CTFontSymbolicTraits { get }
To
static var traitVertical: CTFontSymbolicTraits { get }

Declaration
From
static var UIOptimizedTrait: CTFontSymbolicTraits { get }
To
static var uiOptimizedTrait: CTFontSymbolicTraits { get }

Declaration
From
static var VerticalTrait: CTFontSymbolicTraits { get }
To
static var verticalTrait: CTFontSymbolicTraits { get }

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

Declaration
From
enum CTFontUIFontType : UInt32 {
    case None
    case User
    case UserFixedPitch
    case System
    case EmphasizedSystem
    case SmallSystem
    case SmallEmphasizedSystem
    case MiniSystem
    case MiniEmphasizedSystem
    case Views
    case Application
    case Label
    case MenuTitle
    case MenuItem
    case MenuItemMark
    case MenuItemCmdKey
    case WindowTitle
    case PushButton
    case UtilityWindowTitle
    case AlertHeader
    case SystemDetail
    case EmphasizedSystemDetail
    case Toolbar
    case SmallToolbar
    case Message
    case Palette
    case ToolTip
    case ControlContent
    static var kCTFontNoFontType: CTFontUIFontType { get }
    static var kCTFontUserFontType: CTFontUIFontType { get }
    static var kCTFontUserFixedPitchFontType: CTFontUIFontType { get }
    static var kCTFontSystemFontType: CTFontUIFontType { get }
    static var kCTFontEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontSmallSystemFontType: CTFontUIFontType { get }
    static var kCTFontSmallEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontMiniSystemFontType: CTFontUIFontType { get }
    static var kCTFontMiniEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontViewsFontType: CTFontUIFontType { get }
    static var kCTFontApplicationFontType: CTFontUIFontType { get }
    static var kCTFontLabelFontType: CTFontUIFontType { get }
    static var kCTFontMenuTitleFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemMarkFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemCmdKeyFontType: CTFontUIFontType { get }
    static var kCTFontWindowTitleFontType: CTFontUIFontType { get }
    static var kCTFontPushButtonFontType: CTFontUIFontType { get }
    static var kCTFontUtilityWindowTitleFontType: CTFontUIFontType { get }
    static var kCTFontAlertHeaderFontType: CTFontUIFontType { get }
    static var kCTFontSystemDetailFontType: CTFontUIFontType { get }
    static var kCTFontEmphasizedSystemDetailFontType: CTFontUIFontType { get }
    static var kCTFontToolbarFontType: CTFontUIFontType { get }
    static var kCTFontSmallToolbarFontType: CTFontUIFontType { get }
    static var kCTFontMessageFontType: CTFontUIFontType { get }
    static var kCTFontPaletteFontType: CTFontUIFontType { get }
    static var kCTFontToolTipFontType: CTFontUIFontType { get }
    static var kCTFontControlContentFontType: CTFontUIFontType { get }
}
To
enum CTFontUIFontType : UInt32 {
    case none
    case user
    case userFixedPitch
    case system
    case emphasizedSystem
    case smallSystem
    case smallEmphasizedSystem
    case miniSystem
    case miniEmphasizedSystem
    case views
    case application
    case label
    case menuTitle
    case menuItem
    case menuItemMark
    case menuItemCmdKey
    case windowTitle
    case pushButton
    case utilityWindowTitle
    case alertHeader
    case systemDetail
    case emphasizedSystemDetail
    case toolbar
    case smallToolbar
    case message
    case palette
    case toolTip
    case controlContent
    static var kCTFontNoFontType: CTFontUIFontType { get }
    static var kCTFontUserFontType: CTFontUIFontType { get }
    static var kCTFontUserFixedPitchFontType: CTFontUIFontType { get }
    static var kCTFontSystemFontType: CTFontUIFontType { get }
    static var kCTFontEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontSmallSystemFontType: CTFontUIFontType { get }
    static var kCTFontSmallEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontMiniSystemFontType: CTFontUIFontType { get }
    static var kCTFontMiniEmphasizedSystemFontType: CTFontUIFontType { get }
    static var kCTFontViewsFontType: CTFontUIFontType { get }
    static var kCTFontApplicationFontType: CTFontUIFontType { get }
    static var kCTFontLabelFontType: CTFontUIFontType { get }
    static var kCTFontMenuTitleFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemMarkFontType: CTFontUIFontType { get }
    static var kCTFontMenuItemCmdKeyFontType: CTFontUIFontType { get }
    static var kCTFontWindowTitleFontType: CTFontUIFontType { get }
    static var kCTFontPushButtonFontType: CTFontUIFontType { get }
    static var kCTFontUtilityWindowTitleFontType: CTFontUIFontType { get }
    static var kCTFontAlertHeaderFontType: CTFontUIFontType { get }
    static var kCTFontSystemDetailFontType: CTFontUIFontType { get }
    static var kCTFontEmphasizedSystemDetailFontType: CTFontUIFontType { get }
    static var kCTFontToolbarFontType: CTFontUIFontType { get }
    static var kCTFontSmallToolbarFontType: CTFontUIFontType { get }
    static var kCTFontMessageFontType: CTFontUIFontType { get }
    static var kCTFontPaletteFontType: CTFontUIFontType { get }
    static var kCTFontToolTipFontType: CTFontUIFontType { get }
    static var kCTFontControlContentFontType: CTFontUIFontType { get }
}

Declaration
From
case AlertHeader
To
case alertHeader

Declaration
From
case Application
To
case application

Declaration
From
case ControlContent
To
case controlContent

Declaration
From
case EmphasizedSystem
To
case emphasizedSystem

Declaration
From
case EmphasizedSystemDetail
To
case emphasizedSystemDetail

Declaration
From
case Label
To
case label

Declaration
From
case MenuItem
To
case menuItem

Declaration
From
case MenuItemCmdKey
To
case menuItemCmdKey

Declaration
From
case MenuItemMark
To
case menuItemMark

Declaration
From
case MenuTitle
To
case menuTitle

Declaration
From
case Message
To
case message

Declaration
From
case MiniEmphasizedSystem
To
case miniEmphasizedSystem

Declaration
From
case MiniSystem
To
case miniSystem

Declaration
From
case None
To
case none

Declaration
From
case Palette
To
case palette

Declaration
From
case PushButton
To
case pushButton

Declaration
From
case SmallEmphasizedSystem
To
case smallEmphasizedSystem

Declaration
From
case SmallSystem
To
case smallSystem

Declaration
From
case SmallToolbar
To
case smallToolbar

Declaration
From
case System
To
case system

Declaration
From
case SystemDetail
To
case systemDetail

Declaration
From
case Toolbar
To
case toolbar

Declaration
From
case ToolTip
To
case toolTip

Declaration
From
case User
To
case user

Declaration
From
case UserFixedPitch
To
case userFixedPitch

Declaration
From
case UtilityWindowTitle
To
case utilityWindowTitle

Declaration
From
case Views
To
case views

Declaration
From
case WindowTitle
To
case windowTitle

Declaration
From
enum CTFramePathFillRule : UInt32 {
    case EvenOdd
    case WindingNumber
}
To
enum CTFramePathFillRule : UInt32 {
    case evenOdd
    case windingNumber
}

Declaration
From
case EvenOdd
To
case evenOdd

Declaration
From
case WindingNumber
To
case windingNumber

Declaration
From
enum CTFrameProgression : UInt32 {
    case TopToBottom
    case RightToLeft
    case LeftToRight
}
To
enum CTFrameProgression : UInt32 {
    case topToBottom
    case rightToLeft
    case leftToRight
}

Declaration
From
case LeftToRight
To
case leftToRight

Declaration
From
case RightToLeft
To
case rightToLeft

Declaration
From
case TopToBottom
To
case topToBottom

DeclarationProtocols
From
struct CTLineBoundsOptions : OptionSetType {
    init(rawValue rawValue: CFOptionFlags)
    static var ExcludeTypographicLeading: CTLineBoundsOptions { get }
    static var ExcludeTypographicShifts: CTLineBoundsOptions { get }
    static var UseHangingPunctuation: CTLineBoundsOptions { get }
    static var UseGlyphPathBounds: CTLineBoundsOptions { get }
    static var UseOpticalBounds: CTLineBoundsOptions { get }
    static var IncludeLanguageExtents: CTLineBoundsOptions { get }
}
OptionSetType
To
struct CTLineBoundsOptions : OptionSet {
    init(rawValue rawValue: CFOptionFlags)
    static var excludeTypographicLeading: CTLineBoundsOptions { get }
    static var excludeTypographicShifts: CTLineBoundsOptions { get }
    static var useHangingPunctuation: CTLineBoundsOptions { get }
    static var useGlyphPathBounds: CTLineBoundsOptions { get }
    static var useOpticalBounds: CTLineBoundsOptions { get }
    static var includeLanguageExtents: CTLineBoundsOptions { get }
    func intersect(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
    func exclusiveOr(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
    mutating func unionInPlace(_ other: CTLineBoundsOptions)
    mutating func intersectInPlace(_ other: CTLineBoundsOptions)
    mutating func exclusiveOrInPlace(_ other: CTLineBoundsOptions)
    func isSubsetOf(_ other: CTLineBoundsOptions) -> Bool
    func isDisjointWith(_ other: CTLineBoundsOptions) -> Bool
    func isSupersetOf(_ other: CTLineBoundsOptions) -> Bool
    mutating func subtractInPlace(_ other: CTLineBoundsOptions)
    func isStrictSupersetOf(_ other: CTLineBoundsOptions) -> Bool
    func isStrictSubsetOf(_ other: CTLineBoundsOptions) -> Bool
}
extension CTLineBoundsOptions {
    func union(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
    func intersection(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
    func symmetricDifference(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
}
extension CTLineBoundsOptions {
    func contains(_ member: CTLineBoundsOptions) -> Bool
    mutating func insert(_ newMember: CTLineBoundsOptions) -> (inserted: Bool, memberAfterInsert: CTLineBoundsOptions)
    mutating func remove(_ member: CTLineBoundsOptions) -> CTLineBoundsOptions?
    mutating func update(with newMember: CTLineBoundsOptions) -> CTLineBoundsOptions?
}
extension CTLineBoundsOptions {
    convenience init()
    mutating func formUnion(_ other: CTLineBoundsOptions)
    mutating func formIntersection(_ other: CTLineBoundsOptions)
    mutating func formSymmetricDifference(_ other: CTLineBoundsOptions)
}
extension CTLineBoundsOptions {
    convenience init<S : Sequence where S.Iterator.Element == CTLineBoundsOptions>(_ sequence: S)
    convenience init(arrayLiteral arrayLiteral: CTLineBoundsOptions...)
    mutating func subtract(_ other: CTLineBoundsOptions)
    func isSubset(of other: CTLineBoundsOptions) -> Bool
    func isSuperset(of other: CTLineBoundsOptions) -> Bool
    func isDisjoint(with other: CTLineBoundsOptions) -> Bool
    func subtracting(_ other: CTLineBoundsOptions) -> CTLineBoundsOptions
    var isEmpty: Bool { get }
    func isStrictSuperset(of other: CTLineBoundsOptions) -> Bool
    func isStrictSubset(of other: CTLineBoundsOptions) -> Bool
}
OptionSet

Declaration
From
static var ExcludeTypographicLeading: CTLineBoundsOptions { get }
To
static var excludeTypographicLeading: CTLineBoundsOptions { get }

Declaration
From
static var ExcludeTypographicShifts: CTLineBoundsOptions { get }
To
static var excludeTypographicShifts: CTLineBoundsOptions { get }

Declaration
From
static var IncludeLanguageExtents: CTLineBoundsOptions { get }
To
static var includeLanguageExtents: CTLineBoundsOptions { get }

Declaration
From
static var UseGlyphPathBounds: CTLineBoundsOptions { get }
To
static var useGlyphPathBounds: CTLineBoundsOptions { get }

Declaration
From
static var UseHangingPunctuation: CTLineBoundsOptions { get }
To
static var useHangingPunctuation: CTLineBoundsOptions { get }

Declaration
From
static var UseOpticalBounds: CTLineBoundsOptions { get }
To
static var useOpticalBounds: CTLineBoundsOptions { get }

Declaration
From
enum CTLineBreakMode : UInt8 {
    case ByWordWrapping
    case ByCharWrapping
    case ByClipping
    case ByTruncatingHead
    case ByTruncatingTail
    case ByTruncatingMiddle
}
To
enum CTLineBreakMode : UInt8 {
    case byWordWrapping
    case byCharWrapping
    case byClipping
    case byTruncatingHead
    case byTruncatingTail
    case byTruncatingMiddle
}

Declaration
From
case ByCharWrapping
To
case byCharWrapping

Declaration
From
case ByClipping
To
case byClipping

Declaration
From
case ByTruncatingHead
To
case byTruncatingHead

Declaration
From
case ByTruncatingMiddle
To
case byTruncatingMiddle

Declaration
From
case ByTruncatingTail
To
case byTruncatingTail

Declaration
From
case ByWordWrapping
To
case byWordWrapping

Declaration
From
enum CTLineTruncationType : UInt32 {
    case Start
    case End
    case Middle
}
To
enum CTLineTruncationType : UInt32 {
    case start
    case end
    case middle
}

Declaration
From
case End
To
case end

Declaration
From
case Middle
To
case middle

Declaration
From
case Start
To
case start

Declaration
From
struct CTParagraphStyleSetting {
    var spec: CTParagraphStyleSpecifier
    var valueSize: Int
    var value: UnsafePointer<Void>
}
To
struct CTParagraphStyleSetting {
    var spec: CTParagraphStyleSpecifier
    var valueSize: Int
    var value: UnsafeRawPointer
}

Declaration
From
var value: UnsafePointer<Void>
To
var value: UnsafeRawPointer

Declaration
From
enum CTParagraphStyleSpecifier : UInt32 {
    case Alignment
    case FirstLineHeadIndent
    case HeadIndent
    case TailIndent
    case TabStops
    case DefaultTabInterval
    case LineBreakMode
    case LineHeightMultiple
    case MaximumLineHeight
    case MinimumLineHeight
    case LineSpacing
    case ParagraphSpacing
    case ParagraphSpacingBefore
    case BaseWritingDirection
    case MaximumLineSpacing
    case MinimumLineSpacing
    case LineSpacingAdjustment
    case LineBoundsOptions
    case Count
}
To
enum CTParagraphStyleSpecifier : UInt32 {
    case alignment
    case firstLineHeadIndent
    case headIndent
    case tailIndent
    case tabStops
    case defaultTabInterval
    case lineBreakMode
    case lineHeightMultiple
    case maximumLineHeight
    case minimumLineHeight
    case lineSpacing
    case paragraphSpacing
    case paragraphSpacingBefore
    case baseWritingDirection
    case maximumLineSpacing
    case minimumLineSpacing
    case lineSpacingAdjustment
    case lineBoundsOptions
    case count
}

Declaration
From
case Alignment
To
case alignment

Declaration
From
case BaseWritingDirection
To
case baseWritingDirection

Declaration
From
case Count
To
case count

Declaration
From
case DefaultTabInterval
To
case defaultTabInterval

Declaration
From
case FirstLineHeadIndent
To
case firstLineHeadIndent

Declaration
From
case HeadIndent
To
case headIndent

Declaration
From
case LineBoundsOptions
To
case lineBoundsOptions

Declaration
From
case LineBreakMode
To
case lineBreakMode

Declaration
From
case LineHeightMultiple
To
case lineHeightMultiple

Declaration
From
case LineSpacingAdjustment
To
case lineSpacingAdjustment

Declaration
From
case MaximumLineHeight
To
case maximumLineHeight

Declaration
From
case MaximumLineSpacing
To
case maximumLineSpacing

Declaration
From
case MinimumLineHeight
To
case minimumLineHeight

Declaration
From
case MinimumLineSpacing
To
case minimumLineSpacing

Declaration
From
case ParagraphSpacing
To
case paragraphSpacing

Declaration
From
case ParagraphSpacingBefore
To
case paragraphSpacingBefore

Declaration
From
case TabStops
To
case tabStops

Declaration
From
case TailIndent
To
case tailIndent

Declaration
From
enum CTRubyAlignment : UInt8 {
    case Invalid
    case Auto
    case Start
    case Center
    case End
    case DistributeLetter
    case DistributeSpace
    case LineEdge
}
To
enum CTRubyAlignment : UInt8 {
    case invalid
    case auto
    case start
    case center
    case end
    case distributeLetter
    case distributeSpace
    case lineEdge
}

Declaration
From
case Auto
To
case auto

Declaration
From
case Center
To
case center

Declaration
From
case DistributeLetter
To
case distributeLetter

Declaration
From
case DistributeSpace
To
case distributeSpace

Declaration
From
case End
To
case end

Declaration
From
case Invalid
To
case invalid

Declaration
From
case LineEdge
To
case lineEdge

Declaration
From
case Start
To
case start

Declaration
From
enum CTRubyOverhang : UInt8 {
    case Invalid
    case Auto
    case Start
    case End
    case None
}
To
enum CTRubyOverhang : UInt8 {
    case invalid
    case auto
    case start
    case end
    case none
}

Declaration
From
case Auto
To
case auto

Declaration
From
case End
To
case end

Declaration
From
case Invalid
To
case invalid

Declaration
From
case None
To
case none

Declaration
From
case Start
To
case start

Declaration
From
enum CTRubyPosition : UInt8 {
    case Before
    case After
    case InterCharacter
    case Inline
    case Count
}
To
enum CTRubyPosition : UInt8 {
    case before
    case after
    case interCharacter
    case inline
    case count
}

Declaration
From
case After
To
case after

Declaration
From
case Before
To
case before

Declaration
From
case Count
To
case count

Declaration
From
case Inline
To
case inline

Declaration
From
case InterCharacter
To
case interCharacter

Declaration
From
struct CTRunDelegateCallbacks {
    var version: CFIndex
    var dealloc: CTRunDelegateDeallocateCallback
    var getAscent: CTRunDelegateGetAscentCallback
    var getDescent: CTRunDelegateGetDescentCallback
    var getWidth: CTRunDelegateGetWidthCallback
}
To
struct CTRunDelegateCallbacks {
    var version: CFIndex
    var dealloc: CoreText.CTRunDelegateDeallocateCallback
    var getAscent: CoreText.CTRunDelegateGetAscentCallback
    var getDescent: CoreText.CTRunDelegateGetDescentCallback
    var getWidth: CoreText.CTRunDelegateGetWidthCallback
}

Declaration
From
var dealloc: CTRunDelegateDeallocateCallback
To
var dealloc: CoreText.CTRunDelegateDeallocateCallback

Declaration
From
var getAscent: CTRunDelegateGetAscentCallback
To
var getAscent: CoreText.CTRunDelegateGetAscentCallback

Declaration
From
var getDescent: CTRunDelegateGetDescentCallback
To
var getDescent: CoreText.CTRunDelegateGetDescentCallback

Declaration
From
var getWidth: CTRunDelegateGetWidthCallback
To
var getWidth: CoreText.CTRunDelegateGetWidthCallback

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

Declaration
From
static var HasNonIdentityMatrix: CTRunStatus { get }
To
static var hasNonIdentityMatrix: CTRunStatus { get }

Declaration
From
static var NonMonotonic: CTRunStatus { get }
To
static var nonMonotonic: CTRunStatus { get }

Declaration
From
static var RightToLeft: CTRunStatus { get }
To
static var rightToLeft: CTRunStatus { get }

Declaration
From
enum CTTextAlignment : UInt8 {
    case Left
    case Right
    case Center
    case Justified
    case Natural
    static var kCTLeftTextAlignment: CTTextAlignment { get }
    static var kCTRightTextAlignment: CTTextAlignment { get }
    static var kCTCenterTextAlignment: CTTextAlignment { get }
    static var kCTJustifiedTextAlignment: CTTextAlignment { get }
    static var kCTNaturalTextAlignment: CTTextAlignment { get }
}
To
enum CTTextAlignment : UInt8 {
    case left
    case right
    case center
    case justified
    case natural
    static var kCTLeftTextAlignment: CTTextAlignment { get }
    static var kCTRightTextAlignment: CTTextAlignment { get }
    static var kCTCenterTextAlignment: CTTextAlignment { get }
    static var kCTJustifiedTextAlignment: CTTextAlignment { get }
    static var kCTNaturalTextAlignment: CTTextAlignment { get }
}

Declaration
From
case Center
To
case center

Declaration
From
case Justified
To
case justified

Declaration
From
case Left
To
case left

Declaration
From
case Natural
To
case natural

Declaration
From
case Right
To
case right

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

Declaration
From
static var Double: CTUnderlineStyle { get }
To
static var double: CTUnderlineStyle { get }

Declaration
From
static var Single: CTUnderlineStyle { get }
To
static var single: CTUnderlineStyle { get }

Declaration
From
static var Thick: CTUnderlineStyle { get }
To
static var thick: CTUnderlineStyle { get }

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

Declaration
From
static var PatternDash: CTUnderlineStyleModifiers { get }
To
static var patternDash: CTUnderlineStyleModifiers { get }

Declaration
From
static var PatternDashDot: CTUnderlineStyleModifiers { get }
To
static var patternDashDot: CTUnderlineStyleModifiers { get }

Declaration
From
static var PatternDashDotDot: CTUnderlineStyleModifiers { get }
To
static var patternDashDotDot: CTUnderlineStyleModifiers { get }

Declaration
From
static var PatternDot: CTUnderlineStyleModifiers { get }
To
static var patternDot: CTUnderlineStyleModifiers { get }

Declaration
From
static var PatternSolid: CTUnderlineStyleModifiers { get }
To
static var patternSolid: CTUnderlineStyleModifiers { get }

Declaration
From
enum CTWritingDirection : Int8 {
    case Natural
    case LeftToRight
    case RightToLeft
}
To
enum CTWritingDirection : Int8 {
    case natural
    case leftToRight
    case rightToLeft
}

Declaration
From
case LeftToRight
To
case leftToRight

Declaration
From
case Natural
To
case natural

Declaration
From
case RightToLeft
To
case rightToLeft

Modified KerxIndexArrayHeader [struct]
Declaration
From
struct KerxIndexArrayHeader {
    var glyphCount: UInt16
    var kernValueCount: UInt16
    var leftClassCount: UInt16
    var rightClassCount: UInt16
    var flags: UInt16
    var kernValue: (Int16)
    var leftClass: (UInt16)
    var rightClass: (UInt16)
    var kernIndex: (UInt16)
    init()
    init(glyphCount glyphCount: UInt16, kernValueCount kernValueCount: UInt16, leftClassCount leftClassCount: UInt16, rightClassCount rightClassCount: UInt16, flags flags: UInt16, kernValue kernValue: (Int16), leftClass leftClass: (UInt16), rightClass rightClass: (UInt16), kernIndex kernIndex: (UInt16))
}
To
struct KerxIndexArrayHeader {
    var flags: UInt32
    var rowCount: UInt16
    var columnCount: UInt16
    var rowIndexTableOffset: UInt32
    var columnIndexTableOffset: UInt32
    var kerningArrayOffset: UInt32
    var kerningVectorOffset: UInt32
    init()
    init(flags flags: UInt32, rowCount rowCount: UInt16, columnCount columnCount: UInt16, rowIndexTableOffset rowIndexTableOffset: UInt32, columnIndexTableOffset columnIndexTableOffset: UInt32, kerningArrayOffset kerningArrayOffset: UInt32, kerningVectorOffset kerningVectorOffset: UInt32)
}

Modified KerxIndexArrayHeader.flags
Declaration
From
var flags: UInt16
To
var flags: UInt32

Modified KerxSubtableHeader [struct]
Declaration
From
struct KerxSubtableHeader {
    var length: UInt32
    var stInfo: KerxSubtableCoverage
    var tupleIndex: UInt32
    var fsHeader: KerxFormatSpecificHeader
    init()
    init(length length: UInt32, stInfo stInfo: KerxSubtableCoverage, tupleIndex tupleIndex: UInt32, fsHeader fsHeader: KerxFormatSpecificHeader)
}
To
struct KerxSubtableHeader {
    var length: UInt32
    var stInfo: KerxSubtableCoverage
    var tupleCount: UInt32
    var fsHeader: KerxFormatSpecificHeader
    init()
    init(length length: UInt32, stInfo stInfo: KerxSubtableCoverage, tupleCount tupleCount: UInt32, fsHeader fsHeader: KerxFormatSpecificHeader)
}

Modified SFNTLookupFormatSpecificHeader [struct]
Declaration
From
struct SFNTLookupFormatSpecificHeader {
    var theArray: SFNTLookupArrayHeader
    var segment: SFNTLookupSegmentHeader
    var single: SFNTLookupSingleHeader
    var trimmedArray: SFNTLookupTrimmedArrayHeader
    init(theArray theArray: SFNTLookupArrayHeader)
    init(segment segment: SFNTLookupSegmentHeader)
    init(single single: SFNTLookupSingleHeader)
    init(trimmedArray trimmedArray: SFNTLookupTrimmedArrayHeader)
    init()
}
To
struct SFNTLookupFormatSpecificHeader {
    var theArray: SFNTLookupArrayHeader
    var segment: SFNTLookupSegmentHeader
    var single: SFNTLookupSingleHeader
    var trimmedArray: SFNTLookupTrimmedArrayHeader
    var vector: SFNTLookupVectorHeader
    init(theArray theArray: SFNTLookupArrayHeader)
    init(segment segment: SFNTLookupSegmentHeader)
    init(single single: SFNTLookupSingleHeader)
    init(trimmedArray trimmedArray: SFNTLookupTrimmedArrayHeader)
    init(vector vector: SFNTLookupVectorHeader)
    init()
}

Declaration
From
func CTFontCollectionCreateMatchingFontDescriptorsSortedWithCallback(_ collection: CTFontCollection, _ sortCallback: CTFontCollectionSortDescriptorsCallback?, _ refCon: UnsafeMutablePointer<Void>) -> CFArray?
To
func CTFontCollectionCreateMatchingFontDescriptorsSortedWithCallback(_ collection: CTFontCollection, _ sortCallback: CoreText.CTFontCollectionSortDescriptorsCallback?, _ refCon: UnsafeMutableRawPointer?) -> CFArray?

Declaration
From
typealias CTFontCollectionSortDescriptorsCallback = (CTFontDescriptor, CTFontDescriptor, UnsafeMutablePointer<Void>) -> CFComparisonResult
To
typealias CTFontCollectionSortDescriptorsCallback = (CTFontDescriptor, CTFontDescriptor, UnsafeMutableRawPointer) -> CFComparisonResult

Declaration
From
func CTFontCopyAttribute(_ font: CTFont, _ attribute: CFString) -> AnyObject?
To
func CTFontCopyAttribute(_ font: CTFont, _ attribute: CFString) -> CFTypeRef?

Declaration
From
func CTFontCopyGraphicsFont(_ font: CTFont, _ attributes: UnsafeMutablePointer<Unmanaged<CTFontDescriptor>?>) -> CGFont
To
func CTFontCopyGraphicsFont(_ font: CTFont, _ attributes: UnsafeMutablePointer<Unmanaged<CTFontDescriptor>?>?) -> CGFont

Declaration
From
func CTFontCopyLocalizedName(_ font: CTFont, _ nameKey: CFString, _ actualLanguage: UnsafeMutablePointer<Unmanaged<CFString>?>) -> CFString?
To
func CTFontCopyLocalizedName(_ font: CTFont, _ nameKey: CFString, _ actualLanguage: UnsafeMutablePointer<Unmanaged<CFString>?>?) -> CFString?

Declaration
From
func CTFontCreateCopyWithAttributes(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ attributes: CTFontDescriptor?) -> CTFont
To
func CTFontCreateCopyWithAttributes(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ attributes: CTFontDescriptor?) -> CTFont

Declaration
From
func CTFontCreateCopyWithFamily(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ family: CFString) -> CTFont?
To
func CTFontCreateCopyWithFamily(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ family: CFString) -> CTFont?

Declaration
From
func CTFontCreateCopyWithSymbolicTraits(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ symTraitValue: CTFontSymbolicTraits, _ symTraitMask: CTFontSymbolicTraits) -> CTFont?
To
func CTFontCreateCopyWithSymbolicTraits(_ font: CTFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ symTraitValue: CTFontSymbolicTraits, _ symTraitMask: CTFontSymbolicTraits) -> CTFont?

Declaration
From
func CTFontCreatePathForGlyph(_ font: CTFont, _ glyph: CGGlyph, _ matrix: UnsafePointer<CGAffineTransform>) -> CGPath?
To
func CTFontCreatePathForGlyph(_ font: CTFont, _ glyph: CGGlyph, _ matrix: UnsafePointer<CGAffineTransform>?) -> CGPath?

Declaration
From
func CTFontCreateWithFontDescriptor(_ descriptor: CTFontDescriptor, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>) -> CTFont
To
func CTFontCreateWithFontDescriptor(_ descriptor: CTFontDescriptor, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?) -> CTFont

Declaration
From
func CTFontCreateWithFontDescriptorAndOptions(_ descriptor: CTFontDescriptor, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ options: CTFontOptions) -> CTFont
To
func CTFontCreateWithFontDescriptorAndOptions(_ descriptor: CTFontDescriptor, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ options: CTFontOptions) -> CTFont

Declaration
From
func CTFontCreateWithGraphicsFont(_ graphicsFont: CGFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ attributes: CTFontDescriptor?) -> CTFont
To
func CTFontCreateWithGraphicsFont(_ graphicsFont: CGFont, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ attributes: CTFontDescriptor?) -> CTFont

Declaration
From
func CTFontCreateWithName(_ name: CFString?, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>) -> CTFont
To
func CTFontCreateWithName(_ name: CFString?, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?) -> CTFont

Declaration
From
func CTFontCreateWithNameAndOptions(_ name: CFString, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ options: CTFontOptions) -> CTFont
To
func CTFontCreateWithNameAndOptions(_ name: CFString, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ options: CTFontOptions) -> CTFont

Declaration
From
func CTFontCreateWithPlatformFont(_ platformFont: ATSFontRef, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>, _ attributes: CTFontDescriptor?) -> CTFont?
To
func CTFontCreateWithPlatformFont(_ platformFont: ATSFontRef, _ size: CGFloat, _ matrix: UnsafePointer<CGAffineTransform>?, _ attributes: CTFontDescriptor?) -> CTFont?

Declaration
From
func CTFontCreateWithQuickdrawInstance(_ name: ConstStr255Param, _ identifier: Int16, _ style: UInt8, _ size: CGFloat) -> CTFont
To
func CTFontCreateWithQuickdrawInstance(_ name: ConstStr255Param?, _ identifier: Int16, _ style: UInt8, _ size: CGFloat) -> CTFont

Declaration
From
func CTFontDescriptorCopyAttribute(_ descriptor: CTFontDescriptor, _ attribute: CFString) -> AnyObject?
To
func CTFontDescriptorCopyAttribute(_ descriptor: CTFontDescriptor, _ attribute: CFString) -> CFTypeRef?

Declaration
From
func CTFontDescriptorCopyLocalizedAttribute(_ descriptor: CTFontDescriptor, _ attribute: CFString, _ language: UnsafeMutablePointer<Unmanaged<CFString>?>) -> AnyObject?
To
func CTFontDescriptorCopyLocalizedAttribute(_ descriptor: CTFontDescriptor, _ attribute: CFString, _ language: UnsafeMutablePointer<Unmanaged<CFString>?>?) -> CFTypeRef?

Declaration
From
func CTFontDescriptorMatchFontDescriptorsWithProgressHandler(_ descriptors: CFArray, _ mandatoryAttributes: CFSet?, _ progressBlock: CTFontDescriptorProgressHandler) -> Bool
To
func CTFontDescriptorMatchFontDescriptorsWithProgressHandler(_ descriptors: CFArray, _ mandatoryAttributes: CFSet?, _ progressBlock: CoreText.CTFontDescriptorProgressHandler) -> Bool

Declaration
From
func CTFontDrawGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>, _ positions: UnsafePointer<CGPoint>, _ count: Int, _ context: CGContext)
To
func CTFontDrawGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>!, _ positions: UnsafePointer<CGPoint>!, _ count: Int, _ context: CGContext)

Declaration
From
func CTFontGetAdvancesForGlyphs(_ font: CTFont, _ orientation: CTFontOrientation, _ glyphs: UnsafePointer<CGGlyph>, _ advances: UnsafeMutablePointer<CGSize>, _ count: CFIndex) -> Double
To
func CTFontGetAdvancesForGlyphs(_ font: CTFont, _ orientation: CTFontOrientation, _ glyphs: UnsafePointer<CGGlyph>!, _ advances: UnsafeMutablePointer<CGSize>?, _ count: CFIndex) -> Double

Declaration
From
func CTFontGetBoundingRectsForGlyphs(_ font: CTFont, _ orientation: CTFontOrientation, _ glyphs: UnsafePointer<CGGlyph>, _ boundingRects: UnsafeMutablePointer<CGRect>, _ count: CFIndex) -> CGRect
To
func CTFontGetBoundingRectsForGlyphs(_ font: CTFont, _ orientation: CTFontOrientation, _ glyphs: UnsafePointer<CGGlyph>!, _ boundingRects: UnsafeMutablePointer<CGRect>?, _ count: CFIndex) -> CGRect

Declaration
From
func CTFontGetGlyphsForCharacters(_ font: CTFont, _ characters: UnsafePointer<UniChar>, _ glyphs: UnsafeMutablePointer<CGGlyph>, _ count: CFIndex) -> Bool
To
func CTFontGetGlyphsForCharacters(_ font: CTFont, _ characters: UnsafePointer<UniChar>!, _ glyphs: UnsafeMutablePointer<CGGlyph>!, _ count: CFIndex) -> Bool

Declaration
From
func CTFontGetLigatureCaretPositions(_ font: CTFont, _ glyph: CGGlyph, _ positions: UnsafeMutablePointer<CGFloat>, _ maxPositions: CFIndex) -> CFIndex
To
func CTFontGetLigatureCaretPositions(_ font: CTFont, _ glyph: CGGlyph, _ positions: UnsafeMutablePointer<CGFloat>?, _ maxPositions: CFIndex) -> CFIndex

Declaration
From
func CTFontGetOpticalBoundsForGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>, _ boundingRects: UnsafeMutablePointer<CGRect>, _ count: CFIndex, _ options: CFOptionFlags) -> CGRect
To
func CTFontGetOpticalBoundsForGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>!, _ boundingRects: UnsafeMutablePointer<CGRect>?, _ count: CFIndex, _ options: CFOptionFlags) -> CGRect

Declaration
From
func CTFontGetPlatformFont(_ font: CTFont, _ attributes: UnsafeMutablePointer<Unmanaged<CTFontDescriptor>?>) -> ATSFontRef
To
func CTFontGetPlatformFont(_ font: CTFont, _ attributes: UnsafeMutablePointer<Unmanaged<CTFontDescriptor>?>?) -> ATSFontRef

Declaration
From
func CTFontGetVerticalTranslationsForGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>, _ translations: UnsafeMutablePointer<CGSize>, _ count: CFIndex)
To
func CTFontGetVerticalTranslationsForGlyphs(_ font: CTFont, _ glyphs: UnsafePointer<CGGlyph>!, _ translations: UnsafeMutablePointer<CGSize>!, _ count: CFIndex)

Declaration
From
func CTFontManagerCompareFontFamilyNames(_ family1: UnsafePointer<Void>, _ family2: UnsafePointer<Void>, _ context: UnsafeMutablePointer<Void>) -> CFComparisonResult
To
func CTFontManagerCompareFontFamilyNames(_ family1: UnsafeRawPointer, _ family2: UnsafeRawPointer, _ context: UnsafeMutableRawPointer?) -> CFComparisonResult

Declaration
From
func CTFontManagerCreateFontRequestRunLoopSource(_ sourceOrder: CFIndex, _ createMatchesCallback: (CFDictionary, pid_t) -> Unmanaged<CFArray>) -> CFRunLoopSource?
To
func CTFontManagerCreateFontRequestRunLoopSource(_ sourceOrder: CFIndex, _ createMatchesCallback: @escaping (CFDictionary, pid_t) -> Unmanaged<CFArray>) -> CFRunLoopSource?

Declaration
From
func CTFontManagerRegisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool
To
func CTFontManagerRegisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool

Declaration
From
func CTFontManagerRegisterFontsForURLs(_ fontURLs: CFArray, _ scope: CTFontManagerScope, _ errors: UnsafeMutablePointer<Unmanaged<CFArray>?>) -> Bool
To
func CTFontManagerRegisterFontsForURLs(_ fontURLs: CFArray, _ scope: CTFontManagerScope, _ errors: UnsafeMutablePointer<Unmanaged<CFArray>?>?) -> Bool

Declaration
From
func CTFontManagerRegisterGraphicsFont(_ font: CGFont, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool
To
func CTFontManagerRegisterGraphicsFont(_ font: CGFont, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool

Declaration
From
func CTFontManagerUnregisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool
To
func CTFontManagerUnregisterFontsForURL(_ fontURL: CFURL, _ scope: CTFontManagerScope, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool

Declaration
From
func CTFontManagerUnregisterFontsForURLs(_ fontURLs: CFArray, _ scope: CTFontManagerScope, _ errors: UnsafeMutablePointer<Unmanaged<CFArray>?>) -> Bool
To
func CTFontManagerUnregisterFontsForURLs(_ fontURLs: CFArray, _ scope: CTFontManagerScope, _ errors: UnsafeMutablePointer<Unmanaged<CFArray>?>?) -> Bool

Declaration
From
func CTFontManagerUnregisterGraphicsFont(_ font: CGFont, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>) -> Bool
To
func CTFontManagerUnregisterGraphicsFont(_ font: CGFont, _ error: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool

Declaration
From
func CTFrameGetLineOrigins(_ frame: CTFrame, _ range: CFRange, _ origins: UnsafeMutablePointer<CGPoint>)
To
func CTFrameGetLineOrigins(_ frame: CTFrame, _ range: CFRange, _ origins: UnsafeMutablePointer<CGPoint>!)

Declaration
From
func CTFramesetterSuggestFrameSizeWithConstraints(_ framesetter: CTFramesetter, _ stringRange: CFRange, _ frameAttributes: CFDictionary?, _ constraints: CGSize, _ fitRange: UnsafeMutablePointer<CFRange>) -> CGSize
To
func CTFramesetterSuggestFrameSizeWithConstraints(_ framesetter: CTFramesetter, _ stringRange: CFRange, _ frameAttributes: CFDictionary?, _ constraints: CGSize, _ fitRange: UnsafeMutablePointer<CFRange>?) -> CGSize

Declaration
From
func CTLineEnumerateCaretOffsets(_ line: CTLine, _ block: (Double, CFIndex, Bool, UnsafeMutablePointer<Bool>) -> Void)
To
func CTLineEnumerateCaretOffsets(_ line: CTLine, _ block: @escaping (Double, CFIndex, Bool, UnsafeMutablePointer<Bool>) -> Swift.Void)

Declaration
From
func CTLineGetOffsetForStringIndex(_ line: CTLine, _ charIndex: CFIndex, _ secondaryOffset: UnsafeMutablePointer<CGFloat>) -> CGFloat
To
func CTLineGetOffsetForStringIndex(_ line: CTLine, _ charIndex: CFIndex, _ secondaryOffset: UnsafeMutablePointer<CGFloat>?) -> CGFloat

Declaration
From
func CTLineGetTypographicBounds(_ line: CTLine, _ ascent: UnsafeMutablePointer<CGFloat>, _ descent: UnsafeMutablePointer<CGFloat>, _ leading: UnsafeMutablePointer<CGFloat>) -> Double
To
func CTLineGetTypographicBounds(_ line: CTLine, _ ascent: UnsafeMutablePointer<CGFloat>?, _ descent: UnsafeMutablePointer<CGFloat>?, _ leading: UnsafeMutablePointer<CGFloat>?) -> Double

Declaration
From
func CTParagraphStyleCreate(_ settings: UnsafePointer<CTParagraphStyleSetting>, _ settingCount: Int) -> CTParagraphStyle
To
func CTParagraphStyleCreate(_ settings: UnsafePointer<CTParagraphStyleSetting>?, _ settingCount: Int) -> CTParagraphStyle

Declaration
From
func CTParagraphStyleGetValueForSpecifier(_ paragraphStyle: CTParagraphStyle, _ spec: CTParagraphStyleSpecifier, _ valueBufferSize: Int, _ valueBuffer: UnsafeMutablePointer<Void>) -> Bool
To
func CTParagraphStyleGetValueForSpecifier(_ paragraphStyle: CTParagraphStyle, _ spec: CTParagraphStyleSpecifier, _ valueBufferSize: Int, _ valueBuffer: UnsafeMutableRawPointer) -> Bool

Declaration
From
func CTRubyAnnotationCreate(_ alignment: CTRubyAlignment, _ overhang: CTRubyOverhang, _ sizeFactor: CGFloat, _ text: UnsafeMutablePointer<Unmanaged<CFString>?>) -> CTRubyAnnotation
To
func CTRubyAnnotationCreate(_ alignment: CTRubyAlignment, _ overhang: CTRubyOverhang, _ sizeFactor: CGFloat, _ text: UnsafeMutablePointer<Unmanaged<CFString>>!) -> CTRubyAnnotation

Declaration
From
func CTRunDelegateCreate(_ callbacks: UnsafePointer<CTRunDelegateCallbacks>, _ refCon: UnsafeMutablePointer<Void>) -> CTRunDelegate?
To
func CTRunDelegateCreate(_ callbacks: UnsafePointer<CTRunDelegateCallbacks>, _ refCon: UnsafeMutableRawPointer?) -> CTRunDelegate?

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

Declaration
From
typealias CTRunDelegateGetAscentCallback = (UnsafeMutablePointer<Void>) -> CGFloat
To
typealias CTRunDelegateGetAscentCallback = (UnsafeMutableRawPointer) -> CGFloat

Declaration
From
typealias CTRunDelegateGetDescentCallback = (UnsafeMutablePointer<Void>) -> CGFloat
To
typealias CTRunDelegateGetDescentCallback = (UnsafeMutableRawPointer) -> CGFloat

Declaration
From
func CTRunDelegateGetRefCon(_ runDelegate: CTRunDelegate) -> UnsafeMutablePointer<Void>
To
func CTRunDelegateGetRefCon(_ runDelegate: CTRunDelegate) -> UnsafeMutableRawPointer

Declaration
From
typealias CTRunDelegateGetWidthCallback = (UnsafeMutablePointer<Void>) -> CGFloat
To
typealias CTRunDelegateGetWidthCallback = (UnsafeMutableRawPointer) -> CGFloat

Declaration
From
func CTRunGetAdvances(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGSize>)
To
func CTRunGetAdvances(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGSize>!)

Declaration
From
func CTRunGetAdvancesPtr(_ run: CTRun) -> UnsafePointer<CGSize>
To
func CTRunGetAdvancesPtr(_ run: CTRun) -> UnsafePointer<CGSize>?

Declaration
From
func CTRunGetGlyphs(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGGlyph>)
To
func CTRunGetGlyphs(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGGlyph>!)

Declaration
From
func CTRunGetGlyphsPtr(_ run: CTRun) -> UnsafePointer<CGGlyph>
To
func CTRunGetGlyphsPtr(_ run: CTRun) -> UnsafePointer<CGGlyph>?

Declaration
From
func CTRunGetPositions(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGPoint>)
To
func CTRunGetPositions(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CGPoint>!)

Declaration
From
func CTRunGetPositionsPtr(_ run: CTRun) -> UnsafePointer<CGPoint>
To
func CTRunGetPositionsPtr(_ run: CTRun) -> UnsafePointer<CGPoint>?

Declaration
From
func CTRunGetStringIndices(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CFIndex>)
To
func CTRunGetStringIndices(_ run: CTRun, _ range: CFRange, _ buffer: UnsafeMutablePointer<CFIndex>!)

Declaration
From
func CTRunGetStringIndicesPtr(_ run: CTRun) -> UnsafePointer<CFIndex>
To
func CTRunGetStringIndicesPtr(_ run: CTRun) -> UnsafePointer<CFIndex>?

Declaration
From
func CTRunGetTypographicBounds(_ run: CTRun, _ range: CFRange, _ ascent: UnsafeMutablePointer<CGFloat>, _ descent: UnsafeMutablePointer<CGFloat>, _ leading: UnsafeMutablePointer<CGFloat>) -> Double
To
func CTRunGetTypographicBounds(_ run: CTRun, _ range: CFRange, _ ascent: UnsafeMutablePointer<CGFloat>?, _ descent: UnsafeMutablePointer<CGFloat>?, _ leading: UnsafeMutablePointer<CGFloat>?) -> Double

Modified KernTableHeaderHandle
Declaration
From
typealias KernTableHeaderHandle = UnsafeMutablePointer<KernTableHeaderPtr>
To
typealias KernTableHeaderHandle = UnsafeMutablePointer<KernTableHeaderPtr?>

Modified KerxTableHeaderHandle
Declaration
From
typealias KerxTableHeaderHandle = UnsafeMutablePointer<KerxTableHeaderPtr>
To
typealias KerxTableHeaderHandle = UnsafeMutablePointer<KerxTableHeaderPtr?>

Modified SFNTLookupTableHandle
Declaration
From
typealias SFNTLookupTableHandle = UnsafeMutablePointer<SFNTLookupTablePtr>
To
typealias SFNTLookupTableHandle = UnsafeMutablePointer<SFNTLookupTablePtr?>

Feedback