Font Descriptor: mga pangunahing konsepto at kakayahan ng deskriptor ng font

Ano ang Font Descriptor at bakit ito kailangan

Font Descriptor — ay isang bagay na naglalarawan ng mga katangian ng font bilang isang set ng mga pares ng key-value, hindi bilang isang partikular na file ng font. Sa halip na gumawa ng font sa pamamagitan ng pangalan, tinutukoy ng developer ang pamilya, estilo, laki, at opsyonal na mga katangian, at pinipili ng system ang pinakamahusay na tugma. Ang ganitong paraan ay mahalaga para sa adaptive typography: ang parehong deskriptor ay maaaring gumana sa iba’t ibang bersyon ng iOS kung saan magkaiba ang set ng mga available na font. Ayon sa iOS Human Interface Guidelines, ang pagtutugma ng font sa pamamagitan ng mga deskriptor ay ang inirerekomendang paraan ng pagtatrabaho sa mga dynamic na font.

Kung wala ang Font Descriptor, kakailanganin ng developer na suriin ang availability ng bawat font sa pamamagitan ng pangalan at manu-manong matukoy ang mga fallback na variant. Awtomatiko ng deskriptor ang prosesong ito: naglalaman ito ng compatibility matrix ng mga estilo — normal, bold, italic, bold italic — at kung walang eksaktong tugma, ibinabalik nito ang pinakamalapit na available. Pagtutugma ng system ay gumagana sa antas ng Core Text at available kapwa sa iOS at macOS sa pamamagitan ng nag-iisang NSFontDescriptor API.

Ang mga deskriptor ay ginagamit din para sa mga custom na font — na-load sa pamamagitan ng Info.plist o manu-manong idinagdag. Kung ang isang font ay rehistrado sa system, ang deskriptor nito ay ginawa nang eksakto tulad ng para sa isang system font. Tala ng cross-platform: ang konsepto ng deskriptor ay umiiral din sa Android sa pamamagitan ng Typeface.Builder, ngunit ang iOS implementation sa pamamagitan ng UIFontDescriptor ay nagbibigay ng mas maraming katangian — mahigit 20 kumpara sa 5 sa Android.

Mga pangunahing property at katangian ng Font Descriptor

UIFontDescriptor ay naglalaman ng mga katangian na pinagsama-sama sa diksyunaryo ng fontAttributes na uri [UIFontDescriptor.AttributeName: Any]. Ang mga pangunahing katangian ay kinabibilangan ng pamilya ng font (family), pangalan (name), laki (size), estilo (traits), matrix ng transformasyon (matrix), optical size (opticalSize), at estilo ng teksto (textStyle). Ayon sa Apple WWDC 2019 Session 227, ang paggamit ng mga estilo ng teksto — Dynamic Type — ay sapilitan para sa mga application na katugma sa accessibility.

Ang katangiang traits — ay isang diksyunaryo na naglalaman ng mga simbolikong katangian: kapal (UIFontWeightTrait), italic (UIFontSlantTrait), lapad (UIFontWidthTrait), at iba pa. Ang mga halagang ito ay ginagamit ng tagatugma ng font para sa pagpili ng estilo. Halimbawa, ang UIFontWeightTrait na may halagang 0.0 — normal na estilo, 0.3 — bold. Awtomatikong minamapa ng system ang mga numerikong halaga sa mga available na variant ng font.

Ang mga karagdagang katangian ay kinabibilangan ng featureSettings para sa mga feature ng OpenType (ligatures, kerning, proporsyon ng numero), visibleName para sa pagpapakita sa user, matrix para sa affine transformations ng font, at cascadeList para sa cascading list ng mga fallback na font. Ang kumpletong listahan ng mga katangian ay sumasaklaw sa halos lahat ng typography scenario sa iOS at macOS.

Paggawa ng UIFont sa pamamagitan ng Font Descriptor sa Swift

Ang pangunahing paraan ng pagtatrabaho sa Font Descriptor sa iOS — paggawa ng deskriptor na may kasunod na pagbuo ng UIFont. Ito ang ginustong paraan kapag kailangan mong makakuha ng font na may partikular na mga katangian nang hindi alam ang eksaktong pangalan. Ang proseso ay binubuo ng dalawang hakbang: paggawa ng UIFontDescriptor sa pamamagitan ng initializer at pagtawag sa pamamaraang font(withSize:) sa deskriptor.

import UIKit

// Gumawa ng deskriptor ng font para sa pamilya
let descriptor = UIFontDescriptor.init(
    fontAttributes: [
        .family: "SF Pro",
        .traits: [
            .weight: UIFont.Weight.bold
        ]
    ]
)

