Rename package and address warnings
This commit is contained in:
Guille Gonzalez
160
Sources/SwiftUIMath/MathBundle/MTFontMathTableV2.swift
Executable file
160
Sources/SwiftUIMath/MathBundle/MTFontMathTableV2.swift
Executable file
@@ -0,0 +1,160 @@
|
||||
//
|
||||
// MTFontMathTableV2.swift
|
||||
//
|
||||
//
|
||||
// Created by Peter Tang on 15/9/2023.
|
||||
//
|
||||
|
||||
import Foundation
|
||||
import CoreGraphics
|
||||
import CoreText
|
||||
|
||||
internal class MTFontMathTableV2: MTFontMathTable {
|
||||
private let mathFont: MathFont
|
||||
private let fontSize: CGFloat
|
||||
private let unitsPerEm: UInt
|
||||
private let mTable: NSDictionary
|
||||
init(mathFont: MathFont, size: CGFloat, unitsPerEm: UInt) {
|
||||
self.mathFont = mathFont
|
||||
self.fontSize = size
|
||||
self.unitsPerEm = unitsPerEm
|
||||
mTable = mathFont.rawMathTable()
|
||||
super.init(withFont: mathFont.mtfont(size: fontSize), mathTable: mTable)
|
||||
super._mathTable = nil
|
||||
// disable all possible access to _mathTable in superclass!
|
||||
}
|
||||
override var _mathTable: NSDictionary? {
|
||||
set { fatalError("\(#function) change to _mathTable \(mathFont.rawValue) not allowed.") }
|
||||
get { mTable }
|
||||
}
|
||||
override var muUnit: CGFloat { fontSize/18 }
|
||||
|
||||
override func fontUnitsToPt(_ fontUnits:Int) -> CGFloat {
|
||||
CGFloat(fontUnits) * fontSize / CGFloat(unitsPerEm)
|
||||
}
|
||||
override func constantFromTable(_ constName: String) -> CGFloat {
|
||||
guard let consts = mTable[kConstants] as? NSDictionary, let val = consts[constName] as? NSNumber else {
|
||||
return .zero
|
||||
}
|
||||
return fontUnitsToPt(val.intValue)
|
||||
}
|
||||
override func percentFromTable(_ percentName: String) -> CGFloat {
|
||||
guard let consts = mTable[kConstants] as? NSDictionary, let val = consts[percentName] as? NSNumber else {
|
||||
return .zero
|
||||
}
|
||||
return CGFloat(val.floatValue) / 100
|
||||
}
|
||||
/** Returns an Array of all the vertical variants of the glyph if any. If
|
||||
there are no variants for the glyph, the array contains the given glyph. */
|
||||
override func getVerticalVariantsForGlyph(_ glyph: CGGlyph) -> [NSNumber?] {
|
||||
guard let variants = mTable[kVertVariants] as? NSDictionary else { return [] }
|
||||
return self.getVariantsForGlyph(glyph, inDictionary: variants)
|
||||
}
|
||||
/** Returns an Array of all the horizontal variants of the glyph if any. If
|
||||
there are no variants for the glyph, the array contains the given glyph. */
|
||||
override func getHorizontalVariantsForGlyph(_ glyph: CGGlyph) -> [NSNumber?] {
|
||||
guard let variants = mTable[kHorizVariants] as? NSDictionary else { return [] }
|
||||
return self.getVariantsForGlyph(glyph, inDictionary:variants)
|
||||
}
|
||||
override func getVariantsForGlyph(_ glyph: CGGlyph, inDictionary variants: NSDictionary) -> [NSNumber?] {
|
||||
let font = mathFont.mtfont(size: fontSize)
|
||||
let glyphName = font.get(nameForGlyph: glyph)
|
||||
|
||||
var glyphArray = [NSNumber]()
|
||||
let variantGlyphs = variants[glyphName] as? NSArray
|
||||
|
||||
guard let variantGlyphs = variantGlyphs, variantGlyphs.count != .zero else {
|
||||
// There are no extra variants, so just add the current glyph to it.
|
||||
let glyph = font.get(glyphWithName: glyphName)
|
||||
glyphArray.append(NSNumber(value:glyph))
|
||||
return glyphArray
|
||||
}
|
||||
for gvn in variantGlyphs {
|
||||
if let glyphVariantName = gvn as? String {
|
||||
let variantGlyph = font.get(glyphWithName: glyphVariantName)
|
||||
glyphArray.append(NSNumber(value:variantGlyph))
|
||||
}
|
||||
}
|
||||
return glyphArray
|
||||
}
|
||||
/** Returns a larger vertical variant of the given glyph if any.
|
||||
If there is no larger version, this returns the current glyph.
|
||||
*/
|
||||
override func getLargerGlyph(_ glyph: CGGlyph) -> CGGlyph {
|
||||
let font = mathFont.mtfont(size: fontSize)
|
||||
let glyphName = font.get(nameForGlyph: glyph)
|
||||
|
||||
guard let variants = mTable[kVertVariants] as? NSDictionary,
|
||||
let variantGlyphs = variants[glyphName] as? NSArray, variantGlyphs.count != .zero else {
|
||||
// There are no extra variants, so just returnt the current glyph.
|
||||
return glyph
|
||||
}
|
||||
// Find the first variant with a different name.
|
||||
for gvn in variantGlyphs {
|
||||
if let glyphVariantName = gvn as? String, glyphVariantName != glyphName {
|
||||
let variantGlyph = font.get(glyphWithName: glyphVariantName)
|
||||
return variantGlyph
|
||||
}
|
||||
}
|
||||
// We did not find any variants of this glyph so return it.
|
||||
return glyph
|
||||
}
|
||||
/** Returns the italic correction for the given glyph if any. If there
|
||||
isn't any this returns 0. */
|
||||
override func getItalicCorrection(_ glyph: CGGlyph) -> CGFloat {
|
||||
let font = mathFont.mtfont(size: fontSize)
|
||||
let glyphName = font.get(nameForGlyph: glyph)
|
||||
|
||||
guard let italics = mTable[kItalic] as? NSDictionary, let val = italics[glyphName] as? NSNumber else {
|
||||
return .zero
|
||||
}
|
||||
// if val is nil, this returns 0.
|
||||
return fontUnitsToPt(val.intValue)
|
||||
}
|
||||
override func getTopAccentAdjustment(_ glyph: CGGlyph) -> CGFloat {
|
||||
let font = mathFont.mtfont(size: fontSize)
|
||||
let glyphName = font.get(nameForGlyph: glyph)
|
||||
|
||||
guard let accents = mTable[kAccents] as? NSDictionary, let val = accents[glyphName] as? NSNumber else {
|
||||
// If no top accent is defined then it is the center of the advance width.
|
||||
var glyph = glyph
|
||||
var advances = CGSize.zero
|
||||
CTFontGetAdvancesForGlyphs(font.ctFont, .horizontal, &glyph, &advances, 1)
|
||||
return advances.width/2
|
||||
}
|
||||
return fontUnitsToPt(val.intValue)
|
||||
}
|
||||
override func getVerticalGlyphAssembly(forGlyph glyph: CGGlyph) -> [GlyphPart] {
|
||||
let font = mathFont.mtfont(size: fontSize)
|
||||
let glyphName = font.get(nameForGlyph: glyph)
|
||||
|
||||
guard let assemblyTable = mTable[kVertAssembly] as? NSDictionary,
|
||||
let assemblyInfo = assemblyTable[glyphName] as? NSDictionary,
|
||||
let parts = assemblyInfo[kAssemblyParts] as? NSArray else {
|
||||
// No vertical assembly defined for glyph
|
||||
// parts should always have been defined, but if it isn't return nil
|
||||
return []
|
||||
}
|
||||
|
||||
var rv = [GlyphPart]()
|
||||
for part in parts {
|
||||
guard let partInfo = part as? NSDictionary,
|
||||
let adv = partInfo["advance"] as? NSNumber,
|
||||
let end = partInfo["endConnector"] as? NSNumber,
|
||||
let start = partInfo["startConnector"] as? NSNumber,
|
||||
let ext = partInfo["extender"] as? NSNumber,
|
||||
let glyphName = partInfo["glyph"] as? String else { continue }
|
||||
let fullAdvance = fontUnitsToPt(adv.intValue)
|
||||
let endConnectorLength = fontUnitsToPt(end.intValue)
|
||||
let startConnectorLength = fontUnitsToPt(start.intValue)
|
||||
let isExtender = ext.boolValue
|
||||
let glyph = font.get(glyphWithName: glyphName)
|
||||
let part = GlyphPart(glyph: glyph, fullAdvance: fullAdvance,
|
||||
startConnectorLength: startConnectorLength,
|
||||
endConnectorLength: endConnectorLength,
|
||||
isExtender: isExtender)
|
||||
rv.append(part)
|
||||
}
|
||||
return rv
|
||||
}
|
||||
}
|
||||
68
Sources/SwiftUIMath/MathBundle/MTFontV2.swift
Executable file
68
Sources/SwiftUIMath/MathBundle/MTFontV2.swift
Executable file
@@ -0,0 +1,68 @@
|
||||
//
|
||||
// MTFontV2.swift
|
||||
//
|
||||
//
|
||||
// Created by Peter Tang on 15/9/2023.
|
||||
//
|
||||
|
||||
import Foundation
|
||||
import CoreGraphics
|
||||
import CoreText
|
||||
|
||||
extension MathFont {
|
||||
public func mtfont(size: CGFloat) -> MTFontV2 {
|
||||
MTFontV2(font: self, size: size)
|
||||
}
|
||||
}
|
||||
public final class MTFontV2: MTFont {
|
||||
let font: MathFont
|
||||
let size: CGFloat
|
||||
private let _cgFont: CGFont
|
||||
private let _ctFont: CTFont
|
||||
private let unitsPerEm: UInt
|
||||
private var _mathTab: MTFontMathTableV2?
|
||||
init(font: MathFont = .latinModernFont, size: CGFloat) {
|
||||
self.font = font
|
||||
self.size = size
|
||||
// MathFont cgfont and ctfont are fast & threadsafe, keep a local copy is cheaper than
|
||||
// handling via NSLock
|
||||
self._cgFont = font.cgFont()
|
||||
self._ctFont = font.ctFont(withSize: size)
|
||||
self.unitsPerEm = self._ctFont.unitsPerEm
|
||||
super.init()
|
||||
|
||||
super.defaultCGFont = nil
|
||||
super.ctFont = nil
|
||||
super.mathTable = nil
|
||||
super.rawMathTable = nil
|
||||
}
|
||||
override var defaultCGFont: CGFont! {
|
||||
set { fatalError("\(#function): change to \(font.fontName) not allowed.") }
|
||||
get { _cgFont }
|
||||
}
|
||||
override var ctFont: CTFont! {
|
||||
set { fatalError("\(#function): change to \(font.fontName) not allowed.") }
|
||||
get { _ctFont }
|
||||
}
|
||||
private let mtfontV2LockOnMathTable = NSLock()
|
||||
override var mathTable: MTFontMathTable? {
|
||||
set { fatalError("\(#function): change to \(font.rawValue) not allowed.") }
|
||||
get {
|
||||
guard _mathTab == nil else { return _mathTab }
|
||||
//Note: lazy _mathTab initialization is now threadsafe.
|
||||
mtfontV2LockOnMathTable.lock()
|
||||
defer { mtfontV2LockOnMathTable.unlock() }
|
||||
if _mathTab == nil {
|
||||
_mathTab = MTFontMathTableV2(mathFont: font, size: size, unitsPerEm: unitsPerEm)
|
||||
}
|
||||
return _mathTab
|
||||
}
|
||||
}
|
||||
override var rawMathTable: NSDictionary? {
|
||||
set { fatalError("\(#function): change to \(font.rawValue) not allowed.") }
|
||||
get { fatalError("\(#function): access to \(font.rawValue) not allowed.") }
|
||||
}
|
||||
public override func copy(withSize size: CGFloat) -> MTFont {
|
||||
MTFontV2(font: font, size: size)
|
||||
}
|
||||
}
|
||||
225
Sources/SwiftUIMath/MathBundle/MathFont.swift
Normal file
225
Sources/SwiftUIMath/MathBundle/MathFont.swift
Normal file
@@ -0,0 +1,225 @@
|
||||
//
|
||||
// MathFont.swift
|
||||
//
|
||||
//
|
||||
// Created by Peter Tang on 10/9/2023.
|
||||
//
|
||||
|
||||
#if os(iOS) || os(visionOS)
|
||||
import UIKit
|
||||
#elseif os(macOS)
|
||||
import AppKit
|
||||
#endif
|
||||
|
||||
/// Now available for everyone to use
|
||||
public enum MathFont: String, CaseIterable, Identifiable {
|
||||
|
||||
public var id: Self { self } // Makes things simpler for SwiftUI
|
||||
|
||||
case latinModernFont = "latinmodern-math"
|
||||
case kpMathLightFont = "KpMath-Light"
|
||||
case kpMathSansFont = "KpMath-Sans"
|
||||
case xitsFont = "xits-math"
|
||||
case termesFont = "texgyretermes-math"
|
||||
case asanaFont = "Asana-Math"
|
||||
case eulerFont = "Euler-Math"
|
||||
case firaFont = "FiraMath-Regular"
|
||||
case notoSansFont = "NotoSansMath-Regular"
|
||||
case libertinusFont = "LibertinusMath-Regular"
|
||||
case garamondFont = "Garamond-Math"
|
||||
case leteSansFont = "LeteSansMath"
|
||||
|
||||
var fontFamilyName: String {
|
||||
switch self {
|
||||
case .latinModernFont: "Latin Modern Math"
|
||||
case .kpMathLightFont: "KpMath"
|
||||
case .kpMathSansFont: "KpMath"
|
||||
case .xitsFont: "XITS Math"
|
||||
case .termesFont: "TeX Gyre Termes Math"
|
||||
case .asanaFont: "Asana Math"
|
||||
case .eulerFont: "Euler Math"
|
||||
case .firaFont: "Fira Math"
|
||||
case .notoSansFont: "Noto Sans Math"
|
||||
case .libertinusFont: "Libertinus Math"
|
||||
case .garamondFont: "Garamond-Math" // PostScript name is "Garamond-Math", not "Garamond Math"
|
||||
case .leteSansFont: "Lete Sans Math"
|
||||
}
|
||||
}
|
||||
|
||||
var postScriptName: String {
|
||||
switch self {
|
||||
case .latinModernFont: "LatinModernMath-Regular"
|
||||
case .kpMathLightFont: "KpMath-Light"
|
||||
case .kpMathSansFont: "KpMath-Sans"
|
||||
case .xitsFont: "XITSMath"
|
||||
case .termesFont: "TeXGyreTermesMath-Regular"
|
||||
case .asanaFont: "Asana-Math"
|
||||
case .eulerFont: "Euler-Math"
|
||||
case .firaFont: "FiraMath-Regular"
|
||||
case .notoSansFont: "NotoSansMath-Regular"
|
||||
case .libertinusFont: "LibertinusMath-Regular"
|
||||
case .garamondFont: "Garamond-Math"
|
||||
case .leteSansFont: "LeteSansMath"
|
||||
}
|
||||
}
|
||||
|
||||
var fontName: String { self.rawValue }
|
||||
|
||||
public func cgFont() -> CGFont {
|
||||
BundleManager.manager.obtainCGFont(font: self)
|
||||
}
|
||||
public func ctFont(withSize size: CGFloat) -> CTFont {
|
||||
BundleManager.manager.obtainCTFont(font: self, withSize: size)
|
||||
}
|
||||
internal func rawMathTable() -> NSDictionary {
|
||||
BundleManager.manager.obtainRawMathTable(font: self)
|
||||
}
|
||||
|
||||
//Note: Below code are no longer supported, unable to tell if UIFont/NSFont is threadsafe, not used in SwiftMath.
|
||||
// #if os(iOS) || os(visionOS)
|
||||
// public func uiFont(withSize size: CGFloat) -> UIFont? {
|
||||
// UIFont(name: fontName, size: size)
|
||||
// }
|
||||
// #endif
|
||||
// #if os(macOS)
|
||||
// public func nsFont(withSize size: CGFloat) -> NSFont? {
|
||||
// NSFont(name: fontName, size: size)
|
||||
// }
|
||||
// #endif
|
||||
}
|
||||
internal extension CTFont {
|
||||
/** The size of this font in points. */
|
||||
var fontSize: CGFloat {
|
||||
CTFontGetSize(self)
|
||||
}
|
||||
var unitsPerEm: UInt {
|
||||
return UInt(CTFontGetUnitsPerEm(self))
|
||||
}
|
||||
}
|
||||
private class BundleManager {
|
||||
//Note: below should be lightweight and without threadsafe problem.
|
||||
static internal let manager = BundleManager()
|
||||
|
||||
private var cgFonts = [MathFont: CGFont]()
|
||||
private var ctFonts = [CTFontSizePair: CTFont]()
|
||||
private var rawMathTables = [MathFont: NSDictionary]()
|
||||
|
||||
private let threadSafeQueue = DispatchQueue(label: "com.smartmath.mathfont.threadsafequeue",
|
||||
qos: .userInitiated,
|
||||
attributes: .concurrent)
|
||||
|
||||
private func registerCGFont(mathFont: MathFont) throws {
|
||||
guard let frameworkBundleURL = Bundle.module.url(forResource: "mathFonts", withExtension: "bundle"),
|
||||
let resourceBundleURL = Bundle(url: frameworkBundleURL)?.path(forResource: mathFont.rawValue, ofType: "otf") else {
|
||||
throw FontError.fontPathNotFound
|
||||
}
|
||||
guard let fontData = NSData(contentsOfFile: resourceBundleURL), let dataProvider = CGDataProvider(data: fontData) else {
|
||||
throw FontError.invalidFontFile
|
||||
}
|
||||
guard let defaultCGFont = CGFont(dataProvider) else {
|
||||
throw FontError.initFontError
|
||||
}
|
||||
|
||||
cgFonts[mathFont] = defaultCGFont
|
||||
|
||||
/// This does not load the complete math font, it only has about half the glyphs of the full math font.
|
||||
/// In particular it does not have the math italic characters which breaks our variable rendering.
|
||||
/// So we first load a CGFont from the file and then convert it to a CTFont.
|
||||
var errorRef: Unmanaged<CFError>? = nil
|
||||
guard CTFontManagerRegisterGraphicsFont(defaultCGFont, &errorRef) else {
|
||||
throw FontError.registerFailed
|
||||
}
|
||||
let postsript = (defaultCGFont.postScriptName as? String) ?? ""
|
||||
let cgfontName = (defaultCGFont.fullName as? String) ?? ""
|
||||
let threadName = Thread.isMainThread ? "main" : "global"
|
||||
debugPrint("mathFonts bundle resource: \(mathFont.rawValue), font: \(cgfontName), ps: \(postsript) registered on \(threadName).")
|
||||
}
|
||||
|
||||
private func registerMathTable(mathFont: MathFont) throws {
|
||||
guard let frameworkBundleURL = Bundle.module.url(forResource: "mathFonts", withExtension: "bundle"),
|
||||
let mathTablePlist = Bundle(url: frameworkBundleURL)?.url(forResource: mathFont.rawValue, withExtension:"plist") else {
|
||||
throw FontError.fontPathNotFound
|
||||
}
|
||||
guard let rawMathTable = NSDictionary(contentsOf: mathTablePlist),
|
||||
let version = rawMathTable["version"] as? String,
|
||||
version == "1.3" else {
|
||||
throw FontError.invalidMathTable
|
||||
}
|
||||
|
||||
rawMathTables[mathFont] = rawMathTable
|
||||
|
||||
let threadName = Thread.isMainThread ? "main" : "global"
|
||||
debugPrint("mathFonts bundle resource: \(mathFont.rawValue).plist registered on \(threadName).")
|
||||
}
|
||||
|
||||
private func onDemandRegistration(mathFont: MathFont) {
|
||||
guard threadSafeQueue.sync(execute: { cgFonts[mathFont] }) == nil else { return }
|
||||
// Note: resourceLoading is now serialized.
|
||||
threadSafeQueue.sync(flags: .barrier, execute: { [weak self] in
|
||||
if self?.cgFonts[mathFont] == nil {
|
||||
do {
|
||||
try BundleManager.manager.registerCGFont(mathFont: mathFont)
|
||||
try BundleManager.manager.registerMathTable(mathFont: mathFont)
|
||||
|
||||
} catch {
|
||||
fatalError("MTMathFonts:\(#function) ondemand loading failed, mathFont \(mathFont.rawValue), reason \(error)")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
fileprivate func obtainCGFont(font: MathFont) -> CGFont {
|
||||
onDemandRegistration(mathFont: font)
|
||||
guard let cgFont = threadSafeQueue.sync(execute: { cgFonts[font] }) else {
|
||||
fatalError("\(#function) unable to locate CGFont \(font.fontName)")
|
||||
}
|
||||
return cgFont
|
||||
}
|
||||
|
||||
fileprivate func obtainCTFont(font: MathFont, withSize size: CGFloat) -> CTFont {
|
||||
onDemandRegistration(mathFont: font)
|
||||
let fontSizePair = CTFontSizePair(font: font, size: size)
|
||||
let ctFont = threadSafeQueue.sync(execute: { ctFonts[fontSizePair] })
|
||||
guard ctFont == nil else { return ctFont! }
|
||||
guard let cgFont = threadSafeQueue.sync(execute: { cgFonts[font] }) else {
|
||||
fatalError("\(#function) unable to locate CGFont \(font.fontName) to create CTFont")
|
||||
}
|
||||
//Note: ctfont creation and caching is now threadsafe.
|
||||
guard threadSafeQueue.sync(execute: { ctFonts[fontSizePair] }) == nil else { return ctFonts[fontSizePair]! }
|
||||
return threadSafeQueue.sync(flags: .barrier, execute: {
|
||||
if let ctfont = ctFonts[fontSizePair] {
|
||||
return ctfont
|
||||
} else {
|
||||
let result = CTFontCreateWithGraphicsFont(cgFont, size, nil, nil)
|
||||
ctFonts[fontSizePair] = result
|
||||
return result
|
||||
}
|
||||
})
|
||||
}
|
||||
fileprivate func obtainRawMathTable(font: MathFont) -> NSDictionary {
|
||||
onDemandRegistration(mathFont: font)
|
||||
guard let mathTable = threadSafeQueue.sync(execute: { rawMathTables[font] } ) else {
|
||||
fatalError("\(#function) unable to locate mathTable: \(font.rawValue).plist")
|
||||
}
|
||||
return mathTable
|
||||
}
|
||||
deinit {
|
||||
ctFonts.removeAll()
|
||||
var errorRef: Unmanaged<CFError>? = nil
|
||||
cgFonts.values.forEach { cgFont in
|
||||
CTFontManagerUnregisterGraphicsFont(cgFont, &errorRef)
|
||||
}
|
||||
cgFonts.removeAll()
|
||||
}
|
||||
public enum FontError: Error {
|
||||
case invalidFontFile
|
||||
case fontPathNotFound
|
||||
case initFontError
|
||||
case registerFailed
|
||||
case invalidMathTable
|
||||
}
|
||||
|
||||
private struct CTFontSizePair: Hashable {
|
||||
let font: MathFont
|
||||
let size: CGFloat
|
||||
}
|
||||
}
|
||||
123
Sources/SwiftUIMath/MathBundle/MathImage.swift
Executable file
123
Sources/SwiftUIMath/MathBundle/MathImage.swift
Executable file
@@ -0,0 +1,123 @@
|
||||
//
|
||||
// MathImage.swift
|
||||
//
|
||||
//
|
||||
// Created by Peter Tang on 15/9/2023.
|
||||
//
|
||||
|
||||
import Foundation
|
||||
|
||||
#if os(iOS) || os(visionOS)
|
||||
import UIKit
|
||||
#elseif os(macOS)
|
||||
import AppKit
|
||||
#endif
|
||||
|
||||
public struct MathImage {
|
||||
public var font: MathFont = .latinModernFont
|
||||
public var fontSize: CGFloat
|
||||
public var textColor: MTColor
|
||||
|
||||
public var labelMode: MTMathUILabelMode
|
||||
public var textAlignment: MTTextAlignment
|
||||
|
||||
public var contentInsets: MTEdgeInsets = MTEdgeInsetsZero
|
||||
|
||||
public let latex: String
|
||||
|
||||
private(set) var intrinsicContentSize = CGSize.zero
|
||||
|
||||
public init(latex: String, fontSize: CGFloat, textColor: MTColor, labelMode: MTMathUILabelMode = .display, textAlignment: MTTextAlignment = .center) {
|
||||
self.latex = latex
|
||||
self.fontSize = fontSize
|
||||
self.textColor = textColor
|
||||
self.labelMode = labelMode
|
||||
self.textAlignment = textAlignment
|
||||
}
|
||||
}
|
||||
extension MathImage {
|
||||
public var currentStyle: MTLineStyle {
|
||||
switch labelMode {
|
||||
case .display: return .display
|
||||
case .text: return .text
|
||||
}
|
||||
}
|
||||
private func intrinsicContentSize(_ displayList: MTMathListDisplay) -> CGSize {
|
||||
CGSize(width: displayList.width + contentInsets.left + contentInsets.right,
|
||||
height: displayList.ascent + displayList.descent + contentInsets.top + contentInsets.bottom)
|
||||
}
|
||||
public struct LayoutInfo {
|
||||
public var ascent: CGFloat = 0
|
||||
public var descent: CGFloat = 0
|
||||
|
||||
public init(ascent: CGFloat, descent: CGFloat) {
|
||||
self.ascent = ascent
|
||||
self.descent = descent
|
||||
}
|
||||
}
|
||||
public mutating func asImage() -> (NSError?, MTImage?, LayoutInfo?) {
|
||||
func layoutImage(size: CGSize, displayList: MTMathListDisplay) {
|
||||
var textX = CGFloat(0)
|
||||
switch self.textAlignment {
|
||||
case .left: textX = contentInsets.left
|
||||
case .center: textX = (size.width - contentInsets.left - contentInsets.right - displayList.width) / 2 + contentInsets.left
|
||||
case .right: textX = size.width - displayList.width - contentInsets.right
|
||||
}
|
||||
let availableHeight = size.height - contentInsets.bottom - contentInsets.top
|
||||
|
||||
// center things vertically
|
||||
var height = displayList.ascent + displayList.descent
|
||||
if height < fontSize/2 {
|
||||
height = fontSize/2 // set height to half the font size
|
||||
}
|
||||
let textY = (availableHeight - height) / 2 + displayList.descent + contentInsets.bottom
|
||||
displayList.position = CGPoint(x: textX, y: textY)
|
||||
}
|
||||
var error: NSError?
|
||||
let mtfont: MTFont? = font.mtfont(size: fontSize)
|
||||
|
||||
guard let mathList = MTMathListBuilder.build(fromString: latex, error: &error), error == nil,
|
||||
let displayList = MTTypesetter.createLineForMathList(mathList, font: mtfont, style: currentStyle) else {
|
||||
return (error, nil, nil)
|
||||
}
|
||||
|
||||
intrinsicContentSize = intrinsicContentSize(displayList)
|
||||
displayList.textColor = textColor
|
||||
|
||||
let size = intrinsicContentSize.regularized
|
||||
layoutImage(size: size, displayList: displayList)
|
||||
|
||||
#if os(iOS) || os(visionOS)
|
||||
let renderer = UIGraphicsImageRenderer(size: size)
|
||||
let image = renderer.image { rendererContext in
|
||||
rendererContext.cgContext.saveGState()
|
||||
rendererContext.cgContext.concatenate(.flippedVertically(size.height))
|
||||
displayList.draw(rendererContext.cgContext)
|
||||
rendererContext.cgContext.restoreGState()
|
||||
}
|
||||
return (nil, image, LayoutInfo(ascent: displayList.ascent, descent: displayList.descent))
|
||||
#endif
|
||||
#if os(macOS)
|
||||
let image = NSImage(size: size, flipped: false) { bounds in
|
||||
guard let context = NSGraphicsContext.current?.cgContext else { return false }
|
||||
context.saveGState()
|
||||
displayList.draw(context)
|
||||
context.restoreGState()
|
||||
return true
|
||||
}
|
||||
return (nil, image, LayoutInfo(ascent: displayList.ascent, descent: displayList.descent))
|
||||
#endif
|
||||
}
|
||||
}
|
||||
private extension CGAffineTransform {
|
||||
static func flippedVertically(_ height: CGFloat) -> CGAffineTransform {
|
||||
var transform = CGAffineTransform(scaleX: 1, y: -1)
|
||||
transform = transform.translatedBy(x: 0, y: -height)
|
||||
return transform
|
||||
}
|
||||
}
|
||||
extension CGSize {
|
||||
fileprivate var regularized: CGSize {
|
||||
CGSize(width: ceil(width), height: ceil(height))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user