“Ligadura” no desenvolvimento mobile — fundamentos e aplicação das conexões de caracteres

O que é uma ligadura na tipografia

Ligadura é uma técnica tipográfica onde dois ou mais caracteres são substituídos por um único glifo especialmente desenhado. O principal propósito de uma ligadura é eliminar conflitos visuais entre caracteres adjacentes e melhorar a percepção do texto. No par fi, por exemplo, a protuberância superior da letra f colide com o ponto da letra i — a ligadura os funde em um único símbolo elegante.

As ligaduras são divididas em obrigatórias (padrão) e opcionais (decorativas). Ligaduras padrão são pares encontrados na maioria das fontes: fi, fl, ff, ffi, ffl. São consideradas necessárias para tipografia de qualidade e estão ativadas na fonte por padrão. De acordo com a Especificação OpenType, ligaduras padrão são codificadas com a tag ‘liga’ e devem estar presentes em qualquer fonte profissional.

Efeito visual: sem ligadura, o par fi parece dois caracteres separados com uma colisão indesejada. Com ligadura, parece um símbolo harmonioso. A diferença é especialmente notável em tamanhos grandes (títulos, logotipos) e em texto com muitos pares repetidos (por exemplo, em alemão com häufigen Buchstabenkombinationen).

Tipos de ligaduras: padrão, discricionárias, contextuais

Fontes OpenType suportam vários tipos de ligaduras, cada uma com sua própria tag e propósito. Padrão (tag ‘liga’) são ligaduras obrigatórias ativadas por padrão em uma fonte. Melhoram a legibilidade e não devem ser desativadas sem um bom motivo. Incluem os pares fi, fl, ff, ffi, ffl e outros específicos da família tipográfica.

Ligaduras discricionárias (tag ‘dlig’) são ligaduras decorativas que são opcionalmente ativadas a critério do designer. Não são necessárias para legibilidade e são usadas para estilização de texto: ct, st, sp, Th, Qu e outras. Ligaduras discricionárias são frequentemente encontradas em fontes com caráter histórico ou caligráfico — por exemplo, em Garamond ou Adobe Caslon. Cuidado: um excesso de ligaduras discricionárias prejudica a legibilidade, especialmente para usuários com dislexia.

Ligaduras contextuais (tag ‘clig’) são ligaduras que dependem do contexto ao redor do caractere. São aplicadas apenas sob certas condições: se o caractere está no início ou fim de uma palavra, após um sinal de pontuação específico, etc. Ligaduras contextuais são um recurso OpenType avançado não suportado por todas as fontes. Ligaduras históricas (tag ‘hlig’) são ligaduras obsoletas que imitam o estilo de livros impressos antigos (long s, &). São raramente usadas, apenas em textos históricos ou estilizados.

Tipos raros: existem também ligaduras para composição matemática (tag ‘dlig’ para símbolos matemáticos) e ligaduras de iniciais (capitulares), mas não são usadas na tipografia de interface e são suportadas apenas por fontes especializadas.

História das ligaduras: do tipo metálico às fontes digitais

As ligaduras apareceram muito antes da tipografia digital — já na era do tipo metálico no século XV. O primeiro impressor Johannes Gutenberg usou ligaduras para economizar espaço nas linhas de sua Bíblia de 42 linhas. Cada tipo era um bloco físico de metal, e combinar dois caracteres em uma única peça economizava chumbo e simplificava a composição. As ligaduras padrão fi, fl, ffi, ffl são um legado dessa época.

Na fotocomposição (século XX), as ligaduras perderam sua função prática mas permaneceram como elemento estético da tipografia de qualidade. Designers de fontes continuaram a incluir ligaduras em suas tipografias, pois se tornaram uma marca de profissionalismo e atenção aos detalhes. Na era das fontes digitais (PostScript, TrueType), as ligaduras eram implementadas como glifos separados com substituição programática.

OpenType (1996) foi uma revolução: introduziu o mecanismo GSUB (Glyph Substitution Table), que substitui automaticamente uma sequência de caracteres por uma ligadura sem intervenção do usuário. GSUB suporta substituições contextuais, condições e variantes de fallback. Isso permitiu que fontes tivessem centenas de ligaduras que podem ser ativadas/desativadas via tags. Fontes modernas — SF Pro, Roboto, Inter — suportam ligaduras OpenType em todas as plataformas: iOS, Android, macOS, Windows, web.

Implementação de ligaduras no iOS via UIFontDescriptor

No iOS, ligaduras podem ser controladas através de UIFontDescriptor usando o atributo featureSettings. Este atributo aceita um array de dicionários, cada um descrevendo um recurso OpenType. Controlar ligaduras através de um descritor é a única forma de gerenciar tipos individuais de ligaduras sem afetar outros recursos OpenType da fonte.

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

// Ativar ligaduras discricionárias
let ligatureDescriptor = descriptor.addingAttributes([
    .featureSettings: [
        [
            UIFontDescriptor.FeatureIdentifier: kLigaturesType,
            UIFontDescriptor.TypeIdentifier: kCommonLigaturesOnSelector
        ]
    ]
])

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

