UIFont / CTFont — ano ito, mga uri ng font at Core Text

Ano ang UIFont at CTFont?

UIFont — ay isang UIKit class na kumakatawan sa isang font para sa pagpapakita ng text sa UI components: UILabel, UITextView, UITextField. Nagbibigay ito ng simpleng interface para makuha ang system at custom na font na may pagtukoy sa laki, bigat at style. Hindi pinapayagan ng UIFont ang direktang pamamahala ng kerning, ligature at OpenType features — para dito ginagamit ang Core Text.

CTFont — ay isang Core Text type (CTFontRef) na nagbibigay ng mababang antas na access sa data ng font. Direktang gumagana ang CTFont sa Core Graphics para sa rendering, sinusuportahan ang lahat ng kakayahan ng OpenType at TrueType, kabilang ang alternatibong glyph, ligature at variable na font. Ginagamit ang CTFont sa loob ng UIKit para sa rendering ng UIFont, ngunit direktang available din para sa custom na pagguhit.

Toll-Free Bridging

Sinusuportahan ng UIFont at CTFont ang toll-free bridging — conversion sa pagitan ng mga type na walang karagdagang gastos. Ang pag-cast ng UIFont as CTFont o CTFont as UIFont ay posible sa Swift at Objective-C. Pinapayagan nito ang paggamit ng mataas na antas na UIKit API para sa configuration at mababang antas na Core Text para sa rendering nang hindi kinokopya ang data ng font.

Font Descriptor

Parehong gumagamit ang dalawang klase ng UIFontDescriptor (UIKit) / CTFontDescriptor (Core Text) para sa paglalarawan ng mga katangian ng font: pangalan, laki, bigat, style, transformation matrix. Ang descriptor ay isang diksyunaryo ng mga attribute na maaaring baguhin at gumawa ng bagong font batay sa umiiral na. Halimbawa, magdagdag ng traitItalic sa descriptor at makuha ang italic na bersyon ng parehong font.

UIFont — mga font ng UIKit

UIFont ay nagbibigay ng ilang factory method para sa paggawa ng font. Ang systemFont(ofSize:) ay nagbabalik ng system font na San Francisco (iOS) o Helvetica (lumang bersyon). Ang boldSystemFont, italicSystemFont — mga variant na may style. Ang preferredFont(forTextStyle:) ay nagbabalik ng Dynamic Type font para sa ibinigay na style: .headline, .body, .caption1, .footnote. Ang mga font na ito ay awtomatikong nagsi-scale kapag nagbago ang text size settings sa system.

Para sa pag-load ng custom na font ginagamit ang UIFont(name:size:) na may PostScript name ng font. Ang font ay dapat naidagdag sa Info.plist at kasama sa bundle ng application. Ayon sa Apple, inirerekomenda ang paggamit ng UIFont para sa lahat ng standard UI components at lumipat sa CTFont lamang kapag kailangan ang custom na rendering.

Dynamic Type

Dynamic Type — adaptive font system na ipinakilala sa iOS 7. Pinipili ng user ang gustong laki ng text sa Settings — mula sa napakaliit hanggang sa napakalaki. Ang UIFont.preferredFont ay awtomatikong nagbabalik ng font ng naaangkop na laki. Para sa tamang paggana, lahat ng UILabel ay dapat may adjustsFontForContentSizeCategory = true. Ang Dynamic Type ay kinakailangan para sa accessibility compliance.

UIFontDescriptor

Ang UIFontDescriptor ay nagpapahintulot sa pagbabago ng mga attribute ng font nang hindi gumagawa ng bagong instance mula sa simula. Ang mga pamamaraan na addingAttributes(_:), withSymbolicTraits(_:), withFamily(_:) ay nagbabalik ng bagong descriptor na may binagong parameter. Ito ay maginhawa para sa pagkuha ng mga variant ng font: magdagdag ng traitBold sa system font at makuha ang bold na bersyon nang hindi alam ang PostScript name.

CTFont — mga font ng Core Text

CTFont (CTFontRef) — ay isang Core Text type para sa mababang antas na paggawa gamit ang mga font. Ito ay ginagawa gamit ang mga function na CTFontCreateWithName, CTFontCreateWithFontDescriptor, CTFontCreateCopyWithAttributes. Bawat function ay nagbabalik ng font na may tinukoy na interface, laki at opsyonal na attribute. Ginagamit ang CTFont sa Core Graphics para sa rendering ng text sa custom na UIView sa pamamagitan ng drawRect.

