Ligatura sa mobile development — mga batayan at aplikasyon ng mga koneksyong simbolo

Ano ang ligatura sa tipograpiya

Ligatura ay isang tipograpikong pamamaraan kung saan ang dalawa o higit pang mga simbolo ay pinapalitan ng isang espesyal na dinisenyong tanda. Ang pangunahing layunin ng ligatura ay alisin ang mga biswal na alitan sa pagitan ng mga karatig na simbolo at pagbutihin ang persepsyon ng teksto. Sa pares na fi, halimbawa, ang itaas na usli ng letrang f ay bumabangga sa tuldok ng letrang i — pinagsasama sila ng ligatura sa isang elegante at pinag-isang simbolo.

Ang mga ligatura ay nahahati sa obligado (standard) at opsyonal (dekoratibo). Standard na ligatura ay mga pares na matatagpuan sa karamihan ng mga font: fi, fl, ff, ffi, ffl. Ang mga ito ay itinuturing na kinakailangan para sa de-kalidad na tipograpiya at naka-default na naka-activate sa font. Ayon sa OpenType Specification, ang mga standard na ligatura ay naka-encode na may tag na 'liga' at dapat na naka-activate sa bawat propesyonal na font.

Biswal na epekto: walang ligatura, ang pares na fi ay mukhang dalawang magkahiwalay na simbolo na may hindi kanais-nais na pagkakadikit. May ligatura — parang isang magkakatugmang simbolo. Ang pagkakaiba ay lalong kapansin-pansin sa malalaking sukat (mga heading, logo) at sa tekstong may maraming umuulit na pares (halimbawa, sa wikang German na may häufigen Buchstabenkombinationen).

Mga uri ng ligatura: standard, discretionary, kontekstwal

Ang mga OpenType font ay sumusuporta sa ilang uri ng ligatura, bawat isa ay may sariling tag at layunin. Standard (tag 'liga') — obligadong ligatura na naka-default na naka-activate sa font. Pinapabuti nila ang pagiging madaling-basa at hindi dapat i-off nang walang wastong dahilan. Naglalaman ng mga pares na fi, fl, ff, ffi, ffl at iba pa na espesipiko sa tipo ng letra.

Discretionary ligatura (tag 'dlig') — mga dekoratibong ligatura na opsyonal na isina-activate ayon sa pagpapasya ng taga-disenyo. Hindi sila kinakailangan para sa pagiging madaling-basa at ginagamit para sa pag-istilo ng teksto: ct, st, sp, Th, Qu at iba pa. Ang mga discretionary ligatura ay madalas na matatagpuan sa mga font na may historikal o kaligrapikong karakter — halimbawa, sa Garamond o Adobe Caslon. Babala: ang sobrang dami ng discretionary ligatura ay nagpapahina sa pagiging madaling-basa, lalo na para sa mga user na may dyslexia.

Kontekstwal na ligatura (tag 'clig') — mga ligatura na nakadepende sa kapaligiran ng simbolo. Ang mga ito ay inilalapat lamang sa ilalim ng tiyak na mga kondisyon: kung ang simbolo ay nasa simula o dulo ng salita, pagkatapos ng isang partikular na bantas, at iba pa. Ang kontekstwal na ligatura ay isang advanced na OpenType-feature na hindi sinusuportahan ng lahat ng font. Historikal na ligatura (tag 'hlig') — mga lumang ligatura na ginagaya ang estilo ng mga lumang naka-print na aklat (long s, &). Bihirang ginagamit, sa historikal o naka-istilong teksto lamang.

Mga bihirang uri: mayroon ding mga ligatura para sa mathematical set (tag 'dlig' para sa mathematical na mga simbolo) at mga ligatura para sa inisyal (drop caps) — ngunit hindi ito ginagamit sa interface typography at sinusuportahan lamang ng mga espesyalisadong font.

Kasaysayan ng mga ligatura: mula sa metal na set hanggang sa digital na mga font

Ang mga ligatura ay lumitaw bago pa ang digital na tipograpiya — noong panahon pa ng metal na set noong ika-15 siglo. Ang tagapaglimbag na si Johannes Gutenberg ay gumamit ng mga ligatura upang makatipid ng espasyo sa mga linya ng kanyang 42-linya na Bibliya. Ang bawat letra ay isang pisikal na metal na bloke, at ang pagsasama ng dalawang simbolo sa isang letra ay nakatipid ng tingga at nagpasimple sa pag-set. Ang mga standard na ligatura na fi, fl, ffi, ffl ay pamana ng panahong iyon.

