pt — vad det är, Points och skalning i iOS

Vad är pt i iOS?

pt (point) — logisk måttenhet i iOS som låter utvecklaren beskriva gränssnittet i abstrakta koordinater, oberoende av skärmens fysiska upplösning. Apple introducerade begreppet point med lanseringen av iPhone 4 och Retina-skärmen 2010. Före Retina använde utvecklare pixlar direkt — en UI-pixel var lika med en fysisk pixel.

iOS koordinatsystem är byggt på punkter: punkten (0,0) finns i skärmens övre vänstra hörn, X-axeln pekar åt höger, Y-axeln nedåt. Skärmstorleken i punkter förblir konstant för varje enhetsklass: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (stående), 1024×768 pt (liggande). Den fysiska upplösningen kan vara 1179×2556 px (iPhone 15 Pro) — men utvecklaren arbetar med punkter.

Enligt Apple Human Interface Guidelines är punkter den grundläggande abstraktionen i UIKit. Alla ramverk — UIKit, SwiftUI, Core Graphics, SpriteKit — arbetar med punkter. Konvertering till pixlar sker automatiskt i renderingsfasen via UIScreen.nativeScale.

Skalfaktorer: @1x, @2x, @3x

Skalfaktorn (scale factor) bestämmer hur många fysiska pixlar som motsvarar en logisk punkt. Apple använder tre nivåer: @1x — 1 pt = 1 px (iPad mini utan Retina, äldre modeller), @2x — 1 pt = 2 px (de flesta iPhone fram till 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X och nyare, inklusive iPhone 15 Pro).

Värdet för scale factor är tillgängligt via UIScreen.main.scale (för UIKit) och @Environment(\.displayScale) (för SwiftUI). Används vid inläsning av tillgångar: systemet väljer automatiskt bilden med suffixet @2x eller @3x från Assets.xcassets. Utvecklaren laddar inte @1x-bilder på Retina-enheter — detta minskar prestanda och kvalitet.

CGPoint och koordinater i punkter

Strukturen CGPoint — grundtypen för representation av koordinater i iOS och macOS. Innehåller två fält: x (CGFloat) och y (CGFloat), värden anges i punkter. CGPoint används i alla Apple-ramverk: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — arbete med koordinater i punkter
import UIKit

// Skapa punkt
let point = CGPoint(x: 100.0, y: 200.0)
print("Koordinater: \(point.x), \(point.y)")

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

// Avstånd mellan punkter
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)
}

// Konvertera punkt till pixlar
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Metoden toPixels i exemplet visar konvertering av punkter till fysiska pixlar via UIScreen.main.scale. I UIKit sker denna konvertering automatiskt vid rendering, men i Core Graphics och vid arbete med Metal kan utvecklaren behöva explicit konvertering till pixlar. Alla animeringsberäkningar, kollisionsdetektering och layout utförs i punkter.

UIFont.pointSize och typografi

Egenskapen UIFont.pointSize returnerar teckenstorleken i punkter — detta är standard typografienhet i iOS, ärvd från tryckkonsten (1 pt = 1/72 tum). Apple använder pt för teckensnitt sedan de första versionerna av Mac OS. I iOS ställs teckenstorleken in i punkter via UIFont.systemFont(ofSize:) eller via SwiftUI Font.system(size:).

// Arbete med UIFont.pointSize i Swift
import UIKit

// Skapa teckensnitt med storlek i pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Läsa pointSize
print("Rubrikstorlek: \(titleFont.pointSize) pt")

// Dynamisk typ — automatisk skalning
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Skalad: \(scaledFont.pointSize) pt")

// Jämföra teckenstorlekar
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — mekanismen för dynamisk skalning av teckensnitt, tillagd i iOS 11. Justerar automatiskt pointSize baserat på användarens tillgänglighetsinställningar (Settings > Display & Brightness > Text Size). Utan UIFontMetrics skalas inte teckensnitten, vilket bryter mot WCAG:s tillgänglighetskrav.

pt vs px: skillnader

Skillnaden mellan pt och px är avgörande för att förstå iOS-utveckling. pt — logisk enhet, px — fysisk enhet. En punkt kan motsvara 1, 2 eller 3 pixlar beroende på scale factor. Utvecklaren arbetar med punkter, systemet omvandlar dem till pixlar i rasteriseringsfasen.

Den viktigaste slutsatsen: gränssnittsstorleken i punkter är densamma på alla enheter av samma klass. En skärm som är 375 pt bred — det är både iPhone SE och iPhone 14 (basmodell). Skillnaden är bara hur många fysiska pixlar som får plats i dessa 375 pt. Detta säkerställer ett enhetligt UI utan manuell anpassning för varje enhet.

pt i SwiftUI

I SwiftUI arbetar utvecklaren inte explicit med punkter — alla storlekar anges via Dp (device-independent points, motsvarighet till pt). SwiftUI tillämpar automatiskt scale factor vid rendering, men ger åtkomst via environment value displayScale.

// SwiftUI — arbete med punkter och scale factor
import SwiftUI

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

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

            Text("Exemplets huvudtext")
                .font(.body)

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

SwiftUI abstraherar pt på ramverksnivå. .font(.body) använder automatiskt Dynamic Type — teckenstorleken anpassas till användarens inställningar. SwiftUI tillåter inte att teckenstorlek ställs in i pixlar — endast via Font och typografisystemet. Detta garanterar gränssnittets tillgänglighet utan extra ansträngning från utvecklaren.