// Bumuo ng UIFont mula sa deskriptor
let font = descriptor.font(withSize: 17)

Tinitiyak ng paraang ito na pipiliin ng system ang pinakamahusay na tugma para sa bold na estilo ng SF Pro sa kasalukuyang device. Pangunahing bentahe — ang code ay hindi nakadepende sa bersyon ng iOS: sa iOS 13 gagamitin ang SF Pro, sa mas lumang bersyon — Helvetica Neue o ang default na system font.

Para sa paggawa ng font na may dynamic na laki, ginagamit ang initializer na may estilo ng teksto at scale. Awtomatikong inaayos ng Dynamic Type ang laki sa mga setting ng user:

// Deskriptor ng Dynamic Type
let bodyDescriptor = UIFontDescriptor
    .preferredFontDescriptor(withTextStyle: .body)

// Gawing bold ang font
let boldDescriptor = bodyDescriptor.withSymbolicTraits([.traitBold])

// Bumuo ng UIFont na may preserbasyon ng dynamic na laki
let boldBodyFont = UIFont(
    descriptor: boldDescriptor!,
    size: bodyDescriptor.pointSize
)

Mahalaga: ang pamamaraang withSymbolicTraits ay nagbabalik ng opsyonal na deskriptor — kung ang hinihiling na estilo ay hindi available, nagbabalik ito ng nil. Palaging suriin ang opsyon bago gamitin.

Pagbabago ng mga katangian sa pamamagitan ng pagdaragdag at pagpapalit

Sinusuportahan ng Font Descriptor ang isang hindi nababagong modelo — bawat pamamaraan ng pagbabago ay nagbabalik ng bagong deskriptor na may binagong katangian. Ito ay tumutugma sa value semantics at ginagawang predictable ang code: ang orihinal na deskriptor ay hindi nagbabago. Ang mga pangunahing pamamaraan ng pagbabago: addingAttributes para sa pagdaragdag ng mga katangian, withFace para sa pagbabago ng estilo, withSize para sa pagbabago ng laki, withMatrix para sa affine transformation.

Ang pamamaraang addingAttributes — ang pinaka-flexible. Tumatanggap ito ng diksyunaryo ng mga katangian at nagbabalik ng bagong deskriptor. Kung may magkatugmang key, pinapalitan ng mga bagong halaga ang mga luma. Pinapayagan nito ang pagsasama-sama ng mga pagbabago: pagdagdag ng bigat, pagbabago ng laki, at pag-enable ng mga ligature sa isang tawag. Ayon sa Apple Technical Q&A QA1682, ang addingAttributes ay ang inirerekomendang paraan para sa maramihang pagbabago sa pamamagitan ng extension.

Praktikal na aplikasyon: paggawa ng font para sa monospace na teksto sa editor ng code. Kinuha ng developer ang system monospace deskriptor, nagdagdag ng pinababang bigat para sa manipis na linya, at pinataas ang spacing ng titik sa pamamagitan ng featureSettings. Nagbibigay ito ng mas nababasang code nang hindi nag-load ng hiwalay na font.

let monoDescriptor = UIFontDescriptor.monospacedDigitFontDescriptor()

// Magdagdag ng mga custom na katangian
let customDescriptor = monoDescriptor.addingAttributes([
    .size: 14,
    .traits: [
        .weight: UIFont.Weight.medium
    ]
])

let monoFont = UIFont(
    descriptor: customDescriptor,
    size: 14
)

Limitasyon: hindi lahat ng katangian ay maaaring baguhin pagkatapos gawin ang deskriptor. Halimbawa, ang pamilya ng font (family) ay itinatakda nang isang beses sa initialisation. Kung kailangan mong baguhin ang pamilya, gumawa ng bagong deskriptor. Ito ay nauugnay sa arkitektura ng Core Text, kung saan ang deskriptor ay nakatali sa isang partikular na resource ng font.

Pagtutugma ng font at paghahanap ng mga system font

Pagtutugma ng font — pangunahing function ng Font Descriptor, na awtomatikong pumipili ng pinakamahusay na tugma para sa hinihinging mga katangian mula sa mga naka-install na font. Ang proseso ay may tatlong yugto: pagsasala (pag-alis ng mga hindi tugmang font), pagraranggo (pag-uuri ayon sa antas ng pagtutugma), at pagpili (pagbabalik ng pinakamahusay na resulta). Ang pagtutugma ay ginagawa sa antas ng Core Text — ang framework na nasa pundasyon ng lahat ng typography ng iOS.