Sa phototypesetting (ika-20 siglo) ang mga ligatura ay nawalan ng praktikal na gamit, ngunit nanatili bilang isang estetikong elemento ng de-kalidad na tipograpiya. Ang mga taga-disenyo ng font ay patuloy na nagsama ng mga ligatura sa kanilang mga tipo ng letra, dahil sila ay naging tanda ng propesyonalismo at atensyon sa detalye. Sa panahon ng digital na mga font (PostScript, TrueType), ang mga ligatura ay ipinatupad bilang mga hiwalay na glyph na may programatikong pagpapalit.

OpenType (1996) ay isang rebolusyon: ipinakilala nito ang mekanismong GSUB (Glyph Substitution Table) na awtomatikong pumapalit sa isang pagkakasunod-sunod ng mga simbolo ng isang ligatura nang walang interbensyon ng user. Sinusuportahan ng GSUB ang kontekstwal na pagpapalit, mga kondisyon, at mga fallback-variant. Ito ay nagbigay-daan sa mga font na magkaroon ng daan-daang ligatura na isina-activate/deactivate sa pamamagitan ng mga tag. Mga modernong font — SF Pro, Roboto, Inter — sumusuporta sa OpenType ligatura sa lahat ng platform: iOS, Android, macOS, Windows, web.

Implementasyon ng mga ligatura sa iOS sa pamamagitan ng UIFontDescriptor

Sa iOS, ang mga ligatura ay maaaring pamahalaan sa pamamagitan ng UIFontDescriptor gamit ang atributong featureSettings. Ang atributong ito ay tumatanggap ng isang array ng mga diksyunaryo, na ang bawat isa ay naglalarawan ng isang OpenType-feature. Ang pamamahala ng mga ligatura sa pamamagitan ng descriptor ay ang tanging paraan upang kontrolin ang mga indibidwal na uri ng ligatura nang hindi naaapektuhan ang iba pang OpenType-feature ng font.

let descriptor = UIFontDescriptor.preferredFontDescriptor(
    withTextStyle: .body
)

// I-activate ang discretionary ligatura
let ligatureDescriptor = descriptor.addingAttributes([
    .featureSettings: [
        [
            UIFontDescriptor.FeatureIdentifier: kLigaturesType,
            UIFontDescriptor.TypeIdentifier: kCommonLigaturesOnSelector
        ]
    ]
])

let font = UIFont(
    descriptor: ligatureDescriptor,
    size: 17
)

NSAttributedString ay sumusuporta din sa atributong ligature: NSNumber. Ang halagang 0 — i-deactivate ang lahat ng ligatura, 1 — i-activate ang standard (default), 2 — i-activate lahat (kasama ang discretionary). Gayunpaman, ang atributong ligature sa NSAttributedString ay hindi nagbibigay ng maselang kontrol sa mga uri ng ligatura — pandaigdigang pag-activate/deactivation lamang. Para sa piling pamamahala, gamitin ang UIFontDescriptor na may featureSettings.

SwiftUI ay hindi nagbibigay ng direktang modifier para sa mga ligatura. Upang pamahalaan ang mga ligatura sa SwiftUI, lumikha ng UIFont na may nais na mga setting sa pamamagitan ng UIFontDescriptor at gamitin ito sa pamamagitan ng Font(descriptor:size:). Bilang alternatibo — gamitin ang AttributedString (iOS 15+) na may atributong .ligature para sa NSMutableAttributedString sa mga view ng AppKit/UIKit.

// SwiftUI na may custom na ligatura sa pamamagitan ng AttributedString
var attributedText: AttributedString {
    var text = AttributedString(
        "Effective typography with ligatures"
    )

    // I-activate ang lahat ng ligatura para sa buong teksto
    text.ligature = .all

    return text
}

var body: some View {
    Text(attributedText)
}

Pamamahala ng mga ligatura sa CSS at sa Android

Sa web, ang mga ligatura ay pinamamahalaan sa pamamagitan ng CSS property na font-variant-ligatures, na tumatanggap ng mga keyword: common-ligatures (standard naka-activate), no-common-ligatures (standard naka-deactivate), discretionary-ligatures, no-discretionary-ligatures, contextual, no-contextual. Ang property ay sinusuportahan ng lahat ng modernong browser mula noong 2015. Bilang default, isina-activate ng mga browser ang standard at kontekstwal na ligatura.

