pt — ce este, puncte și scalare în iOS

Ce este pt în iOS?

pt (point) — unitatea logică de măsură în iOS care permite dezvoltatorului să descrie interfața în coordonate abstracte, independente de rezoluția fizică a ecranului. Apple a introdus conceptul de point odată cu lansarea iPhone 4 și a ecranului Retina în 2010. Înainte de Retina, dezvoltatorii foloseau pixelii direct — un pixel UI egal cu un pixel fizic.

Sistemul de coordonate iOS este construit pe puncte: punctul (0,0) se află în colțul din stânga sus al ecranului, axa X este orientată spre dreapta, axa Y — în jos. Dimensiunea ecranului în puncte rămâne constantă pentru fiecare clasă de dispozitive: iPhone SE — 375×667 pt, iPhone 15 Pro — 393×852 pt, iPad — 768×1024 pt (portret), 1024×768 pt (peisaj). Rezoluția fizică poate fi 1179×2556 px (iPhone 15 Pro) — dar dezvoltatorul lucrează cu puncte.

Conform Apple Human Interface Guidelines, punctele sunt abstracția fundamentală a UIKit. Toate frameworkurile — UIKit, SwiftUI, Core Graphics, SpriteKit — operează cu puncte. Conversia în pixeli are loc automat în etapa de randare prin UIScreen.nativeScale.

Coeficienții de scară: @1x, @2x, @3x

Coeficientul de scară (scale factor) determină câți pixeli fizici corespund unui punct logic. Apple folosește trei nivele: @1x — 1 pt = 1 px (iPad mini fără Retina, modele vechi), @2x — 1 pt = 2 px (majoritatea iPhone-urilor până în 2020, iPad Retina), @3x — 1 pt = 3 px (iPhone X și mai noi, inclusiv iPhone 15 Pro).

Valoarea scale factor este disponibilă prin UIScreen.main.scale (pentru UIKit) și @Environment(\.displayScale) (pentru SwiftUI). Se utilizează la încărcarea resurselor: sistemul selectează automat imaginea cu sufixul @2x sau @3x din Assets.xcassets. Dezvoltatorul nu încarcă imagini @1x pe dispozitivele cu Retina — aceasta reduce performanța și calitatea.

CGPoint și coordonate în puncte

Structura CGPoint — tipul de bază pentru reprezentarea coordonatelor în iOS și macOS. Conține două câmpuri: x (CGFloat) și y (CGFloat), valorile sunt date în puncte. CGPoint este utilizat în toate frameworkurile Apple: UIKit (frame.origin), Core Graphics (CGContext), SpriteKit (SKNode.position), Core Animation (CALayer.position).

// CGPoint — lucrul cu coordonate în puncte
import UIKit

// Crearea punctului
let point = CGPoint(x: 100.0, y: 200.0)
print("Coordonate: \(point.x), \(point.y)")

// Operații matematice
let offset = CGPoint(x: 16.0, y: 8.0)
let translated = CGPoint(
    x: point.x + offset.x,
    y: point.y + offset.y
)

// Distanța dintre puncte
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)
}

// Conversia punctului în pixeli
extension CGPoint {
    func toPixels(scale: CGFloat) -> CGPoint {
        CGPoint(x: x * scale, y: y * scale)
    }
}

Metoda toPixels din exemplu demonstrează conversia punctelor în pixeli fizici prin UIScreen.main.scale. În UIKit această conversie are loc automat la randare, dar în Core Graphics și la lucrul cu Metal, dezvoltatorul poate avea nevoie de o conversie explicită în pixeli. Toate calculele de animații, detectarea coliziunilor și layout-ul se execută în puncte.

UIFont.pointSize și tipografie

Proprietatea UIFont.pointSize returnează dimensiunea fontului în puncte — aceasta este unitatea standard de tipografie în iOS, moștenită din poligrafie (1 pt = 1/72 de țol). Apple folosește pt pentru fonturi de la primele versiuni Mac OS. În iOS dimensiunea fontului se setează în puncte prin UIFont.systemFont(ofSize:) sau prin SwiftUI Font.system(size:).

// Lucrul cu UIFont.pointSize în Swift
import UIKit

// Crearea fontului cu dimensiunea în pt
let titleFont = UIFont.systemFont(ofSize: 28.0, weight: .bold)
let bodyFont = UIFont.systemFont(ofSize: 17.0)
let captionFont = UIFont.systemFont(ofSize: 12.0)

// Citirea pointSize
print("Dimensiunea titlului: \(titleFont.pointSize) pt")

// Tip dinamic — scalare automată
let scaledFont = UIFontMetrics.default.scaledFont(for: bodyFont)
print("Scalat: \(scaledFont.pointSize) pt")

// Compararea dimensiunilor fonturilor
func font(from size: CGFloat, weight: UIFont.Weight) -> UIFont {
    UIFont.systemFont(ofSize: size, weight: weight)
}

UIFontMetrics — mecanismul de scalare dinamică a fonturilor, adăugat în iOS 11. Corectează automat pointSize în funcție de setările de accesibilitate ale utilizatorului (Settings > Display & Brightness > Text Size). Fără utilizarea UIFontMetrics, fonturile nu se scalează, ceea ce încalcă cerințele WCAG privind accesibilitatea.

pt vs px: diferențe

Diferența dintre pt și px este critică pentru înțelegerea dezvoltării iOS. pt — unitate logică, px — unitate fizică. Un punct poate corespunde la 1, 2 sau 3 pixeli în funcție de scale factor. Dezvoltatorul operează cu puncte, sistemul le transformă în pixeli în etapa de rasterizare.

Consecința cheie: dimensiunea interfeței în puncte este aceeași pe toate dispozitivele din aceeași clasă. Ecranul de 375 pt lățime — este atât iPhone SE, cât și iPhone 14 (modelul de bază). Diferența constă doar în câți pixeli fizici încap în acești 375 pt. Aceasta asigură o interfață uniformă fără adaptare manuală pentru fiecare dispozitiv.

pt în SwiftUI

În SwiftUI dezvoltatorul nu operează explicit cu puncte — toate dimensiunile sunt date prin Dp (device-independent points, echivalentul pt). SwiftUI aplică automat scale factor la randare, dar oferă acces la acesta prin environment value displayScale.

// SwiftUI — lucrul cu puncte și scale factor
import SwiftUI

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

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

            Text("Textul principal al exemplului")
                .font(.body)

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

SwiftUI abstractizează pt la nivel de framework. .font(.body) folosește automat Dynamic Type — dimensiunea fontului se adaptează la setările utilizatorului. SwiftUI nu permite setarea dimensiunii fontului în pixeli — doar prin Font și sistemul de tipografie. Aceasta garantează accesibilitatea interfeței fără efort suplimentar din partea dezvoltatorului.