NSAttributedString também suporta o atributo ligature: NSNumber. O valor 0 desativa todas as ligaduras, 1 ativa as padrão (padrão), 2 ativa todas (incluindo discricionárias). No entanto, o atributo ligature no NSAttributedString não fornece controle refinado sobre tipos de ligaduras — apenas ativação/desativação global. Para controle seletivo, use UIFontDescriptor com featureSettings.

SwiftUI não fornece um modificador direto para ligaduras. Para controlar ligaduras no SwiftUI, crie um UIFont com as configurações desejadas via UIFontDescriptor e use-o através de Font(descriptor:size:). Alternativamente, use AttributedString (iOS 15+) com o atributo .ligature para NSMutableAttributedString em visualizações AppKit/UIKit.

// SwiftUI com ligaduras personalizadas via AttributedString
var attributedText: AttributedString {
    var text = AttributedString(
        "Effective typography with ligatures"
    )

    // Ativar todas as ligaduras para o texto inteiro
    text.ligature = .all

    return text
}

var body: some View {
    Text(attributedText)
}

Controle de ligaduras em CSS e Android

Na web, ligaduras são controladas através da propriedade CSS font-variant-ligatures, que aceita palavras-chave: common-ligatures (padrão ativadas), no-common-ligatures (padrão desativadas), discretionary-ligatures, no-discretionary-ligatures, contextual, no-contextual. A propriedade é suportada por todos os navegadores modernos desde 2015. Por padrão, navegadores ativam ligaduras padrão e contextuais.

/* 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ão tem uma API direta para controlar ligaduras. No Android, ligaduras são controladas no nível da fonte e pelo mecanismo de renderização Minikin (Android 10+). Se a fonte contém uma tabela OpenType GSUB, as ligaduras são aplicadas automaticamente. Para desativar ligaduras no Android, são usados Typeface personalizados criados via Typeface.Builder ou pré-processamento de texto (substituição de caracteres antes da exibição). Limitação: no Android anterior ao 10, ligaduras podem não funcionar corretamente com algumas fontes TTF.

Controle de baixo nível: em todas as plataformas, você pode usar CSS @font-face com o parâmetro font-feature-settings para recursos OpenType. Este método fornece acesso a quaisquer tags OpenType, incluindo ligaduras. Exemplo: font-feature-settings: ‘liga’ 1, ‘dlig’ 1. No entanto, font-feature-settings é uma sintaxe de baixo nível, e MDN recomenda usar font-variant-ligatures como alternativa de mais alto nível.

Ligaduras em fontes de programação

Uma classe especial de ligaduras — ligaduras de programação — combinam operadores e símbolos de código em glifos mais legíveis. Fontes de programação como Fira Code, JetBrains Mono, Cascadia Code incluem ligaduras discricionárias para operadores comuns: != (torna-se ≠), >= (torna-se ≥), -> (torna-se seta), => (torna-se seta grossa), === (torna-se triplo igual).

Ligaduras de programação são um tópico controverso na comunidade de desenvolvedores. Defensores argumentam que ligaduras aceleram a leitura de código porque operadores são percebidos como conceitos únicos. Um estudo (Kera et al., PLATEAU 2020) mostrou que ligaduras não afetam a velocidade de leitura de código, mas 67% dos desenvolvedores gostam subjetivamente delas. Opositores de ligaduras notam que elas distorcem o código: o símbolo != no editor exibe como ≠, mas no arquivo de texto é armazenado como dois caracteres, o que pode ser confuso durante a colaboração.

Implementação técnica: ligaduras de programação são ligaduras discricionárias OpenType (tag ‘dlig’). Estão desativadas por padrão e são ativadas no editor de código através de configurações de fonte. Desenvolvedores que usam essas fontes devem configurar o editor para ativar ligaduras discricionárias. Em terminais (iTerm2, Windows Terminal), ligaduras também são suportadas através de configurações de fonte. Compatibilidade: nem todos editores e terminais suportam ligaduras OpenType. Antes de escolher uma fonte, verifique a compatibilidade com seu conjunto de ferramentas.

// Exemplo: ligaduras de operadores no JetBrains Mono
val isEqual = a != b  // != renderizado como ≠
val arrow = x -> x + 1  // -> renderizado como →
val range = 1 .. 10  // .. renderizado como intervalo

Fontes populares com ligaduras de programação: Fira Code (a primeira fonte massiva com ligaduras, 2015), JetBrains Mono (otimizada para leitura de código, 2020), Cascadia Code (da Microsoft, 2019), Iosevka (fonte personalizável com sistema modular de ligaduras). Cada fonte tem seu próprio conjunto de ligaduras — de 50 a 150+ substituições. Recomendação: comece com Fira Code ou JetBrains Mono — elas têm o melhor suporte em editores e IDEs.