/* Disable all ligatures for monospace */
code, pre {
    font-variant-ligatures: none;
}

/* Enable discretionary ligatures for headings */
.title-fancy {
    font-variant-ligatures:
        common-ligatures
        discretionary-ligatures
        contextual;
}

Android ay walang direktang API para sa pamamahala ng mga ligatura. Sa Android, ang mga ligatura ay pinamamahalaan sa antas ng font at ng Minikin rendering engine (Android 10+). Kung ang font ay naglalaman ng OpenType GSUB table, ang mga ligatura ay awtomatikong inilalapat. Para sa pag-deactivate ng mga ligatura sa Android, ginagamit ang mga custom na Typeface na nilikha sa pamamagitan ng Typeface.Builder, o preprocessing ng teksto (pagpapalit ng mga simbolo bago ipakita). Limitasyon: sa Android na mas mababa sa 10, ang mga ligatura ay maaaring gumana nang hindi tama sa ilang TTF font.

Kontrol sa mababang antas: sa lahat ng platform, maaaring gamitin ang CSS @font-face na may parameter na font-feature-settings para sa OpenType-feature. Ang pamamaraang ito ay nagbibigay ng access sa anumang OpenType tag, kabilang ang mga ligatura. Halimbawa: font-feature-settings: 'liga' 1, 'dlig' 1. Gayunpaman, ang font-feature-settings ay isang mababang antas na syntax at inirerekomenda ng MDN ang paggamit ng font-variant-ligatures bilang isang mas mataas na antas na kahalili.

Mga ligatura sa mga font para sa programming

Isang espesyal na klase ng mga ligatura — programming ligatura, na pinagsasama ang mga operator at simbolo ng code sa mas madaling basahin na mga tanda. Ang mga font para sa programming tulad ng Fira Code, JetBrains Mono, Cascadia Code ay nagsasama ng discretionary ligatura para sa mga karaniwang operator: != (nagiging ≠), >= (nagiging ≥), -> (nagiging arrow), => (nagiging makapal na arrow), === (nagiging triple equal).

Ang mga programming ligatura ay isang kontrobersyal na paksa sa komunidad ng mga developer. Ang mga tagapagtaguyod ay nagsasabi na ang mga ligatura ay nagpapabilis sa pagbabasa ng code, dahil ang mga operator ay nakikita bilang mga iisang konsepto. Pananaliksik (Kera et al., PLATEAU 2020) ay nagpakita na ang mga ligatura ay hindi nakakaapekto sa bilis ng pagbabasa ng code, ngunit subjective na nagustuhan ng 67% ng mga developer. Ang mga kalaban ng ligatura ay napapansin na binabaluktot nila ang code: ang simbolo na != sa editor ay ipinapakita bilang ≠, ngunit sa text file ay naka-imbak bilang dalawang simbolo, na maaaring nakakalito sa pakikipagtulungan.

Teknikal na implementasyon: ang mga programming ligatura ay discretionary OpenType ligatura (tag 'dlig'). Ang mga ito ay naka-deactivate bilang default at isina-activate sa code editor sa pamamagitan ng mga setting ng font. Ang mga developer na gumagamit ng gayong mga font ay dapat i-configure ang editor upang i-activate ang discretionary ligatura. Sa terminal (iTerm2, Windows Terminal) ang mga ligatura ay sinusuportahan din sa pamamagitan ng mga setting ng font. Pagkakatugma: hindi lahat ng editor at terminal ay sumusuporta sa OpenType ligatura. Bago pumili ng font, suriin ang pagkakatugma sa iyong tool.

// Halimbawa: operator ligatura sa JetBrains Mono
val isEqual = a != b  // != na-render bilang ≠
val arrow = x -> x + 1  // -> na-render bilang →
val range = 1 .. 10  // .. na-render bilang range

Mga sikat na font na may programming ligatura: Fira Code (unang mass font na may ligatura, 2015), JetBrains Mono (na-optimize para sa pagbabasa ng code, 2020), Cascadia Code (mula sa Microsoft, 2019), Iosevka (nako-configure na font na may modular na sistema ng ligatura). Ang bawat font ay may sariling set ng mga ligatura — mula 50 hanggang 150+ pagpapalit. Rekomendasyon: magsimula sa Fira Code o JetBrains Mono — sila ay may pinakamahusay na suporta sa mga editor at IDE.