Para sa paghahanap ng lahat ng font na tumutugma sa isang deskriptor, ginagamit ang pamamaraang matchingFontDescriptors. Nagbabalik ito ng array ng mga deskriptor na pinagsunod-sunod ayon sa kaugnayan. Maaaring piliin ng developer ang eksaktong tugma (unang elemento) o suriin ang mga variant para sa custom na logic. Ayon sa Apple Font Handling Guide, ito ang tanging paraan upang makuha ang listahan ng mga available na estilo para sa isang partikular na pamilya nang walang enumerasyon ayon sa pangalan.

Scenario ng paggamit: kapag pumipili ng font sa interface ng mga setting ng teksto. Pinipili ng user ang isang pamilya, at ang application sa pamamagitan ng matchingFontDescriptors ay kumukuha ng lahat ng available na estilo at ipinapakita ang mga ito sa picker. Kung walang pagtutugma, kakailanganing i-hardcode ang listahan ng mga variant na nagbabago sa pagitan ng mga bersyon ng iOS.

let searchDescriptor = UIFontDescriptor.init(
    fontAttributes: [.family: "SF Mono"]
)

// Kunin ang lahat ng available na estilo
let matchingDescriptors = searchDescriptor
    .matchingFontDescriptors(withMandatoryKeys: nil)

for descriptor in matchingDescriptors {
    print(descriptor.object(forKey: .visibleName) ?? "unnamed")
}

Mandatory keys — parameter na naglilimita sa paghahanap. Kung tinukoy ang [.family], ibabalik ng pagtutugma ang lahat ng font ng tinukoy na pamilya. Kung tinukoy ang [.family, .traits] — tanging ang mga tugma sa parehong pamilya at estilo. Ang paggamit ng mandatory keys ay nagpapabilis ng pagtutugma kapag naghahanap ng subset ng mga font.

Pagganap: ang pagtutugma ay isang synchronous na operasyon na tumatagal ng 0.5 hanggang 5 ms sa iOS. Para sa isang paghahanap ito ay hindi napapansin, ngunit sa maramihang pagtingin ng mga deskriptor (halimbawa, sa isang picker na may 50+ font), inirerekomenda ang pag-cache ng mga resulta. Inirerekomenda ng Apple na gawin ang pagtutugma nang isang beses kapag naglo-load ng screen at i-save ang array ng mga deskriptor.

Pagsasama sa Core Text at CTFontDescriptor

Core Text — isang mababang antas na C framework para sa pagtatrabaho sa typography sa iOS at macOS. Ang katumbas nito ng UIFontDescriptor — CTFontDescriptor, na nagbibigay ng parehong mga kakayahan sa antas ng Core Foundation. Ginagamit ang CTFontDescriptor sa Core Text API para sa paggawa ng mga font, pagsukat ng teksto, at pag-render ng kumplikadong typography. Ang UIFontDescriptor ay sa esensya isang Objective-C wrapper sa paligid ng CTFontDescriptor na may pinalawak na set ng mga katangian.

Ang Toll-free bridging sa pagitan ng UIFontDescriptor at CTFontDescriptor ay nagpapahintulot sa pagpasa ng mga deskriptor sa pagitan ng UIKit at Core Text nang walang conversion. Ito ay mahalaga para sa mga application na gumagamit ng custom na pag-render ng teksto — halimbawa, mga text editor na nakabatay sa TextKit o mga code editor na may syntax highlighting. Halimbawa: CTFontDescriptorCreateCopyWithAttribute ay gumagawa ng kopya ng deskriptor na may idinagdag na katangian — katumbas ng addingAttributes mula sa UIFontDescriptor.

Key attribute kCTFontURLAttribute sa CTFontDescriptor ay naglalaman ng URL ng file ng font. Ito ay nagpapahintulot na matukoy kung ang font ay system o custom. Para sa mga custom na font, ang URL ay patungo sa file ng font (.ttf o .otf), para sa mga system font — sa system font directory. Ang data sa pamamagitan ng deskriptor ay read-only; ang pagbabago ng file ng font sa pamamagitan ng URL ay hindi suportado.

Para sa advanced na typography — custom ligatures, contextual replacements, alternatibong glyphs — ginagamit ang CTFontDescriptorCopyAttribute na may key na kCTFontFeatureSettingsAttribute. Ang katangiang ito ay naglalaman ng array ng mga diksyunaryo ng mga feature ng OpenType na maaaring idagdag sa pamamagitan ng deskriptor. Ayon sa Apple Core Text Programming Guide, ang pagsasama ng UIFontDescriptor sa Core Text ay nagbibigay ng ganap na kontrol sa typography ng application.