Ang CTFont ay nagbibigay ng access sa metrics na hindi available sa UIFont: CTFontGetGlyphsForCharacters ay nagbabalik ng array ng glyph para sa ibinigay na character, CTFontGetAdvancesForGlyphs — lapad ng bawat glyph, CTFontGetBoundingBox — hangganan ng glyph. Ito ay kinakailangan para sa pagbuo ng custom na text layout: column, rotation, wrapping.

Font Metrics

CTFontGetAscent, CTFontGetDescent, CTFontGetLeading ay nagbabalik ng vertical metrics ng font. CTFontGetUnitsPerEm — bilang ng units per em-square, ginagamit para sa pagkalkula ng proporsyon. CTFontGetGlyphCount — kabuuang bilang ng glyph sa font. Ang data na ito ay kritikal para sa print typography at custom na layout kung saan kinakailangan ang tumpak na pagpoposisyon ng bawat character.

OpenType at Variable Fonts

Ang CTFont ay sumusuporta sa OpenType features: ang CTFontCopyFeatures ay nagbabalik ng diksyunaryo ng mga available na function ng font (ligature, alternatibong character, kerning), ang CTFontEnableFeature ay gumagana ng specific na opsyon. Ang variable fonts (Variable Fonts) ay naka-configure sa pamamagitan ng CTFontCopyVariation at CTFontCreateCopyWithVariation, na nagpapahintulot sa pagbabago ng weight, width at slant sa tuloy-tuloy na range.

Paano gamitin ang UIFont sa code

Ang paggawa ng UIFont sa Swift ay ginagawa sa pamamagitan ng isa sa mga factory method o direktang initialization ayon sa pangalan. Ang pinakakaraniwang paraan ay systemFont(ofSize:weight:) para sa system fonts o preferredFont(forTextStyle:) para sa Dynamic Type. Para sa custom na font ginagamit ang UIFont(name:size:) na may pagbanggit ng PostScript name.

System Font na may Iba’t Ibang Timbang

Ang UIFont.systemFont(ofSize:weight:) ay tumatanggap ng UIFont.Weight — mula .ultraLight hanggang .black. Ang pamamaraang ito ay nagbabalik ng system font na San Francisco na may kaukulang timbang. Ang UIFont.monospacedSystemFont, UIFont.monospacedDigitSystemFont ay nagbabalik ng monospace font para sa code at numero. Lahat ng system font ay awtomatikong sumusuporta sa Dynamic Type.

let regularFont = UIFont.systemFont(ofSize: 16, weight: .regular)
let boldFont = UIFont.systemFont(ofSize: 16, weight: .bold)
let headlineFont = UIFont.preferredFont(forTextStyle: .headline)
let monoFont = UIFont.monospacedSystemFont(ofSize: 14, weight: .regular)
label.font = headlineFont

Bawat font ay maaaring direktang italaga sa font property ng UILabel o gamitin sa NSAttributedString sa pamamagitan ng NSFontAttributeName. Ang system fonts ay naka-cache ng iOS, kaya ang paulit-ulit na paggawa ng system font ay hindi nagdadala ng karagdagang gastos.

Custom na Font mula sa Bundle

Para gumamit ng custom na font, idagdag ang TTF o OTF file sa bundle ng proyekto at tukuyin ito sa Info.plist (UIAppFonts). Ang PostScript name ng font ay malalaman sa pamamagitan ng UIFont.familyNames at UIFont.fontNames(forFamilyName:). Pagkatapos ng registration, ang font ay available sa pamamagitan ng UIFont(name:size:) sa kahit anong punto ng application.

// Kunin ang lahat ng pangalan ng pamilya ng font
for family in UIFont.familyNames {
    let names = UIFont.fontNames(forFamilyName: family)
    print("\(pamilya): \(pangalan)")
}
// I-load ang custom na font
if let customFont = UIFont(name: "MyCustomFont-Regular", size: 18) {
    label.font = customFont
}

Kung mali ang pangalan ng font, ang UIFont(name:size:) ay nagbabalik ng nil. Inirerekomenda na ipakita muna ang lahat ng available na pangalan ng font sa pamamagitan ng UIFont.familyNames at UIFont.fontNames(forFamilyName:) habang nagde-debug upang matiyak na ang font ay rehistrado nang tama.

Custom na Font gamit ang UIFont at CTFont

Ang pag-load ng custom na font ay posible sa dalawang paraan: static na registration sa pamamagitan ng Info.plist (UIAppFonts) at dynamic na registration sa pamamagitan ng CTFontManagerRegisterGraphicsFont. Ang unang paraan ay mas simple — agad na available ang font pagkatapos simulan ang application. Ang pangalawa ay ginagamit para sa mga font na na-load mula sa network o nai-download on demand.

