« Ligature » dans le développement mobile — principes et application des connexions de caractères

Qu’est-ce qu’une ligature en typographie

Ligature est une technique typographique où deux caractères ou plus sont remplacés par un seul glyphe spécialement conçu. Le but principal d’une ligature est d’éliminer les conflits visuels entre les caractères adjacents et d’améliorer la perception du texte. Dans la paire fi, par exemple, la protubérance supérieure de la lettre f entre en collision avec le point de la lettre i — la ligature les fusionne en un seul symbole élégant.

Les ligatures sont divisées en obligatoires (standard) et optionnelles (décoratives). Les ligatures standard sont des paires que l’on trouve dans la plupart des polices : fi, fl, ff, ffi, ffl. Elles sont considérées comme nécessaires pour une typographie de qualité et sont activées par défaut dans la police. Selon la spécification OpenType, les ligatures standard sont codées avec la balise ‘liga’ et doivent être présentes dans toute police professionnelle.

Effet visuel : sans ligature, la paire fi ressemble à deux caractères séparés avec une collision indésirable. Avec une ligature, elle ressemble à un symbole harmonieux. La différence est surtout notable dans les grandes tailles (titres, logos) et dans les textes comportant de nombreuses paires répétées (par exemple, en allemand avec häufigen Buchstabenkombinationen).

Types de ligatures : standard, discrétionnaires, contextuelles

Les polices OpenType prennent en charge plusieurs types de ligatures, chacun avec sa propre balise et son propre objectif. Standard (balise ‘liga’) — ce sont des ligatures obligatoires activées par défaut dans une police. Elles améliorent la lisibilité et ne doivent pas être désactivées sans raison valable. Elles incluent les paires fi, fl, ff, ffi, ffl et d’autres spécifiques à la police.

Ligatures discrétionnaires (balise ‘dlig’) — ce sont des ligatures décoratives qui sont activées optionnellement à la discrétion du concepteur. Elles ne sont pas nécessaires à la lisibilité et sont utilisées pour styliser le texte : ct, st, sp, Th, Qu et autres. Les ligatures discrétionnaires se trouvent souvent dans les polices au caractère historique ou calligraphique — par exemple, dans Garamond ou Adobe Caslon. Mise en garde : un excès de ligatures discrétionnaires nuit à la lisibilité, en particulier pour les utilisateurs dyslexiques.

Ligatures contextuelles (balise ‘clig’) — ce sont des ligatures qui dépendent du contexte environnant du caractère. Elles ne sont appliquées que sous certaines conditions : si le caractère est au début ou à la fin d’un mot, après un signe de ponctuation spécifique, etc. Les ligatures contextuelles sont une fonctionnalité OpenType avancée qui n’est pas prise en charge par toutes les polices. Ligatures historiques (balise ‘hlig’) — ce sont des ligatures obsolètes qui imitent le style des vieux livres imprimés (long s, &). Elles sont rarement utilisées, uniquement dans les textes historiques ou stylisés.

Types rares : il existe également des ligatures pour la composition mathématique (balise ‘dlig’ pour les symboles mathématiques) et des ligatures d’initiales (lettrines), mais elles ne sont pas utilisées dans la typographie d’interface et ne sont prises en charge que par des polices spécialisées.

Histoire des ligatures : du caractère métallique aux polices numériques

Les ligatures sont apparues bien avant la typographie numérique — dès l’ère du caractère métallique au XVe siècle. Le premier imprimeur Johannes Gutenberg utilisait des ligatures pour économiser de l’espace dans les lignes de sa Bible à 42 lignes. Chaque caractère était un bloc de métal physique, et la combinaison de deux caractères en une seule pièce économisait le plomb et simplifiait la composition. Les ligatures standard fi, fl, ffi, ffl sont un héritage de cette époque.

Dans la photocomposition (XXe siècle), les ligatures ont perdu leur fonction pratique mais sont restées comme élément esthétique d’une typographie de qualité. Les créateurs de polices ont continué à inclure des ligatures dans leurs caractères, car elles sont devenues une marque de professionnalisme et d’attention aux détails. À l’ère des polices numériques (PostScript, TrueType), les ligatures étaient implémentées comme des glyphes séparés avec un remplacement programmatique.

OpenType (1996) a été une révolution : il a introduit le mécanisme GSUB (Glyph Substitution Table), qui remplace automatiquement une séquence de caractères par une ligature sans intervention de l’utilisateur. GSUB prend en charge les substitutions contextuelles, les conditions et les variantes de secours. Cela a permis aux polices d’avoir des centaines de ligatures qui peuvent être activées/désactivées via des balises. Polices modernes — SF Pro, Roboto, Inter — prennent en charge les ligatures OpenType sur toutes les plateformes : iOS, Android, macOS, Windows, web.

Implémentation des ligatures sur iOS via UIFontDescriptor

Sur iOS, les ligatures peuvent être contrôlées via UIFontDescriptor à l’aide de l’attribut featureSettings. Cet attribut accepte un tableau de dictionnaires, chacun décrivant une fonctionnalité OpenType. Contrôler les ligatures via un descripteur est le seul moyen de gérer des types individuels de ligatures sans affecter les autres fonctionnalités OpenType de la police.

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

