Documentation Archive Developer
Search

CoreText Changes for Swift

CoreText

Removed CTFontOptions.Default
Removed CTFontStylisticClass.ClassUnknown
Removed CTFontStylisticClass.UnknownClass
Removed CTFontTableOptions.noOptions
Removed CTParagraphStyleSpecifier.lineSpacing
Removed CTRunStatus.NoStatus
Removed CTUnderlineStyle.None
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 SFNTLookupVectorHeader [struct]
Added SFNTLookupVectorHeader.count
Added SFNTLookupVectorHeader.firstGlyph
Added SFNTLookupVectorHeader.init()
Added SFNTLookupVectorHeader.init(valueSize: UInt16, firstGlyph: UInt16, count: UInt16, values: (UInt8))
Added SFNTLookupVectorHeader.values
Added SFNTLookupVectorHeader.valueSize
Added CTFontManagerCopyAvailableFontFamilyNames() -> CFArray
Added CTFontManagerCopyAvailablePostScriptNames() -> CFArray
Added CTRubyAnnotationCreateWithAttributes(_: CTRubyAlignment, _: CTRubyOverhang, _: CTRubyPosition, _: CFString, _: CFDictionary) -> CTRubyAnnotation
Added kCTBackgroundColorAttributeName
Added kCTHorizontalInVerticalFormsAttributeName
Added kCTRubyAnnotationScaleToFitAttributeName
Added kCTRubyAnnotationSizeFactorAttributeName
Added kCTVersionNumber10_12
Added kKERXValuesAreLong
Added kSFNTLookupVector
Modified CTCharacterCollection [enum]
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 }
}

Modified CTCharacterCollection.adobeCNS1
Declaration
From
case AdobeCNS1
To
case adobeCNS1

Modified CTCharacterCollection.adobeGB1
Declaration
From
case AdobeGB1
To
case adobeGB1

Modified CTCharacterCollection.adobeJapan1
Declaration
From
case AdobeJapan1
To
case adobeJapan1

Modified CTCharacterCollection.adobeJapan2
Declaration
From
case AdobeJapan2
To
case adobeJapan2

Modified CTCharacterCollection.adobeKorea1
Declaration
From
case AdobeKorea1
To
case adobeKorea1

Modified CTCharacterCollection.identityMapping
Declaration
From
case IdentityMapping
To
case identityMapping

Modified CTFontDescriptorMatchingState [enum]
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
}

Modified CTFontDescriptorMatchingState.didBegin
Declaration
From
case DidBegin
To
case didBegin

Modified CTFontDescriptorMatchingState.didFailWithError
Declaration
From
case DidFailWithError
To
case didFailWithError

Modified CTFontDescriptorMatchingState.didFinish
Declaration
From
case DidFinish
To
case didFinish

Modified CTFontDescriptorMatchingState.didFinishDownloading
Declaration
From
case DidFinishDownloading
To
case didFinishDownloading

Modified CTFontDescriptorMatchingState.didMatch
Declaration
From
case DidMatch
To
case didMatch

Modified CTFontDescriptorMatchingState.downloading
Declaration
From
case Downloading
To
case downloading

Modified CTFontDescriptorMatchingState.stalled
Declaration
From
case Stalled
To
case stalled

Modified CTFontDescriptorMatchingState.willBeginDownloading
Declaration
From
case WillBeginDownloading
To
case willBeginDownloading

Modified CTFontDescriptorMatchingState.willBeginQuerying
Declaration
From
case WillBeginQuerying
To
case willBeginQuerying

Modified CTFontFormat [enum]
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
}

Modified CTFontFormat.bitmap
Declaration
From
case Bitmap
To
case bitmap

Modified CTFontFormat.openTypePostScript
Declaration
From
case OpenTypePostScript
To
case openTypePostScript

Modified CTFontFormat.openTypeTrueType
Declaration
From
case OpenTypeTrueType
To
case openTypeTrueType

Modified CTFontFormat.postScript
Declaration
From
case PostScript
To
case postScript

Modified CTFontFormat.trueType
Declaration
From
case TrueType
To
case trueType

Modified CTFontFormat.unrecognized
Declaration
From
case Unrecognized
To
case unrecognized

Modified CTFontManagerAutoActivationSetting [enum]
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
}

Modified CTFontManagerAutoActivationSetting.default
Declaration
From
case Default
To
case `default`

