pt — qu'est-ce que c'est, Points et mise à l'échelle dans iOS

Qu'est-ce que pt dans iOS ?

pt (point) — une unité de mesure logique dans iOS qui permet au développeur de décrire l'interface dans des coordonnées abstraites, indépendantes de la résolution physique de l'écran. Apple a introduit le concept de points avec le lancement de l'iPhone 4 et de l'écran Retina en 2010. Avant Retina, les développeurs utilisaient directement les pixels — un pixel d'interface équivalait à un pixel physique.

Le système de coordonnées iOS est basé sur des points : le point (0,0) se trouve dans le coin supérieur gauche de l'écran, l'axe X va vers la droite, l'axe Y vers le bas. La taille de l'écran en points reste constante pour chaque classe d'appareils : iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (portrait), 1024×768 pt (paysage). La résolution physique peut être de 1179×2556 px (iPhone 15 Pro) — mais le développeur travaille avec des points.

Selon les Apple Human Interface Guidelines, les points sont l'abstraction fondamentale d'UIKit. Tous les frameworks — UIKit, SwiftUI, Core Graphics, SpriteKit — opèrent en points. La conversion en pixels se produit automatiquement lors du rendu via UIScreen.nativeScale.

Facteurs d'échelle : @1x, @2x, @3x

Le facteur d'échelle détermine combien de pixels physiques correspondent à un point logique. Apple utilise trois niveaux : @1x — 1 pt = 1 px (iPad mini sans Retina, anciens modèles), @2x — 1 pt = 2 px (la plupart des iPhone antérieurs à 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X et ultérieurs, y compris l'iPhone 15 Pro).

Le facteur d'échelle est accessible via UIScreen.main.scale (pour UIKit) et @Environment(\.displayScale) (pour SwiftUI). Il est utilisé lors du chargement des assets : le système sélectionne automatiquement l'image avec le suffixe @2x ou @3x depuis Assets.xcassets. Le développeur ne doit pas charger d'images @1x sur les appareils Retina — cela réduit les performances et la qualité.

CGPoint et coordonnées en points

La structure CGPoint est le type de base pour représenter les coordonnées dans iOS et macOS. Elle contient deux champs : x (CGFloat) et y (CGFloat), les valeurs sont spécifiées en points. CGPoint est utilisé dans tous les frameworks Apple : UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — travail avec les coordonnées en points
import UIKit

// Création d'un point
let point = CGPoint(x: 100.0, y: 200.0)
print("Coordonnées : \(point.x), \(point.y)")

// Opérations mathématiques
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Distance entre points
func distance(from a: CGPoint, to b: CGPoint) -> CGFloat {
    let dx = b.x - a.x
    let dy = b.y - a.y
    return sqrt(dx * dx + dy * dy)
}

// Conversion de points en pixels
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

La méthode toPixels dans l'exemple montre la conversion de points en pixels physiques via UIScreen.main.scale. Dans UIKit, cette conversion se produit automatiquement lors du rendu, mais dans Core Graphics et lors du travail avec Metal, le développeur peut avoir besoin d'une conversion explicite en pixels. Tous les calculs d'animations, la détection de collisions et la mise en page sont effectués en points.

UIFont.pointSize et typographie

La propriété UIFont.pointSize retourne la taille de la police en points — c'est l'unité typographique standard dans iOS, héritée de l'imprimerie (1 pt = 1/72 pouce). Apple utilise pt pour les polices depuis les premières versions de Mac OS. Dans iOS, la taille de police est spécifiée en points via UIFont.systemFont(ofSize:) ou via SwiftUI Font.system(size:).

// Travail avec UIFont.pointSize dans Swift
import UIKit

// Création d'une police avec taille en pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Lecture de pointSize
print("Taille du titre : \(titleFont.pointSize) pt")

// Dynamic Type — mise à l'échelle automatique
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Mis à l'échelle : \(scaledFont.pointSize) pt")

// Comparaison des tailles de police
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics est un mécanisme de mise à l'échelle dynamique des polices ajouté dans iOS 11. Il ajuste automatiquement pointSize en fonction des paramètres d'accessibilité de l'utilisateur (Settings > Display & Brightness > Text Size). Sans UIFontMetrics, les polices ne sont pas mises à l'échelle, ce qui viole les exigences d'accessibilité WCAG.

pt vs px : différences

La différence entre pt et px est cruciale pour comprendre le développement iOS. pt est une unité logique, px est une unité physique. Un point peut correspondre à 1, 2 ou 3 pixels selon le facteur d'échelle. Le développeur travaille en points, le système les convertit en pixels lors de l'étape de rastérisation.

Conclusion clé : la taille de l'interface en points est la même sur tous les appareils d'une même classe. Un écran de 375 pt de large — cela s'applique à la fois à l'iPhone SE et à l'iPhone 14 (modèle de base). La seule différence est le nombre de pixels physiques qui tiennent dans ces 375 pt. Cela garantit une interface utilisateur uniforme sans adaptation manuelle pour chaque appareil.

pt dans SwiftUI

Dans SwiftUI, le développeur n'opère pas explicitement avec des points — toutes les tailles sont spécifiées via Dp (points indépendants du périphérique, équivalents à pt). SwiftUI applique automatiquement le facteur d'échelle lors du rendu mais fournit un accès via la valeur d'environnement displayScale.

// SwiftUI — travail avec les points et le facteur d'échelle
import SwiftUI

struct ContentView: View {
    @Environment(\.displayScale) private var displayScale

    var body: some View {
        VStack(spacing: 16) {
            Text("Titre")
                .font(.system(size: 28, weight: .bold))

            Text("Texte d'exemple du corps")
                .font(.body)

            HStack {
                Text("Facteur d'échelle :")
                    .font(.caption)
                Text("\(displayScale, specifier: "%.1f")")
                    .font(.caption.weight(.bold))
            }
        }
        .padding(20)
        .frame(width: 300)
    }
}

SwiftUI abstrait pt au niveau du framework. .font(.body) utilise automatiquement Dynamic Type — la taille de police s'adapte aux paramètres de l'utilisateur. SwiftUI ne permet pas de spécifier la taille de police en pixels — uniquement via Font et le système typographique. Cela garantit l'accessibilité de l'interface sans effort supplémentaire du développeur.