Illustrating the force, altitude, and azimuth properties of touch input

At a glance

Project structure

TouchCanvas/
├── ViewController.swift
├── CanvasView.swift
├── Line.swift
├── ReticleView.swift
├── Formatters.swift
├── SeparatorView.swift
├── AppDelegate.swift
└── Base.lproj/Main.storyboard

Structure observations

• Raw touch routing stays in the controller, but stroke lifecycle and rendering state stay in CanvasView.
• Line.swift groups the aggregate, point value, OptionSet tags, update matching, and drawing behavior.
• Reticle geometry and high-frequency label formatting are isolated from the canvas pipeline.

Overall architecture

flowchart LR
    UIKit["UIKit touch callbacks"] --> Controller["ViewController"]
    Controller --> Canvas["CanvasView"]
    Controller --> Reticle["ReticleView and labels"]
    Event["UIEvent"] --> Coalesced["coalesced touches"]
    Event --> Predicted["predicted touches"]
    Coalesced --> Canvas
    Predicted --> Canvas
    Canvas --> Active["activeLines touch map"]
    Canvas --> Pending["pendingLines update map"]
    Active --> Line["Line / LinePoint"]
    Pending --> Line
    Line --> Live["live line rendering"]
    Line --> Frozen["frozen CGContext image"]
    UIKit -->|estimated updates| Pending

Reference code

TouchCanvas/CanvasView.swift:125 — each event replaces stale predictions, then appends coalesced and new predicted samples to the line for that touch identity.

func drawTouches(_ touches: Set<UITouch>, withEvent event: UIEvent?) {
    var updateRect = CGRect.null

    for touch in touches {
        let line: Line = activeLines.object(forKey: touch) ?? addActiveLineForTouch(touch)

        updateRect = updateRect.union(line.removePointsWithType(.predicted))

        let coalescedTouches = event?.coalescedTouches(for: touch) ?? []
        let coalescedRect = addPointsOfType(.coalesced, for: coalescedTouches,
                                            to: line, in: updateRect)
        updateRect = updateRect.union(coalescedRect)

        let predictedTouches = event?.predictedTouches(for: touch) ?? []
        let predictedRect = addPointsOfType(.predicted, for: predictedTouches,
                                            to: line, in: updateRect)
        updateRect = updateRect.union(predictedRect)
    }

    setNeedsDisplay(updateRect)
}

Interpretation

Predictions are disposable latency hints, while coalesced/standard points become durable line data. Estimated properties create a third phase: an ended touch may remain in pendingLines until UIKit supplies final values.

Ownership and state

classDiagram
    ViewController o-- CanvasView : storyboard outlet
    ViewController *-- ReticleView : creates
    CanvasView *-- Line : active and finished arrays
    CanvasView *-- CGContext : frozen backing store
    CanvasView o-- UITouch : strong map keys
    Line *-- LinePoint : owns samples
    Line *-- NSNumber : estimation index map
    LinePoint *-- PointType : option flags
    ReticleView *-- CALayer : indicator layers
    CGVector ..|> DisplayFormat
    CGPoint ..|> DisplayFormat
    CGFloat ..|> DisplayFormat

Ownership evidence

TouchCanvas/CanvasView.swift:25 — the canvas privately owns the complete line lifecycle and its frozen rendering cache.

private var needsFullRedraw = true

/// Array containing all line objects that need to be drawn in `drawRect(_:)`.
private var lines = [Line]()

/// Array containing all line objects that have been completely drawn into the frozenContext.
private var finishedLines = [Line]()

private let activeLines: NSMapTable<UITouch, Line> = NSMapTable.strongToStrongObjects()
private let pendingLines: NSMapTable<UITouch, Line> = NSMapTable.strongToStrongObjects()

Class and protocol design

DisplayFormat is genuine protocol-oriented design: unrelated Foundation/Core Graphics scalar types gain the same read-only presentation capability through extensions, with no wrapper hierarchy.

Access control

Reference code

TouchCanvas/Formatters.swift:10 — the protocol is target-visible, but the formatter object supporting each conformance is file-private.

protocol DisplayFormat {
    var valueFormattedForDisplay: String? { get }
}

private let vectorFormatter: NumberFormatter = {
    let formatter = NumberFormatter()
    formatter.allowsFloats = true
    formatter.minimumFractionDigits = 3
    formatter.maximumFractionDigits = 3
    formatter.positivePrefix = "+"
    return formatter
}()

Logic ownership and placement

Design patterns

Naming conventions

• activeLines, pendingLines, and finishedLines name lifecycle phases directly.
• Line, LinePoint, and nested PointType express aggregate-to-value containment.
• Update methods say what changed: updateEstimatedPropertiesForTouches and updateWithTouch.
• The source uses gague... for gauge outlets/helpers; architecture notes retain the source spelling only when naming symbols.

Architecture takeaways

• Treat predicted input as replaceable state and final samples as durable model state.
• Keep an explicit pending phase when framework values may arrive after touch end.
• Correlate UIKit identity objects at the custom-view boundary, then pass stable model values deeper.
• Protect rendering caches and sample indexes with private ownership and semantic mutation methods.

Source map

• Official Apple documentation