Modified CTFontManagerAutoActivationSetting.disabled
Declaration
From
case Disabled
To
case disabled

Modified CTFontManagerAutoActivationSetting.enabled
Declaration
From
case Enabled
To
case enabled

Modified CTFontManagerAutoActivationSetting.promptUser
Declaration
From
case PromptUser
To
case promptUser

Modified CTFontManagerError [enum]
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
}

Modified CTFontManagerError.alreadyRegistered
Declaration
From
case AlreadyRegistered
To
case alreadyRegistered

Modified CTFontManagerError.fileNotFound
Declaration
From
case FileNotFound
To
case fileNotFound

Modified CTFontManagerError.insufficientPermissions
Declaration
From
case InsufficientPermissions
To
case insufficientPermissions

Modified CTFontManagerError.inUse
Declaration
From
case InUse
To
case inUse

Modified CTFontManagerError.invalidFontData
Declaration
From
case InvalidFontData
To
case invalidFontData

Modified CTFontManagerError.notRegistered
Declaration
From
case NotRegistered
To
case notRegistered

Modified CTFontManagerError.systemRequired
Declaration
From
case SystemRequired
To
case systemRequired

Modified CTFontManagerError.unrecognizedFormat
Declaration
From
case UnrecognizedFormat
To
case unrecognizedFormat

Modified CTFontManagerScope [enum]
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
}

Modified CTFontManagerScope.none
Declaration
From
case None
To
case none

Modified CTFontManagerScope.process
Declaration
From
case Process
To
case process

Modified CTFontManagerScope.session
Declaration
From
case Session
To
case session

Modified CTFontManagerScope.user
Declaration
From
case User
To
case user

Modified CTFontOptions [struct]
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

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

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

Modified CTFontOrientation [enum]
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 }
}

Modified CTFontOrientation.default
Declaration
From
case Default
To
case `default`

Modified CTFontOrientation.horizontal
Declaration
From
case Horizontal
To
case horizontal

Modified CTFontOrientation.vertical
Declaration
From
case Vertical
To
case vertical

Modified CTFontStylisticClass [struct]
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Modified CTFontSymbolicTraits [struct]
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Modified CTFontTableOptions [struct]
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

Modified CTFontUIFontType [enum]
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 }
}

Modified CTFontUIFontType.alertHeader
Declaration
From
case AlertHeader
To
case alertHeader

Modified CTFontUIFontType.application
Declaration
From
case Application
To
case application

Modified CTFontUIFontType.controlContent
Declaration
From
case ControlContent
To
case controlContent

Modified CTFontUIFontType.emphasizedSystem
Declaration
From
case EmphasizedSystem
To
case emphasizedSystem

Modified CTFontUIFontType.emphasizedSystemDetail
Declaration
From
case EmphasizedSystemDetail
To
case emphasizedSystemDetail

Modified CTFontUIFontType.label
Declaration
From
case Label
To
case label

Modified CTFontUIFontType.menuItem
Declaration
From
case MenuItem
To
case menuItem

Modified CTFontUIFontType.menuItemCmdKey
Declaration
From
case MenuItemCmdKey
To
case menuItemCmdKey

Modified CTFontUIFontType.menuItemMark
Declaration
From
case MenuItemMark
To
case menuItemMark

Modified CTFontUIFontType.menuTitle
Declaration
From
case MenuTitle
To
case menuTitle

Modified CTFontUIFontType.message
Declaration
From
case Message
To
case message

Modified CTFontUIFontType.miniEmphasizedSystem
Declaration
From
case MiniEmphasizedSystem
To
case miniEmphasizedSystem

Modified CTFontUIFontType.miniSystem
Declaration
From
case MiniSystem
To
case miniSystem

Modified CTFontUIFontType.none
Declaration
From
case None
To
case none

Modified CTFontUIFontType.palette
Declaration
From
case Palette
To
case palette

Modified CTFontUIFontType.pushButton
Declaration
From
case PushButton
To
case pushButton

Modified CTFontUIFontType.smallEmphasizedSystem
Declaration
From
case SmallEmphasizedSystem
To
case smallEmphasizedSystem

Modified CTFontUIFontType.smallSystem
Declaration
From
case SmallSystem
To
case smallSystem