Ang dynamic na registration ay kapaki-pakinabang para sa on-demand resources: kung ang application ay naglalaman ng 20+ font, hindi lahat ay kailangang isama sa initial bundle, ngunit maaaring i-download sa unang paggamit. Ang CTFontManagerRegisterFontsForURLs ay nagrerehistro ng mga font mula sa tinukoy na URL. Pagkatapos ng registration, ang font ay nagiging available sa pamamagitan ng UIFont(name:size:) gaya ng dati.

CTFontCreateWithName para sa Custom na Font

Para sa custom na rendering sa pamamagitan ng Core Text gamitin ang CTFontCreateWithName na may PostScript name ng font. Ang pagkakaiba sa UIFont ay ang CTFont ay maaaring gawin gamit ang transformation matrix (CTFontCreateWithNameAndOptions) — para sa paggawa ng distorted na font: pagtagilid, pag-scale sa X axis, pag-ikot. Ito ay hindi available sa UIFont nang hindi gumagamit ng affine transformations.

// Gumawa ng CTFont na may skew matrix
var matrix = CGAffineTransform(a: 1, b: 0, c: 0.2, d: 1, tx: 0, ty: 0)
let ctFont = CTFontCreateWithName(
    "Helvetica" as CFString,
    24, &matrix)
// Gamitin ang toll-free bridging gamit ang UIFont
let uiFont = ctFont as UIFont
label.font = uiFont

Ang transformation matrix ay nagpapahintulot sa paggawa ng italic variants nang walang hiwalay na font file. Ang parameter c (skew) ay nagdaragdag ng pagtagilid sa mga character. Pinapayagan din ng matrix ang horizontal scaling ng font — paggawa ng naka-compress o pinalawak na variants ng parehong font.

Mga Pagkakaiba ng UIFont at CTFont

Ang pangunahing pagkakaiba sa pagitan ng UIFont at CTFont ay ang antas ng abstraction. Ang UIFont ay nagbibigay ng simpleng API para sa karaniwang gawain: kumuha ng system font, baguhin ang laki, ilapat sa UILabel. Ang CTFont ay nagbibigay ng kumpletong kontrol sa font: access sa glyph, metrics, OpenType tables at variable axes. Ang pagpili ay depende sa gawain.

Para sa 95% ng iOS development tasks, sapat na ang UIFont. Ang Core Text na may CTFont ay nabibigyang-katwiran sa paggawa ng text editor, PDF generator, libro na may typographic layout o application na may custom na display ng mga bihirang wika.

Performance at Best Practices

Ang paggawa gamit ang mga font sa iOS ay nangangailangan ng pagsasaalang-alang sa performance. Bawat natatanging font ay na-load sa memory sa unang paggamit at kumukuha ng resources. Ang system fonts na San Francisco ay pre-loaded at hindi lumilikha ng karagdagang gastos. Ang custom na font ay na-load mula sa file at naka-cache ng system pagkatapos ng unang pag-load.

Inirerekomenda na limitahan ang bilang ng natatanging font sa application sa 3-5 pamilya. Bawat font ay kumukuha mula 50 KB hanggang 2 MB sa memory. Ang paggamit ng iba’t ibang timbang ng parehong pamilya (regular, bold, medium) ay mas mahusay kaysa pag-load ng ilang magkakaibang pamilya.

Pag-cache ng UIFont

Ang system ay nag-cache ng mga ginawang instance ng UIFont, kaya ang paulit-ulit na pagtawag sa UIFont.systemFont(ofSize: 16, weight: .regular) ay hindi gumagawa ng bagong object. Gayunpaman, ang UIFont(name:size:) para sa custom na font ay hindi palaging naka-cache — inirerekomenda na i-save ang madalas gamitin na font sa static properties o NSCache cache upang maiwasan ang paulit-ulit na pag-load mula sa file.

Asynchronous na Pag-load ng Font

Sa dynamic na registration ng font sa pamamagitan ng CTFontManagerRegisterGraphicsFont, ang proseso ay maaaring asynchronous kung ang font file ay dina-download mula sa network. Sa kasong ito, ang UILabel o UITextView ay dapat magpakita ng backup system font hanggang sa makumpleto ang pag-load. Pagkatapos ng registration, ang font ay nagiging available, at awtomatikong ina-update ng screen ang display ng text.