pt — was ist das, Points und Skalierung in iOS

Was ist pt in iOS?

pt (point) — eine logische Maßeinheit in iOS, die es dem Entwickler ermöglicht, die Benutzeroberfläche in abstrakten Koordinaten zu beschreiben, die unabhängig von der physischen Displayauflösung sind. Apple führte das Konzept der Points mit der Veröffentlichung des iPhone 4 und des Retina-Displays im Jahr 2010 ein. Vor Retina verwendeten Entwickler direkt Pixel — ein UI-Pixel entsprach einem physischen Pixel.

Das iOS-Koordinatensystem basiert auf Punkten: Punkt (0,0) befindet sich in der oberen linken Ecke des Bildschirms, die X-Achse verläuft nach rechts, die Y-Achse nach unten. Die Bildschirmgröße in Punkten bleibt für jede Geräteklasse konstant: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (Hochformat), 1024×768 pt (Querformat). Die physische Auflösung kann 1179×2556 px (iPhone 15 Pro) betragen — aber der Entwickler arbeitet mit Punkten.

Laut den Apple Human Interface Guidelines sind Punkte die grundlegende Abstraktion von UIKit. Alle Frameworks — UIKit, SwiftUI, Core Graphics, SpriteKit — arbeiten in Punkten. Die Umwandlung in Pixel erfolgt automatisch während des Renderns über UIScreen.nativeScale.

Skalierungsfaktoren: @1x, @2x, @3x

Der Skalierungsfaktor bestimmt, wie viele physische Pixel einem logischen Punkt entsprechen. Apple verwendet drei Stufen: @1x — 1 pt = 1 px (iPad mini ohne Retina, ältere Modelle), @2x — 1 pt = 2 px (die meisten iPhones vor 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X und neuer, einschließlich iPhone 15 Pro).

Der Skalierungsfaktor ist über UIScreen.main.scale (für UIKit) und @Environment(\.displayScale) (für SwiftUI) verfügbar. Er wird beim Laden von Assets verwendet: Das System wählt automatisch das Bild mit dem Suffix @2x oder @3x aus Assets.xcassets aus. Der Entwickler sollte auf Retina-Geräten keine @1x-Bilder laden — dies verringert Leistung und Qualität.

CGPoint und Koordinaten in Punkten

Die CGPoint-Struktur ist der grundlegende Typ zur Darstellung von Koordinaten in iOS und macOS. Sie enthält zwei Felder: x (CGFloat) und y (CGFloat), die Werte werden in Punkten angegeben. CGPoint wird in allen Apple-Frameworks verwendet: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — Arbeiten mit Koordinaten in Punkten
import UIKit

// Erstellen eines Punkts
let point = CGPoint(x: 100.0, y: 200.0)
print("Koordinaten: \(point.x), \(point.y)")

// Mathematische Operationen
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Abstand zwischen Punkten
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)
}

// Konvertierung von Punkten in Pixel
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Die Methode toPixels im Beispiel demonstriert die Konvertierung von Punkten in physische Pixel über UIScreen.main.scale. In UIKit erfolgt diese Konvertierung automatisch während des Renderns, aber in Core Graphics und bei der Arbeit mit Metal kann der Entwickler eine explizite Pixelkonvertierung benötigen. Alle Animationsberechnungen, Kollisionserkennung und Layouts werden in Punkten durchgeführt.

UIFont.pointSize und Typografie

Die Eigenschaft UIFont.pointSize gibt die Schriftgröße in Punkten zurück — dies ist die standardmäßige Typografie-Einheit in iOS, die aus dem Druckwesen übernommen wurde (1 pt = 1/72 Zoll). Apple verwendet pt für Schriften seit den frühen Versionen von Mac OS. In iOS wird die Schriftgröße in Punkten über UIFont.systemFont(ofSize:) oder über SwiftUI Font.system(size:) angegeben.

// Arbeiten mit UIFont.pointSize in Swift
import UIKit

// Erstellen einer Schriftart mit Größe in pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Lesen von pointSize
print("Titelgröße: \(titleFont.pointSize) pt")

// Dynamic Type — automatische Skalierung
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Skaliert: \(scaledFont.pointSize) pt")

// Vergleich von Schriftgrößen
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics ist ein in iOS 11 hinzugefügter dynamischer Schrift-Skalierungsmechanismus. Er passt pointSize automatisch an die Barrierefreiheitseinstellungen des Benutzers an (Settings > Display & Brightness > Text Size). Ohne UIFontMetrics werden Schriften nicht skaliert, was gegen die WCAG-Barrierefreiheitsanforderungen verstößt.

pt vs px: Unterschiede

Der Unterschied zwischen pt und px ist für das Verständnis der iOS-Entwicklung entscheidend. pt ist eine logische Einheit, px eine physische Einheit. Ein Punkt kann je nach Skalierungsfaktor 1, 2 oder 3 Pixeln entsprechen. Der Entwickler arbeitet in Punkten, das System wandelt sie in der Rasterisierungsphase in Pixel um.

Wichtige Schlussfolgerung: Die Größe der Benutzeroberfläche in Punkten ist auf allen Geräten derselben Klasse identisch. Ein 375 pt breiter Bildschirm — dies gilt sowohl für das iPhone SE als auch für das iPhone 14 (Basismodell). Der einzige Unterschied ist, wie viele physische Pixel in diese 375 pt passen. Dies gewährleistet eine einheitliche UI ohne manuelle Anpassung für jedes Gerät.

pt in SwiftUI

In SwiftUI arbeitet der Entwickler nicht explizit mit Punkten — alle Größen werden über Dp (geräteunabhängige Punkte, äquivalent zu pt) angegeben. SwiftUI wendet den Skalierungsfaktor automatisch beim Rendern an, bietet aber Zugriff darauf über den Umgebungswert displayScale.

// SwiftUI — Arbeiten mit Punkten und Skalierungsfaktor
import SwiftUI

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

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

            Text("Beispiel-Fließtext")
                .font(.body)

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

SwiftUI abstrahiert pt auf Framework-Ebene. .font(.body) verwendet automatisch Dynamic Type — die Schriftgröße passt sich den Benutzereinstellungen an. SwiftUI erlaubt es nicht, die Schriftgröße in Pixeln anzugeben — nur über Font und das Typografie-System. Dies gewährleistet die Barrierefreiheit der Benutzeroberfläche ohne zusätzlichen Aufwand für den Entwickler.