Modified CTFontUIFontType.smallToolbar
Declaration
From
case SmallToolbar
To
case smallToolbar

Modified CTFontUIFontType.system
Declaration
From
case System
To
case system

Modified CTFontUIFontType.systemDetail
Declaration
From
case SystemDetail
To
case systemDetail

Modified CTFontUIFontType.toolbar
Declaration
From
case Toolbar
To
case toolbar

Modified CTFontUIFontType.toolTip
Declaration
From
case ToolTip
To
case toolTip

Modified CTFontUIFontType.user
Declaration
From
case User
To
case user

Modified CTFontUIFontType.userFixedPitch
Declaration
From
case UserFixedPitch
To
case userFixedPitch

Modified CTFontUIFontType.utilityWindowTitle
Declaration
From
case UtilityWindowTitle
To
case utilityWindowTitle

Modified CTFontUIFontType.views
Declaration
From
case Views
To
case views

Modified CTFontUIFontType.windowTitle
Declaration
From
case WindowTitle
To
case windowTitle

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

Modified CTFramePathFillRule.evenOdd
Declaration
From
case EvenOdd
To
case evenOdd

Modified CTFramePathFillRule.windingNumber
Declaration
From
case WindingNumber
To
case windingNumber

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

Modified CTFrameProgression.leftToRight
Declaration
From
case LeftToRight
To
case leftToRight

Modified CTFrameProgression.rightToLeft
Declaration
From
case RightToLeft
To
case rightToLeft

Modified CTFrameProgression.topToBottom
Declaration
From
case TopToBottom
To
case topToBottom

Modified CTLineBoundsOptions [struct]
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

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

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

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

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

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

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

Modified CTLineBreakMode [enum]
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
}

Modified CTLineBreakMode.byCharWrapping
Declaration
From
case ByCharWrapping
To
case byCharWrapping

Modified CTLineBreakMode.byClipping
Declaration
From
case ByClipping
To
case byClipping

Modified CTLineBreakMode.byTruncatingHead
Declaration
From
case ByTruncatingHead
To
case byTruncatingHead

Modified CTLineBreakMode.byTruncatingMiddle
Declaration
From
case ByTruncatingMiddle
To
case byTruncatingMiddle

Modified CTLineBreakMode.byTruncatingTail
Declaration
From
case ByTruncatingTail
To
case byTruncatingTail

Modified CTLineBreakMode.byWordWrapping
Declaration
From
case ByWordWrapping
To
case byWordWrapping

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

Modified CTLineTruncationType.end
Declaration
From
case End
To
case end

Modified CTLineTruncationType.middle
Declaration
From
case Middle
To
case middle

Modified CTLineTruncationType.start
Declaration
From
case Start
To
case start

Modified CTParagraphStyleSetting [struct]
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
}

Modified CTParagraphStyleSetting.value
Declaration
From
var value: UnsafePointer<Void>
To
var value: UnsafeRawPointer

Modified CTParagraphStyleSpecifier [enum]
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
}

Modified CTParagraphStyleSpecifier.alignment
Declaration
From
case Alignment
To
case alignment

Modified CTParagraphStyleSpecifier.baseWritingDirection
Declaration
From
case BaseWritingDirection
To
case baseWritingDirection

Modified CTParagraphStyleSpecifier.count
Declaration
From
case Count
To
case count

Modified CTParagraphStyleSpecifier.defaultTabInterval
Declaration
From
case DefaultTabInterval
To
case defaultTabInterval

Modified CTParagraphStyleSpecifier.firstLineHeadIndent
Declaration
From
case FirstLineHeadIndent
To
case firstLineHeadIndent

Modified CTParagraphStyleSpecifier.headIndent
Declaration
From
case HeadIndent
To
case headIndent

Modified CTParagraphStyleSpecifier.lineBoundsOptions
Declaration
From
case LineBoundsOptions
To
case lineBoundsOptions

Modified CTParagraphStyleSpecifier.lineBreakMode
Declaration
From
case LineBreakMode
To
case lineBreakMode

Modified CTParagraphStyleSpecifier.lineHeightMultiple
Declaration
From
case LineHeightMultiple
To
case lineHeightMultiple

Modified CTParagraphStyleSpecifier.lineSpacingAdjustment
Declaration
From
case LineSpacingAdjustment
To
case lineSpacingAdjustment

