pt — co to je, body a škálování v iOS

Co je pt v iOS?

pt (point) — logická jednotka měření v iOS, která umožňuje vývojáři popsat rozhraní v abstraktních souřadnicích, nezávislých na fyzickém rozlišení displeje. Apple zavedl koncept pointů s vydáním iPhone 4 a Retina displeje v roce 2010. Před Retinou používali vývojáři pixely přímo — jeden UI pixel se rovnal jednomu fyzickému pixelu.

Souřadnicový systém iOS je postaven na bodech: bod (0,0) se nachází v levém horním rohu obrazovky, osa X směřuje doprava, osa Y — dolů. Velikost obrazovky v bodech zůstává konstantní pro každou třídu zařízení: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (na výšku), 1024×768 pt (na šířku). Fyzické rozlišení může být 1179×2556 px (iPhone 15 Pro) — ale vývojář pracuje s body.

Podle Apple Human Interface Guidelines jsou body základní abstrakcí UIKit. Všechny frameworky — UIKit, SwiftUI, Core Graphics, SpriteKit — pracují s body. Převod na pixely probíhá automaticky ve fázi vykreslování prostřednictvím UIScreen.nativeScale.

Faktory měřítka: @1x, @2x, @3x

Faktor měřítka (scale factor) určuje, kolik fyzických pixelů odpovídá jednomu logickému bodu. Apple používá tři úrovně: @1x — 1 pt = 1 px (iPad mini bez Retina, starší modely), @2x — 1 pt = 2 px (většina iPhoneů do roku 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X a novější, včetně iPhone 15 Pro).

Hodnota scale factor je dostupná přes UIScreen.main.scale (pro UIKit) a @Environment(\.displayScale) (pro SwiftUI). Používá se při načítání aktiv: systém automaticky vybere obrázek s příponou @2x nebo @3x z Assets.xcassets. Vývojář nenačítá @1x obrázky na zařízeních s Retina — to snižuje výkon a kvalitu.

CGPoint a souřadnice v bodech

Struktura CGPoint — základní typ pro reprezentaci souřadnic v iOS a macOS. Obsahuje dvě pole: x (CGFloat) a y (CGFloat), hodnoty jsou udávány v bodech. CGPoint se používá ve všech Apple frameworkách: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — práce se souřadnicemi v bodech
import UIKit

// Vytvoření bodu
let point = CGPoint(x: 100.0, y: 200.0)
print("Souřadnice: \(point.x), \(point.y)")

// Matematické operace
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Vzdálenost mezi body
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)
}

// Převod bodu na pixely
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Metoda toPixels v příkladu demonstruje převod bodů na fyzické pixely přes UIScreen.main.scale. V UIKit tento převod probíhá automaticky při vykreslování, ale v Core Graphics a při práci s Metal může vývojář potřebovat explicitní převod na pixely. Všechny výpočty animací, detekce kolizí a rozvržení se provádějí v bodech.

UIFont.pointSize a typografie

Vlastnost UIFont.pointSize vrací velikost písma v bodech — to je standardní typografická jednotka v iOS, zděděná z polygrafie (1 pt = 1/72 palce). Apple používá pt pro písma od prvních verzí Mac OS. V iOS se velikost písma nastavuje v bodech přes UIFont.systemFont(ofSize:) nebo přes SwiftUI Font.system(size:).

// Práce s UIFont.pointSize ve Swift
import UIKit

// Vytvoření písma s velikostí v pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Čtení pointSize
print("Velikost nadpisu: \(titleFont.pointSize) pt")

// Dynamický typ — automatické škálování
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Naškálováno: \(scaledFont.pointSize) pt")

// Porovnání velikostí písem
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — mechanismus dynamického škálování písem, přidaný v iOS 11. Automaticky upravuje pointSize podle nastavení přístupnosti uživatele (Settings > Display & Brightness > Text Size). Bez použití UIFontMetrics se písma neškálují, což porušuje požadavky WCAG na přístupnost.

pt vs px: rozdíly

Rozdíl mezi pt a px je klíčový pro pochopení vývoje pro iOS. pt — logická jednotka, px — fyzická jednotka. Jeden bod může odpovídat 1, 2 nebo 3 pixelům v závislosti na scale factor. Vývojář pracuje s body, systém je převádí na pixely ve fázi rasterizace.

Klíčový důsledek: velikost rozhraní v bodech je stejná na všech zařízeních stejné třídy. Obrazovka široká 375 pt — to je jak iPhone SE, tak iPhone 14 (základní model). Rozdíl je pouze v tom, kolik fyzických pixelů se do těchto 375 pt vejde. To zajišťuje jednotné uživatelské rozhraní bez ruční adaptace pro každé zařízení.

pt ve SwiftUI

Ve SwiftUI vývojář nepracuje explicitně s body — všechny velikosti se udávají přes Dp (device-independent points, ekvivalent pt). SwiftUI automaticky aplikuje scale factor při vykreslování, ale poskytuje k němu přístup přes environment value displayScale.

// SwiftUI — práce s body a scale factor
import SwiftUI

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

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

            Text("Hlavní text příkladu")
                .font(.body)

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

SwiftUI abstrahuje pt na úrovni frameworku. .font(.body) automaticky používá Dynamic Type — velikost písma se přizpůsobuje nastavení uživatele. SwiftUI neumožňuje nastavit velikost písma v pixelech — pouze přes Font a typografický systém. To zaručuje přístupnost rozhraní bez dalšího úsilí vývojáře.