pt — mi ez, pontok és skálázás iOS-ben

Mi az a pt iOS-ben?

pt (point) — logikai mértékegység iOS-ben, amely lehetővé teszi a fejlesztő számára, hogy a felületet absztrakt koordinátákban írja le, függetlenül a kijelző fizikai felbontásától. Az Apple 2010-ben vezette be a point fogalmát az iPhone 4 és a Retina kijelző megjelenésével. A Retina előtt a fejlesztők közvetlenül pixeleket használtak — egy UI pixel egy fizikai pixelnek felelt meg.

Az iOS koordináta-rendszere pontokra épül: a (0,0) pont a képernyő bal felső sarkában van, az X tengely jobbra, az Y tengely lefelé mutat. A képernyő mérete pontokban állandó minden eszközosztályban: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (álló), 1024×768 pt (fekvő). A fizikai felbontás lehet 1179×2556 px (iPhone 15 Pro) — de a fejlesztő pontokkal dolgozik.

Az Apple Human Interface Guidelines szerint a pontok a UIKit alapvető absztrakciói. Az összes keretrendszer — UIKit, SwiftUI, Core Graphics, SpriteKit — pontokkal működik. A pixelekké alakítás automatikusan történik a renderelési fázisban a UIScreen.nativeScale segítségével.

Skálázási tényezők: @1x, @2x, @3x

A skálázási tényező (scale factor) határozza meg, hogy hány fizikai pixel felel meg egy logikai pontnak. Az Apple három szintet használ: @1x — 1 pt = 1 px (Retina nélküli iPad mini, régebbi modellek), @2x — 1 pt = 2 px (a legtöbb iPhone 2020-ig, iPad Retina), @3x — 1 pt = 3 px (iPhone X és újabbak, beleértve az iPhone 15 Pro-t).

A scale factor értéke elérhető a UIScreen.main.scale (UIKit esetén) és a @Environment(\.displayScale) (SwiftUI esetén) segítségével. Az eszközök betöltésekor használatos: a rendszer automatikusan kiválasztja a @2x vagy @3x utótagú képet az Assets.xcassets-ből. A fejlesztő nem tölt be @1x képeket Retina eszközökön — ez csökkenti a teljesítményt és a minőséget.

CGPoint és koordináták pontokban

A CGPoint struktúra — az alapvető típus a koordináták reprezentálásához iOS és macOS rendszerekben. Két mezőt tartalmaz: x (CGFloat) és y (CGFloat), az értékek pontokban vannak megadva. A CGPoint az összes Apple keretrendszerben használatos: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — munka koordinátákkal pontokban
import UIKit

// Pont létrehozása
let point = CGPoint(x: 100.0, y: 200.0)
print("Koordináták: \(point.x), \(point.y)")

// Matematikai műveletek
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Pontok közötti távolság
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)
}

// Pont átalakítása pixelekké
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

A toPixels metódus a példában a pontok fizikai pixelekké alakítását mutatja be a UIScreen.main.scale segítségével. A UIKit-ben ez az átalakítás automatikusan megtörténik rendereléskor, de a Core Graphics és a Metal használatakor a fejlesztőnek szüksége lehet explicit pixelekké alakításra. Minden animációs számítás, ütközésérzékelés és elrendezés pontokban történik.

UIFont.pointSize és tipográfia

A UIFont.pointSize tulajdonság a betűméretet pontokban adja vissza — ez a tipográfia szabványos mértékegysége iOS-ben, a nyomdászatból örökölve (1 pt = 1/72 hüvelyk). Az Apple a Mac OS első verziói óta pt-t használ a betűtípusokhoz. iOS-ben a betűméret pontokban állítható be a UIFont.systemFont(ofSize:) vagy a SwiftUI Font.system(size:) segítségével.

// Munka a UIFont.pointSize-szal Swift-ben
import UIKit

// Betűtípus létrehozása pt mérettel
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// pointSize olvasása
print("Cím mérete: \(titleFont.pointSize) pt")

// Dinamikus típus — automatikus skálázás
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Skálázott: \(scaledFont.pointSize) pt")

// Betűméretek összehasonlítása
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — a betűtípusok dinamikus skálázásának mechanizmusa, amely az iOS 11-ben került bevezetésre. Automatikusan korrigálja a pointSize-ot a felhasználó akadálymentesítési beállításai alapján (Settings > Display & Brightness > Text Size). A UIFontMetrics használata nélkül a betűtípusok nem skálázódnak, ami sérti a WCAG akadálymentesítési követelményeit.

pt vs px: különbségek

A pt és px közötti különbség kritikus az iOS fejlesztés megértéséhez. pt — logikai egység, px — fizikai egység. Egy pont 1, 2 vagy 3 pixelnek felelhet meg a scale factortól függően. A fejlesztő pontokkal dolgozik, a rendszer pixelekké alakítja azokat a raszterizációs fázisban.

A kulcsfontosságú következmény: a felület mérete pontokban azonos az összes azonos osztályú eszközön. A 375 pt széles képernyő — ez mind az iPhone SE, mind az iPhone 14 (alapmodell). A különbség csak abban van, hogy hány fizikai pixel fér el ebbe a 375 pt-be. Ez egységes UI-t biztosít minden eszköz kézi adaptációja nélkül.

pt SwiftUI-ben

A SwiftUI-ben a fejlesztő nem explicit módon dolgozik pontokkal — minden méret Dp-n (device-independent points, a pt megfelelője) keresztül van megadva. A SwiftUI automatikusan alkalmazza a scale factort a renderelés során, de hozzáférést biztosít hozzá az environment value displayScale segítségével.

// SwiftUI — munka pontokkal és scale factor-ral
import SwiftUI

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

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

            Text("Példa fő szövege")
                .font(.body)

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

A SwiftUI elvonatkoztatja a pt-t a keretrendszer szintjén. A .font(.body) automatikusan használja a Dynamic Type-ot — a betűméret a felhasználó beállításaihoz igazodik. A SwiftUI nem teszi lehetővé a betűméret pixelekben történő beállítását — csak a Font és a tipográfiai rendszeren keresztül. Ez garantálja a felület akadálymentesítését a fejlesztő további erőfeszítése nélkül.