Modified CTParagraphStyleSpecifier.maximumLineHeight
Declaration
From
case MaximumLineHeight
To
case maximumLineHeight

Modified CTParagraphStyleSpecifier.maximumLineSpacing
Declaration
From
case MaximumLineSpacing
To
case maximumLineSpacing

Modified CTParagraphStyleSpecifier.minimumLineHeight
Declaration
From
case MinimumLineHeight
To
case minimumLineHeight

Modified CTParagraphStyleSpecifier.minimumLineSpacing
Declaration
From
case MinimumLineSpacing
To
case minimumLineSpacing

Modified CTParagraphStyleSpecifier.paragraphSpacing
Declaration
From
case ParagraphSpacing
To
case paragraphSpacing

Modified CTParagraphStyleSpecifier.paragraphSpacingBefore
Declaration
From
case ParagraphSpacingBefore
To
case paragraphSpacingBefore

Modified CTParagraphStyleSpecifier.tabStops
Declaration
From
case TabStops
To
case tabStops

Modified CTParagraphStyleSpecifier.tailIndent
Declaration
From
case TailIndent
To
case tailIndent

Modified CTRubyAlignment [enum]
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
}

Modified CTRubyAlignment.auto
Declaration
From
case Auto
To
case auto

Modified CTRubyAlignment.center
Declaration
From
case Center
To
case center

Modified CTRubyAlignment.distributeLetter
Declaration
From
case DistributeLetter
To
case distributeLetter

Modified CTRubyAlignment.distributeSpace
Declaration
From
case DistributeSpace
To
case distributeSpace

Modified CTRubyAlignment.end
Declaration
From
case End
To
case end

Modified CTRubyAlignment.invalid
Declaration
From
case Invalid
To
case invalid

Modified CTRubyAlignment.lineEdge
Declaration
From
case LineEdge
To
case lineEdge

Modified CTRubyAlignment.start
Declaration
From
case Start
To
case start

Modified CTRubyOverhang [enum]
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
}

Modified CTRubyOverhang.auto
Declaration
From
case Auto
To
case auto

Modified CTRubyOverhang.end
Declaration
From
case End
To
case end

Modified CTRubyOverhang.invalid
Declaration
From
case Invalid
To
case invalid

Modified CTRubyOverhang.none
Declaration
From
case None
To
case none

Modified CTRubyOverhang.start
Declaration
From
case Start
To
case start

Modified CTRubyPosition [enum]
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
}

Modified CTRubyPosition.after
Declaration
From
case After
To
case after

Modified CTRubyPosition.before
Declaration
From
case Before
To
case before

Modified CTRubyPosition.count
Declaration
From
case Count
To
case count

Modified CTRubyPosition.inline
Declaration
From
case Inline
To
case inline

Modified CTRubyPosition.interCharacter
Declaration
From
case InterCharacter
To
case interCharacter

Modified CTRunDelegateCallbacks [struct]
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
}

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

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

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

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

Modified CTRunStatus [struct]
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

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

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

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

Modified CTTextAlignment [enum]
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 }
}

Modified CTTextAlignment.center
Declaration
From
case Center
To
case center

Modified CTTextAlignment.justified
Declaration
From
case Justified
To
case justified

Modified CTTextAlignment.left
Declaration
From
case Left
To
case left

Modified CTTextAlignment.natural
Declaration
From
case Natural
To
case natural

Modified CTTextAlignment.right
Declaration
From
case Right
To
case right

Modified CTUnderlineStyle [struct]
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

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

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

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

Modified CTUnderlineStyleModifiers [struct]
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

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

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

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

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

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

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

Modified CTWritingDirection.leftToRight
Declaration
From
case LeftToRight
To
case leftToRight

Modified CTWritingDirection.natural
Declaration
From
case Natural
To
case natural

Modified CTWritingDirection.rightToLeft
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()
}

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

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

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

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

Modified CTFontCopyLocalizedName(_: CTFont, _: CFString, _: UnsafeMutablePointer<Unmanaged<CFString>?>?) -> CFString?
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?

Modified CTFontCreateCopyWithAttributes(_: CTFont, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CTFontDescriptor?) -> CTFont
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

Modified CTFontCreateCopyWithFamily(_: CTFont, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CFString) -> 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?