// Activer les ligatures discrétionnaires
let ligatureDescriptor = descriptor.addingAttributes([
    .featureSettings: [
        [
            UIFontDescriptor.FeatureIdentifier: kLigaturesType,
            UIFontDescriptor.TypeIdentifier: kCommonLigaturesOnSelector
        ]
    ]
])

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

NSAttributedString prend également en charge l’attribut ligature : NSNumber. La valeur 0 désactive toutes les ligatures, 1 active les standard (par défaut), 2 active toutes (y compris les discrétionnaires). Cependant, l’attribut ligature dans NSAttributedString n’offre pas de contrôle fin sur les types de ligatures — seulement une activation/désactivation globale. Pour un contrôle sélectif, utilisez UIFontDescriptor avec featureSettings.

SwiftUI ne fournit pas de modificateur direct pour les ligatures. Pour contrôler les ligatures dans SwiftUI, créez un UIFont avec les paramètres souhaités via UIFontDescriptor et utilisez-le via Font(descriptor:size:). Alternativement, utilisez AttributedString (iOS 15+) avec l’attribut .ligature pour NSMutableAttributedString dans les vues AppKit/UIKit.

// SwiftUI avec ligatures personnalisées via AttributedString
var attributedText: AttributedString {
    var text = AttributedString(
        "Effective typography with ligatures"
    )

    // Activer toutes les ligatures pour l’ensemble du texte
    text.ligature = .all

    return text
}

var body: some View {
    Text(attributedText)
}

Contrôle des ligatures en CSS et sur Android

Sur le web, les ligatures sont contrôlées via la propriété CSS font-variant-ligatures, qui accepte les mots-clés : common-ligatures (standard activées), no-common-ligatures (standard désactivées), discretionary-ligatures, no-discretionary-ligatures, contextual, no-contextual. La propriété est prise en charge par tous les navigateurs modernes depuis 2015. Par défaut, les navigateurs activent les ligatures standard et contextuelles.

/* 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 n’a pas d’API directe pour contrôler les ligatures. Sur Android, les ligatures sont contrôlées au niveau de la police et par le moteur de rendu Minikin (Android 10+). Si la police contient une table OpenType GSUB, les ligatures sont appliquées automatiquement. Pour désactiver les ligatures sur Android, on utilise des polices personnalisées créées via Typeface.Builder ou un prétraitement du texte (remplacement de caractères avant l’affichage). Limitation : sur Android antérieur à 10, les ligatures peuvent ne pas fonctionner correctement avec certaines polices TTF.

Contrôle bas niveau : sur toutes les plateformes, vous pouvez utiliser CSS @font-face avec le paramètre font-feature-settings pour les fonctionnalités OpenType. Cette méthode donne accès à toutes les balises OpenType, y compris les ligatures. Exemple : font-feature-settings : ‘liga’ 1, ‘dlig’ 1. Cependant, font-feature-settings est une syntaxe de bas niveau, et MDN recommande d’utiliser font-variant-ligatures comme alternative de plus haut niveau.

Ligatures dans les polices de programmation

Une classe spéciale de ligatures — ligatures de programmation — combine les opérateurs et les symboles de code en glyphes plus lisibles. Les polices de programmation comme Fira Code, JetBrains Mono, Cascadia Code incluent des ligatures discrétionnaires pour les opérateurs courants : != (devient ≠), >= (devient ≥), -> (devient flèche), => (devient flèche épaisse), === (devient triple égal).

Les ligatures de programmation sont un sujet controversé dans la communauté des développeurs. Les partisans soutiennent que les ligatures accélèrent la lecture du code car les opérateurs sont perçus comme des concepts uniques. Une étude (Kera et al., PLATEAU 2020) a montré que les ligatures n’affectent pas la vitesse de lecture du code, mais que 67 % des développeurs les apprécient subjectivement. Les opposants aux ligatures notent qu’elles déforment le code : le symbole != dans l’éditeur s’affiche comme ≠, mais dans le fichier texte, il est stocké comme deux caractères, ce qui peut prêter à confusion lors de la collaboration.

Implémentation technique : les ligatures de programmation sont des ligatures discrétionnaires OpenType (balise ‘dlig’). Elles sont désactivées par défaut et activées dans l’éditeur de code via les paramètres de police. Les développeurs qui utilisent ces polices doivent configurer l’éditeur pour activer les ligatures discrétionnaires. Dans les terminaux (iTerm2, Windows Terminal), les ligatures sont également prises en charge via les paramètres de police. Compatibilité : tous les éditeurs et terminaux ne prennent pas en charge les ligatures OpenType. Avant de choisir une police, vérifiez la compatibilité avec votre environnement d’outils.

// Exemple : ligatures d’opérateurs dans JetBrains Mono
val isEqual = a != b  // != rendu comme ≠
val arrow = x -> x + 1  // -> rendu comme →
val range = 1 .. 10  // .. rendu comme intervalle

Polices populaires avec ligatures de programmation : Fira Code (la première police grand public avec ligatures, 2015), JetBrains Mono (optimisée pour la lecture de code, 2020), Cascadia Code (de Microsoft, 2019), Iosevka (police personnalisable avec un système modulaire de ligatures). Chaque police a son propre ensemble de ligatures — de 50 à 150+ substitutions. Recommandation : commencez par Fira Code ou JetBrains Mono — elles ont la meilleure prise en charge dans les éditeurs et les IDE.