Modified CTFontCreateCopyWithSymbolicTraits(_: CTFont, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CTFontSymbolicTraits, _: CTFontSymbolicTraits) -> 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?

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

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

Modified CTFontCreateWithFontDescriptorAndOptions(_: CTFontDescriptor, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CTFontOptions) -> 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

Modified CTFontCreateWithGraphicsFont(_: CGFont, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CTFontDescriptor?) -> 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

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

Modified CTFontCreateWithNameAndOptions(_: CFString, _: CGFloat, _: UnsafePointer<CGAffineTransform>?, _: CTFontOptions) -> 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

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

Modified CTFontDescriptorCopyLocalizedAttribute(_: CTFontDescriptor, _: CFString, _: UnsafeMutablePointer<Unmanaged<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?

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

Modified CTFontDrawGlyphs(_: CTFont, _: UnsafePointer<CGGlyph>!, _: UnsafePointer<CGPoint>!, _: Int, _: CGContext)
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)

Modified CTFontGetAdvancesForGlyphs(_: CTFont, _: CTFontOrientation, _: UnsafePointer<CGGlyph>!, _: UnsafeMutablePointer<CGSize>?, _: CFIndex) -> Double
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

Modified CTFontGetBoundingRectsForGlyphs(_: CTFont, _: CTFontOrientation, _: UnsafePointer<CGGlyph>!, _: UnsafeMutablePointer<CGRect>?, _: CFIndex) -> CGRect
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

Modified CTFontGetGlyphsForCharacters(_: CTFont, _: UnsafePointer<UniChar>!, _: UnsafeMutablePointer<CGGlyph>!, _: CFIndex) -> Bool
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

Modified CTFontGetLigatureCaretPositions(_: CTFont, _: CGGlyph, _: UnsafeMutablePointer<CGFloat>?, _: CFIndex) -> CFIndex
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

Modified CTFontGetOpticalBoundsForGlyphs(_: CTFont, _: UnsafePointer<CGGlyph>!, _: UnsafeMutablePointer<CGRect>?, _: CFIndex, _: CFOptionFlags) -> CGRect
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

Modified CTFontGetVerticalTranslationsForGlyphs(_: CTFont, _: UnsafePointer<CGGlyph>!, _: UnsafeMutablePointer<CGSize>!, _: CFIndex)
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)

Modified CTFontManagerRegisterFontsForURL(_: CFURL, _: CTFontManagerScope, _: UnsafeMutablePointer<Unmanaged<CFError>?>?) -> Bool
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

Modified CTFontManagerRegisterFontsForURLs(_: CFArray, _: CTFontManagerScope, _: UnsafeMutablePointer<Unmanaged<CFArray>?>?) -> 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

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

Modified CTFontManagerUnregisterFontsForURL(_: CFURL, _: CTFontManagerScope, _: 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

Modified CTFontManagerUnregisterFontsForURLs(_: CFArray, _: CTFontManagerScope, _: UnsafeMutablePointer<Unmanaged<CFArray>?>?) -> 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

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

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

Modified CTFramesetterSuggestFrameSizeWithConstraints(_: CTFramesetter, _: CFRange, _: CFDictionary?, _: CGSize, _: UnsafeMutablePointer<CFRange>?) -> CGSize
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

Modified CTLineEnumerateCaretOffsets(_: CTLine, _: (Double, CFIndex, Bool, UnsafeMutablePointer<Bool>) -> Swift.Void)
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)

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

Modified CTLineGetTypographicBounds(_: CTLine, _: UnsafeMutablePointer<CGFloat>?, _: UnsafeMutablePointer<CGFloat>?, _: UnsafeMutablePointer<CGFloat>?) -> Double
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

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

Modified CTParagraphStyleGetValueForSpecifier(_: CTParagraphStyle, _: CTParagraphStyleSpecifier, _: Int, _: UnsafeMutableRawPointer) -> Bool
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

Modified CTRubyAnnotationCreate(_: CTRubyAlignment, _: CTRubyOverhang, _: CGFloat, _: UnsafeMutablePointer<Unmanaged<CFString>>!) -> CTRubyAnnotation
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Modified CTRunGetTypographicBounds(_: CTRun, _: CFRange, _: UnsafeMutablePointer<CGFloat>?, _: UnsafeMutablePointer<CGFloat>?, _: UnsafeMutablePointer<CGFloat>?) -> Double
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?>