hex/ios/HEXShared/KeyboardSurface.swift
Ryan Vogel a0d72ab4bc
iOS keyboard: the dictation bar's globe opens the keyboard list where Apple's keyboard is split, so the host doesn't crash (#2417)
On the iPhone Duo unfolded and upright, a tap on the dictation bar's globe still
ended the app being typed in (iOS 27.2: -[UIKeyboardLayoutStar
activationIndicatorView] index 43 beyond bounds [0 .. 42], the crash #2340 fixed
for the full keyboard). The bar's GlobeKeyRepresentable sent every touch straight
to handleInputModeList(from:with:), so a tap switched to the next keyboard blind.

The rule moves out of FullKeyboardView into ios/HEXShared/InputModeListTouch.swift
and both keyboards use it:
- InputModeListTouch.forward holds back the lift of a tap that stayed on the key
  where Apple's keyboard may be split, so UIKit's 0.2 s hold opens the list.
  Holds, slides and picks from the list pass through unchanged.
- "May be split" is KeyboardPosture.current(in: window): the Duo unfolded and
  upright, or a Duo posture not known yet (no window), as the strip already
  treated it. Every other iPhone and iPad is .phone and switches as before.
- The dictation bar's globe gets a coordinator that forwards through it.
- The full keyboard's globe reads the posture from its window at touch time
  instead of engine.posture (the same value once laid out); the Code from
  Messages chip keeps always holding back its tap (alwaysHoldsBackTap).
- Removed: FullKeyboardView.passesGlobeTouch and globeTouchLeftKey, replaced by
  InputModeListTouch.passes and its own state; the existing globe test now
  checks InputModeListTouch.passes.

Verified (Mac Studio, iPhone Duo simulator, iOS 27.2 runtime 24B91016s, real
touches injected through the inner screen's own digitizer, Apple's split
keyboard on):
- Before (origin/dev 63f05e3c), unfolded and upright, a fresh host that opened
  with the bar: one tap on the globe ended KBHost and Messages, each with a
  crash report in -[UIKeyboardLayoutStar activationIndicatorView].
- After: 20 fresh hosts (10 KBHost, 10 Messages), one tap each: the list
  opened 20/20, no host ended, no crash reports. Picking English (US) from the
  list switched to Apple's split keyboard, host alive.
- Folded and unfolded turned: a tap still switches straight to Apple's
  keyboard, host alive.
- xcodebuild test (iPhone 17 Pro, iOS 27.2): 740 tests, 0 failures, 3 skipped;
  the runner was killed once mid-run in DictationControllerTests (signal TERM,
  busy shared Studio) and that class passed 74/74 on a rerun.
- python3 scripts/code-shape.py --check passes; FullKeyboardView.swift is 1,436
  lines.
2026-11-22 14:13:11 -05:00

1383 lines
55 KiB
Swift
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import Combine
import SwiftUI
import UIKit
@MainActor
final class KeyboardClockModel: ObservableObject {
@Published private(set) var recordingText: String = "0:00"
@Published private(set) var warmRemainingText: String = "15m"
func update(recordingElapsed: TimeInterval?, warmRemaining: TimeInterval?) {
if let recordingElapsed {
let formatted = HexTheme.formatClock(recordingElapsed)
if formatted != recordingText {
recordingText = formatted
}
}
if let warmRemaining, warmRemaining > 0 {
let formatted = HexTheme.formatRemaining(warmRemaining)
if formatted != warmRemainingText {
warmRemainingText = formatted
}
}
}
}
private struct GlobeKeyRepresentable: UIViewRepresentable {
weak var controller: UIInputViewController?
let isDark: Bool
func makeUIView(context: Context) -> UIButton {
let button = UIButton(type: .system)
var config = UIButton.Configuration.plain()
config.image = UIImage(
systemName: "globe",
withConfiguration: UIImage.SymbolConfiguration(pointSize: 15, weight: .medium)
)
config.baseForegroundColor = isDark
? UIColor(white: 0.92, alpha: 1)
: UIColor(red: 0x14 / 255.0, green: 0x16 / 255.0, blue: 0x1B / 255.0, alpha: 1)
button.configuration = config
button.accessibilityLabel = "Next keyboard"
if controller != nil {
button.addTarget(context.coordinator, action: #selector(Coordinator.touch(_:with:)), for: .allTouchEvents)
}
return button
}
func makeCoordinator() -> Coordinator { Coordinator(controller: controller) }
/// Holds back a tap where Apple's keyboard splits, as the full keyboard's globe does.
@MainActor final class Coordinator: NSObject {
weak var controller: UIInputViewController?
private let inputModeListTouch = InputModeListTouch()
init(controller: UIInputViewController?) { self.controller = controller }
@objc func touch(_ sender: UIButton, with event: UIEvent) {
guard let controller else { return }
inputModeListTouch.forward(sender, with: event, to: controller)
}
}
func updateUIView(_ uiView: UIButton, context: Context) {
context.coordinator.controller = controller
uiView.configuration?.baseForegroundColor = isDark
? UIColor(white: 0.92, alpha: 1)
: UIColor(red: 0x14 / 255.0, green: 0x16 / 255.0, blue: 0x1B / 255.0, alpha: 1)
}
}
private struct KeyboardChromePalette {
let isDark: Bool
let isHosted: Bool
var textBase: Color {
isDark
? HexTheme.textBase
: Color(red: 0x14 / 255.0, green: 0x16 / 255.0, blue: 0x1B / 255.0)
}
var textMuted: Color {
isDark
? HexTheme.textMuted
: Color(red: 0x4E / 255.0, green: 0x54 / 255.0, blue: 0x61 / 255.0)
}
var chipIdleFill: Color {
isDark ? Color.white.opacity(0.07) : Color.black.opacity(0.055)
}
var chipActiveFill: Color {
isDark ? Color.white.opacity(0.16) : Color.black.opacity(0.12)
}
var topBarPressedFill: Color {
isDark ? Color.white.opacity(0.09) : Color.black.opacity(0.07)
}
var controlSubtleFill: Color {
isDark ? Color.white.opacity(0.085) : Color.black.opacity(0.065)
}
var controlProminentFill: Color {
isDark ? Color.white.opacity(0.15) : Color.black.opacity(0.11)
}
var idleTriggerFill: Color {
isDark ? Color.white.opacity(0.09) : Color.black.opacity(0.07)
}
var keyFill: Color {
if !isHosted { return Color.white.opacity(0.085) }
return isDark ? Color.white.opacity(0.105) : Color.white
}
var keyPressedFill: Color {
if !isHosted { return Color.white.opacity(0.16) }
return isDark ? Color.white.opacity(0.19) : Color(white: 0.88)
}
var keyShadow: Color {
Color.black.opacity(isDark ? 0.24 : 0.14)
}
/// The return key's colours, as the full keyboard's (`FullKeyboardPalette`).
var actionFill: Color { Color(red: 0, green: 0x7A / 255.0, blue: 1) }
var actionPressedFill: Color { Color(red: 0, green: 0x62 / 255.0, blue: 0xCC / 255.0) }
var actionDisabledFill: Color {
isDark ? Color.white.opacity(0.39) : Color(red: 0xBF / 255.0, green: 0xC0 / 255.0, blue: 0xC5 / 255.0)
}
var returnDisabledInk: Color { textBase.opacity(0.1) }
}
private struct KeyboardKeyButtonStyle: ButtonStyle {
let palette: KeyboardChromePalette
/// Another keycap colour, idle and pressed: the return key's blue.
var fill: (idle: Color, pressed: Color)?
func makeBody(configuration: Configuration) -> some View {
configuration.label
.background(
configuration.isPressed ? fill?.pressed ?? palette.keyPressedFill : fill?.idle ?? palette.keyFill,
in: RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous)
)
.shadow(color: palette.keyShadow, radius: 0.5, x: 0, y: 1)
}
}
/// The top row's tap band: the 26 pt pills keep their size and centre in it.
private enum TopBarMetrics {
static let height: CGFloat = 40
static let hitWidth: CGFloat = 44
/// The surface's side inset, owned by the end controls so taps reach the edges.
static let sideInset: CGFloat = 10
/// The Hex mark's label before its side inset.
static let hexMarkWidth: CGFloat = 22
/// How far the mark's tap area reaches into the status group's slot.
static let hexMarkOverlap = hitWidth - sideInset - hexMarkWidth
}
/// The row's full height and at least 44 pt of width, without drawing any of it:
/// apply after the control's 26 pt visual so the visual keeps its size.
private struct TopBarHitTarget: ViewModifier {
var alignment: Alignment = .center
func body(content: Content) -> some View {
content
.frame(
minWidth: TopBarMetrics.hitWidth,
minHeight: TopBarMetrics.height,
alignment: alignment
)
.contentShape(Rectangle())
}
}
private extension View {
func topBarHitTarget(alignment: Alignment = .center) -> some View {
modifier(TopBarHitTarget(alignment: alignment))
}
}
private struct TopBarTriggerButtonStyle: ButtonStyle {
let palette: KeyboardChromePalette
/// The side inset belongs to the tap area, drawn after the pressed capsule.
var leadingHitInset: CGFloat = 0
var trailingHitInset: CGFloat = 0
func makeBody(configuration: Configuration) -> some View {
configuration.label
.background(
configuration.isPressed ? palette.topBarPressedFill : Color.clear,
in: Capsule()
)
.padding(.leading, leadingHitInset)
.padding(.trailing, trailingHitInset)
.topBarHitTarget()
}
}
/// A tray chip: its capsule keeps its size and the row's tap area surrounds it.
private struct TopBarChipButtonStyle: ButtonStyle {
/// The row's side inset, owned by the first chip in a tray.
var leadingHitInset: CGFloat = 0
func makeBody(configuration: Configuration) -> some View {
configuration.label
.padding(.leading, leadingHitInset)
.topBarHitTarget(alignment: leadingHitInset == 0 ? .center : .leading)
}
}
private struct RepeatDeleteKey: View {
let palette: KeyboardChromePalette
var glyphOpacity: Double = 1
let onDelete: () -> Void
@State private var isPressing = false
@State private var repeatTask: Task<Void, Never>?
var body: some View {
Image(systemName: "delete.left")
.font(.system(size: 15, weight: .medium))
.foregroundStyle(palette.textBase)
.opacity(glyphOpacity)
.frame(width: 44, height: 42)
.background(
isPressing ? palette.keyPressedFill : palette.keyFill,
in: RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous)
)
.shadow(color: palette.keyShadow, radius: 0.5, x: 0, y: 1)
.contentShape(RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous))
.gesture(
DragGesture(minimumDistance: 0)
.onChanged { _ in
guard !isPressing else { return }
isPressing = true
onDelete()
repeatTask = Task { @MainActor in
try? await Task.sleep(for: .milliseconds(360))
while !Task.isCancelled {
onDelete()
try? await Task.sleep(for: .milliseconds(75))
}
}
}
.onEnded { _ in
isPressing = false
repeatTask?.cancel()
repeatTask = nil
}
)
.accessibilityLabel("Delete")
}
}
/// The dictation bar's space bar, a cursor trackpad like the full keyboard's
/// (`FullKeyboardEngine`): sliding `trackpadActivationDistance`, or holding still for
/// `trackpadHoldDelay`, starts it, and each `trackpadPointsPerCharacter` along moves the cursor
/// a character with a selection tick. Letting go of a trackpad types nothing; a tap types a space.
private struct TrackpadSpaceKey: View {
let palette: KeyboardChromePalette
let minWidth: CGFloat
@Binding var isTrackpad: Bool
let onPress: () -> Void
let onSpace: () -> Void
let onMove: (Int) -> Void
let onStep: () -> Void
@Environment(\.accessibilityReduceMotion) private var reduceMotion
@GestureState private var isTouching = false
@State private var isPressing = false
@State private var startX: CGFloat = 0
@State private var anchorX: CGFloat = 0
@State private var lastX: CGFloat = 0
@State private var holdTask: Task<Void, Never>?
var body: some View {
Text("space")
.font(.system(size: 15, weight: .regular))
.foregroundStyle(palette.textMuted)
.lineLimit(1)
.opacity(isTrackpad ? 0 : 1)
.frame(minWidth: minWidth, maxWidth: .infinity)
.frame(height: 42)
.background(
isPressing ? palette.keyPressedFill : palette.keyFill,
in: RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous)
)
.shadow(color: palette.keyShadow, radius: 0.5, x: 0, y: 1)
.contentShape(RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous))
.gesture(
DragGesture(minimumDistance: 0)
.updating($isTouching) { _, touching, _ in touching = true }
.onChanged { value in moved(to: value.location.x, from: value.startLocation.x) }
.onEnded { _ in finish(typesSpace: true) }
)
.onChange(of: isTouching) { _, touching in
guard !touching else { return }
// A cancelled touch never reaches onEnded, and types nothing; an ended one already finished.
DispatchQueue.main.async { finish(typesSpace: false) }
}
.accessibilityElement(children: .combine)
.accessibilityAddTraits(.isButton)
.accessibilityAction { onSpace() }
}
private func moved(to x: CGFloat, from start: CGFloat) {
lastX = x
if !isPressing {
isPressing = true
startX = start
onPress()
holdTask?.cancel()
holdTask = Task { @MainActor in
try? await Task.sleep(for: .seconds(FullKeyboardEngine.trackpadHoldDelay))
guard !Task.isCancelled, isPressing, !isTrackpad else { return }
begin(at: lastX)
}
}
guard isTrackpad else {
if abs(x - startX) >= FullKeyboardEngine.trackpadActivationDistance {
begin(at: x)
}
return
}
let step = FullKeyboardEngine.trackpadPointsPerCharacter
let steps = Int(((x - anchorX) / step).rounded(.towardZero))
guard steps != 0 else { return }
anchorX += CGFloat(steps) * step
onMove(steps)
onStep()
}
private func begin(at x: CGFloat) {
holdTask?.cancel()
holdTask = nil
anchorX = x
setTrackpad(true)
onStep()
}
private func finish(typesSpace: Bool) {
holdTask?.cancel()
holdTask = nil
guard isPressing else { return }
isPressing = false
if isTrackpad {
setTrackpad(false)
} else if typesSpace {
onSpace()
}
}
/// The glyphs blank at once under Reduce Motion, as the full keyboard's do, else fade quickly.
private func setTrackpad(_ on: Bool) {
withAnimation(reduceMotion ? nil : .easeOut(duration: 0.12)) {
isTrackpad = on
}
}
}
private struct KeyboardRecordingClockText: View {
@ObservedObject var clock: KeyboardClockModel
let color: Color
var body: some View {
Text(clock.recordingText)
.font(.system(size: 13, weight: .medium))
.monospacedDigit()
.contentTransition(.numericText())
.foregroundStyle(color)
.animation(.easeOut(duration: 0.16), value: clock.recordingText)
}
}
private struct KeyboardWarmRemainingText: View {
@ObservedObject var clock: KeyboardClockModel
let color: Color
var body: some View {
Text(clock.warmRemainingText)
.font(.system(size: 13, weight: .medium))
.monospacedDigit()
.contentTransition(.numericText())
.foregroundStyle(color)
}
}
extension View {
/// iOS 26's soft scroll-edge effect blurs the whole content of a short
/// scroll view (the 26 pt return-app tray), so turn it off there.
/// Earlier versions have no edge effect and are left unchanged.
@ViewBuilder
func hexScrollEdgeEffectHidden() -> some View {
if #available(iOS 26.0, *) {
scrollEdgeEffectHidden(true, for: .all)
} else {
self
}
}
}
/// Beside the dictation bar's Hex mark while dictations paste translated: the target's code
/// ("EN"), so a dictation never comes out in another language by surprise.
private struct TranslationBadge: View {
let target: String
let palette: KeyboardChromePalette
var body: some View {
HStack(spacing: 2) {
Image(systemName: "arrow.right")
.font(.system(size: 8, weight: .bold))
Text(TranslationPasteChoice.badge(target: target))
.font(.system(size: 10, weight: .semibold))
}
.foregroundStyle(palette.textBase)
.padding(.horizontal, 5)
.frame(height: 16)
.background(palette.chipActiveFill, in: Capsule())
.accessibilityElement(children: .ignore)
.accessibilityLabel(TranslationPasteChoice.translatingLabel(target: target))
}
}
enum KeyboardSetupCopy {
static let fullAccessPath = String(localized: "Allow Full Access: Settings › Apps › Hex › Keyboards")
}
/// Metal-free stand-in for the resting Dot Scope bar. Mounting it instead of
/// `DotScopeView` keeps the keyboard extension's launch path off the GPU: no
/// device, command queue, render pipelines, `CAMetalLayer`, display link, or
/// idle simulation steps before the first frame.
private struct KeyboardRestingDotBar: View {
let isDark: Bool
let leadingInset: CGFloat
let trailingInset: CGFloat
private static let pitch: CGFloat = 3.5
private static let rows = 11
private static let fade: CGFloat = 26
private static let braidCycles: Double = 2.1
private static let restingAmplitude: Double = 0.9
var body: some View {
let lead = Double(max(0, leadingInset))
let trail = Double(max(0, trailingInset))
let tint: (red: Double, green: Double, blue: Double) = isDark
? (red: 0.93, green: 0.91, blue: 0.86)
: (red: 0.55, green: 0.46, blue: 0.33)
return Canvas { context, size in
let pitch = Double(Self.pitch)
let firstX = lead + 3
let lastX = Double(size.width) - trail - 3
guard lastX - firstX > pitch * 2, size.height > 8 else { return }
let columns = max(3, Int(((lastX - firstX) / pitch).rounded(.down)) + 1)
let midY = Double(size.height) * 0.5
let halfRows = Double(Self.rows - 1) * 0.5
for column in 0..<columns {
let x = firstX + Double(column) * pitch
let xn = Double(column) / Double(max(1, columns - 1))
let fadeIn = min(1.0, max(0.0, (x - lead) / Double(Self.fade)))
let fadeOut = min(1.0, max(0.0, (Double(size.width) - trail - x) / Double(Self.fade)))
let edge = min(fadeIn, fadeOut)
guard edge > 0.004 else { continue }
// The live scope flattens to a faint mirrored braid at rest.
let wobble = sin(2.0 * .pi * Self.braidCycles * xn - 0.6) * Self.restingAmplitude
let upper = midY - wobble
let lower = midY + wobble
for row in 0..<Self.rows {
let y = midY + (Double(row) - halfRows) * pitch
let litUpper = exp(-pow(y - upper, 2) / 2.2)
let litLower = exp(-pow(y - lower, 2) / 2.2)
let power = min(1.0, 1.0 - (1.0 - litUpper) * (1.0 - litLower))
let alpha = (0.05 + 0.40 * power) * edge
guard alpha > 0.01 else { continue }
let radius = (0.16 + 0.21 * power) * pitch
context.fill(
Path(
ellipseIn: CGRect(
x: x - radius,
y: y - radius,
width: radius * 2,
height: radius * 2
)
),
with: .color(Color(red: tint.red, green: tint.green, blue: tint.blue, opacity: alpha))
)
}
}
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
.accessibilityHidden(true)
}
}
struct KeyboardSurfaceView: View {
@Environment(\.colorScheme) private var colorScheme
@Environment(\.accessibilityReduceMotion) private var reduceMotion
@ObservedObject var model: KeyboardViewModel
/// The keyboard extension sets this so its process never builds the Metal
/// scope before a stage needs it. The app's docked keyboard preview keeps
/// the live scope mounted at rest.
var defersDotScopeUntilActive = false
/// Push to talk on the well: the press, on the Hex key's state machine.
@State private var hold = HexKeyGesture()
@State private var holdTimer: Task<Void, Never>?
@State private var pressBegan = false
/// This press's hold started the dictation, so the Dictate button's tap action skips it.
@State private var holdTookPress = false
@GestureState private var isPressingWell = false
/// That long press's own touch-up, so it doesn't also pick the language.
@State private var removeTookPress = false
/// The space bar slides the cursor: the keys' glyphs blank out, as on the full keyboard.
@State private var isTrackpadActive = false
private static let wellHeight: CGFloat = 44
private static let controlHeight: CGFloat = 34
private static let wellInset: CGFloat = 5
private static let cancelWidth: CGFloat = 34
private static let doneWidth: CGFloat = 66
private var isHostedExtension: Bool {
model.inputViewController != nil
}
private var palette: KeyboardChromePalette {
KeyboardChromePalette(
isDark: !isHostedExtension || colorScheme == .dark,
isHosted: isHostedExtension
)
}
private var isStageActive: Bool {
model.stagePhase == .recording || model.stagePhase == .transcribing
}
var body: some View {
let showsMore = model.activeTray == .moreLanguages
// The top row spans the bar, its controls reaching the screen's edges;
// everything under it keeps the surface's side inset.
VStack(spacing: 2) {
topBar
ZStack {
VStack(spacing: 8) {
primaryStage
utilityRow
}
.opacity(showsMore ? 0 : 1)
.allowsHitTesting(!showsMore)
.accessibilityHidden(showsMore)
if showsMore {
moreLanguagesGrid(palette: palette)
.transition(.opacity)
}
}
.padding(.horizontal, TopBarMetrics.sideInset)
}
.onChange(of: model.activeTray) { _, _ in
removeTookPress = false
}
.padding(.top, 4)
.padding(.bottom, 6)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(isHostedExtension ? Color.clear : HexTheme.bgDeep)
.preferredColorScheme(isHostedExtension ? nil : .dark)
}
// MARK: - Top Bar (40 pt around 26 pt visuals, permanently mounted ZStack)
private var topBar: some View {
let p = palette
return ZStack {
defaultTopBar(palette: p)
.hexTrayReveal(model.activeTray == .none, reduceMotion: reduceMotion, offsetY: -3)
styleTrayBar(palette: p)
.hexTrayReveal(model.activeTray == .style, reduceMotion: reduceMotion, offsetY: 3.5)
languageTrayBar(palette: p)
.hexTrayReveal(model.activeTray == .language, reduceMotion: reduceMotion, offsetY: 3.5)
moreLanguagesBar(palette: p)
.hexTrayReveal(model.activeTray == .moreLanguages, reduceMotion: reduceMotion, offsetY: 3.5)
}
.frame(height: TopBarMetrics.height)
}
private func defaultTopBar(palette p: KeyboardChromePalette) -> some View {
HStack(spacing: 8) {
Button {
model.onKeyFeedback?()
if model.hasFullAccess, !model.isWarmAvailable, let local = model.onLocalDictateTap {
local()
} else {
let target = model.hasFullAccess ? model.coldStartURL : KeyboardLaunchRequest.setup.url
model.onOpenURL?(target)
}
} label: {
HexMarkView(
size: 16,
color: isStageActive && p.isDark ? HexTheme.warmPearl : p.textBase
)
.frame(width: TopBarMetrics.hexMarkWidth, height: 26, alignment: .leading)
.padding(.leading, TopBarMetrics.sideInset)
.topBarHitTarget(alignment: .leading)
}
.buttonStyle(.plain)
.accessibilityLabel("Open Hex")
// The mark's tap area reaches past its pill into this group's slot: the
// outdent keeps the badge and the status where they were.
HStack(spacing: 8) {
if let target = model.translatingTo {
TranslationBadge(target: target, palette: p)
}
leadingAccessory(palette: p)
}
.padding(.leading, -TopBarMetrics.hexMarkOverlap)
Spacer(minLength: 4)
if showsPasteDictation {
pasteDictationChip(palette: p)
Spacer(minLength: 4)
}
// The translation note takes the bar's width for its few seconds.
if model.showsLanguageSwitch || model.showsTranslationSwitch, model.translationNote == nil {
languageTrigger(palette: p)
}
styleTrigger(palette: p)
.hexTrayReveal(model.hasFullAccess && model.translationNote == nil, reduceMotion: reduceMotion, offsetY: 0)
}
.frame(height: TopBarMetrics.height)
}
/// A dictation that didn't go in by itself, as the full keyboard's strip offers it: the
/// bar is the only keyboard on an iPad, and without this a late one was out of reach.
private var showsPasteDictation: Bool {
model.hasFullAccess && model.offeredDictation != nil && !isStageActive && model.translationNote == nil
}
private func pasteDictationChip(palette p: KeyboardChromePalette) -> some View {
Button {
model.onKeyFeedback?()
model.onPasteDictation?()
} label: {
Text("Paste dictation")
.font(.system(size: 13, weight: .medium))
.foregroundStyle(p.textBase)
.lineLimit(1)
.fixedSize()
.padding(.horizontal, 11)
.frame(height: 26)
.background(p.chipActiveFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle())
.layoutPriority(1)
}
private func styleTrayBar(palette p: KeyboardChromePalette) -> some View {
let firstStyle = DictationStyle.allCases.first
return HStack(spacing: 4) {
ForEach(DictationStyle.allCases, id: \.self) { candidate in
let active = candidate == model.style
Button {
model.onKeyFeedback?()
model.onStyleSelected?(candidate)
model.setActiveTray(.none, reduceMotion: reduceMotion)
} label: {
Text(candidate.label)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(active ? p.textBase : p.textMuted)
.padding(.horizontal, 11)
.frame(height: 26)
.background(active ? p.chipActiveFill : p.chipIdleFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle(
leadingHitInset: candidate == firstStyle ? TopBarMetrics.sideInset : 0
))
}
Spacer(minLength: 4)
closeTrayButton(palette: p)
}
.frame(height: TopBarMetrics.height)
}
private func leadingAccessory(palette p: KeyboardChromePalette) -> some View {
let showNoAccess = !model.hasFullAccess
let showRecordingClock = model.hasFullAccess && model.stagePhase == .recording
let showTranslationNote = model.hasFullAccess
&& model.translationNote != nil
&& model.stagePhase != .recording
&& model.stagePhase != .transcribing
let showWarmStatus = model.hasFullAccess
&& model.isWarmAvailable
&& model.stagePhase != .recording
&& model.stagePhase != .transcribing
&& !showTranslationNote
return ZStack(alignment: .leading) {
HStack(spacing: 6) {
HexStatusDot(color: HexTheme.warmMic, size: 6)
Text(KeyboardSetupCopy.fullAccessPath)
.font(.system(size: 13, weight: .regular))
.foregroundStyle(p.textMuted)
.lineLimit(1)
.minimumScaleFactor(0.78)
}
.accessibilityElement(children: .combine)
.accessibilityLabel("Full Access is off. \(KeyboardSetupCopy.fullAccessPath)")
.hexTrayReveal(showNoAccess, reduceMotion: reduceMotion, offsetY: 2)
HStack(spacing: 6) {
HexStatusDot(color: HexTheme.danger, size: 6.5)
KeyboardRecordingClockText(clock: model.clock, color: p.textBase)
}
.hexTrayReveal(showRecordingClock, reduceMotion: reduceMotion, offsetY: 2)
Group {
if let message = model.statusMessage {
HStack(spacing: 6) {
if model.stagePhase == .failed {
HexStatusDot(color: HexTheme.danger, size: 6)
}
// A failure gets two smaller lines: it has to be read in full.
let failed = model.stagePhase == .failed
Text(message)
.font(.system(size: failed ? 11 : 13, weight: .regular))
.foregroundStyle(p.textMuted)
.lineLimit(failed ? 2 : 1)
.minimumScaleFactor(0.85)
}
} else {
HStack(spacing: 5) {
HexStatusDot(color: HexTheme.warmMic, size: 6)
KeyboardWarmRemainingText(clock: model.clock, color: p.textMuted)
}
}
}
.hexTrayReveal(showWarmStatus, reduceMotion: reduceMotion, offsetY: 2)
Group {
if let note = model.translationNote {
translationNote(note, palette: p)
}
}
.hexTrayReveal(showTranslationNote, reduceMotion: reduceMotion, offsetY: 2)
}
}
/// "Couldn't translate, pasted as spoken" over its fix; a tap opens Hex's Settings › Dictation.
private func translationNote(_ note: TranslationFailure, palette p: KeyboardChromePalette) -> some View {
Button {
model.onOpenURL?(KeyboardLaunchRequest.translationSettings.url)
} label: {
VStack(alignment: .leading, spacing: 0) {
Text(TranslationFailure.note)
.font(.system(size: 11, weight: .medium))
.foregroundStyle(p.textBase)
Text(note.fix)
.font(.system(size: 11))
.foregroundStyle(p.textMuted)
}
.lineLimit(1)
.minimumScaleFactor(0.8)
.contentShape(Rectangle())
}
.buttonStyle(.plain)
.accessibilityElement(children: .combine)
.accessibilityHint("Opens Hex's Settings")
}
private func styleTrigger(palette p: KeyboardChromePalette) -> some View {
Button {
model.onKeyFeedback?()
model.setActiveTray(.style, reduceMotion: reduceMotion)
} label: {
HStack(spacing: 4) {
Text(model.style.label)
.font(.system(size: 13, weight: .medium))
Image(systemName: "chevron.down")
.font(.system(size: 10, weight: .medium))
.foregroundStyle(p.textMuted)
}
.foregroundStyle(p.textMuted)
.padding(.horizontal, 8)
.frame(height: 26)
}
.buttonStyle(TopBarTriggerButtonStyle(palette: p, trailingHitInset: TopBarMetrics.sideInset))
.accessibilityLabel("Style: \(model.style.label)")
}
private func languageTrigger(palette p: KeyboardChromePalette) -> some View {
// While translating, the badge beside the Hex mark says where dictations go ("→ EN").
let summary = model.translatingTo == nil ? model.languageSummary : model.languageLabel
let label = summary ?? "Automatic"
return Button {
model.onKeyFeedback?()
model.setActiveTray(.language, reduceMotion: reduceMotion)
} label: {
HStack(spacing: 4) {
Text(label)
.font(.system(size: 13, weight: .medium))
.lineLimit(1)
Image(systemName: "chevron.down")
.font(.system(size: 10, weight: .medium))
.foregroundStyle(p.textMuted)
}
.foregroundStyle(p.textMuted)
.padding(.horizontal, 8)
.frame(height: 26)
}
.buttonStyle(TopBarTriggerButtonStyle(palette: p))
// "Español → English" before the status beside the Hex mark, which is short whenever
// the switch shows (it needs Full Access).
.layoutPriority(1)
.accessibilityLabel("Dictation language: \(label)")
}
private func languageTrayBar(palette p: KeyboardChromePalette) -> some View {
// Apple Speech's languages here, as the Hex key menu names them: the chips and More
// languages together name a language's region where it has several ("Español (US)").
let names = DictationLanguageSwitch.nativeNames(
for: model.languageChoices,
supported: model.languageChoices + model.moreLanguages
)
// The close's 44 pt tap area ends on the screen's edge, so the spacing before
// its pair keeps the scroll view's end at the same place either way.
let hasTranslationChip = model.showsTranslationSwitch && model.translationLanguage != nil
return HStack(spacing: hasTranslationChip ? 4 : -4) {
ScrollView(.horizontal, showsIndicators: false) {
HStack(spacing: 4) {
if model.showsLanguageSwitch {
languageChip(id: nil, label: String(localized: "Auto"), palette: p)
ForEach(model.languageChoices, id: \.self) { id in
languageChip(id: id, label: names[id] ?? id, palette: p)
if model.removingLanguage == id {
removeChip(id: id, label: names[id] ?? id, palette: p)
}
}
if !model.moreLanguages.isEmpty {
moreChip(palette: p)
}
}
}
.padding(.leading, 2)
.padding(.trailing, 10)
}
.hexScrollEdgeEffectHidden()
.hexHorizontalEdgeFade(leading: 4, trailing: 14)
// The close overlaps 4 pt of what is beside it: with the chip, the pair
// keeps the chip where it was and the chip wins its own pixels; without
// it, the overlap is the scroll view's trailing fade.
HStack(spacing: -4) {
if hasTranslationChip, let target = model.translationLanguage {
translationChip(target: target, palette: p)
.zIndex(1)
}
closeTrayButton(palette: p)
}
}
.padding(.leading, TopBarMetrics.sideInset)
.frame(height: TopBarMetrics.height)
}
/// Translate to <language>: lit while dictations paste translated; a tap turns
/// Translate what I say on or off, the same App Group setting as Settings' switch.
private func translationChip(target: String, palette p: KeyboardChromePalette) -> some View {
let active = model.isTranslating
let title = TranslationPasteChoice.toggleTitle(target: target)
return Button {
model.onKeyFeedback?()
model.onTranslationToggled?(!active)
model.setActiveTray(.none, reduceMotion: reduceMotion)
} label: {
Text(title)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(active ? p.textBase : p.textMuted)
.lineLimit(1)
.padding(.horizontal, 10)
.frame(height: 26)
.background(active ? p.chipActiveFill : p.chipIdleFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle())
.accessibilityLabel(title)
.accessibilityValue(active ? "On" : "Off")
.accessibilityAddTraits(active ? .isSelected : [])
}
/// A language: a tap picks it; a long press offers Remove beside it (not Automatic).
private func languageChip(id: String?, label: String, palette p: KeyboardChromePalette) -> some View {
let active = model.dictationLanguage == id
return Button {
if let id, model.removingLanguage == id {
// The long press's own release keeps Remove up; a later tap puts it away.
if removeTookPress {
removeTookPress = false
} else {
setRemovingLanguage(nil)
}
return
}
model.removingLanguage = nil
removeTookPress = false
model.onKeyFeedback?()
model.onLanguageSelected?(id)
model.setActiveTray(.none, reduceMotion: reduceMotion)
} label: {
Text(label)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(active ? p.textBase : p.textMuted)
.padding(.horizontal, 10)
.frame(height: 26)
.background(active ? p.chipActiveFill : p.chipIdleFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle())
.simultaneousGesture(
LongPressGesture(minimumDuration: Self.removeHoldDuration).onEnded { _ in
guard let id, model.removingLanguage != id else { return }
model.onSelectionStep?()
removeTookPress = true
setRemovingLanguage(id)
},
including: id == nil ? .subviews : .all
)
.accessibilityLabel(id == nil ? "Automatic language" : label)
.accessibilityActions {
if let id {
Button("Remove") { model.onLanguageRemoved?(id) }
}
}
}
/// How long a language chip is held before Remove shows beside it.
private static let removeHoldDuration: Double = 0.45
private func setRemovingLanguage(_ id: String?) {
withAnimation(HexMotion.trayAnimation(reduceMotion: reduceMotion)) {
model.removingLanguage = id
}
}
private func removeChip(id: String, label: String, palette p: KeyboardChromePalette) -> some View {
Button {
model.onKeyFeedback?()
model.onLanguageRemoved?(id)
removeTookPress = false
setRemovingLanguage(nil)
} label: {
Text("Remove")
.font(.system(size: 13, weight: .medium))
.foregroundStyle(HexTheme.danger)
.padding(.horizontal, 10)
.frame(height: 26)
.background(p.chipIdleFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle())
.transition(.opacity)
.accessibilityLabel(Text("Remove \(label)"))
}
private func moreChip(palette p: KeyboardChromePalette) -> some View {
Button {
model.onKeyFeedback?()
model.setActiveTray(.moreLanguages, reduceMotion: reduceMotion)
} label: {
Text("More languages…")
.font(.system(size: 13, weight: .medium))
.foregroundStyle(p.textMuted)
.lineLimit(1)
.padding(.horizontal, 10)
.frame(height: 26)
.background(p.chipIdleFill, in: Capsule())
}
.buttonStyle(TopBarChipButtonStyle())
}
/// More languages…'s bar: back to the language chips, and close.
private func moreLanguagesBar(palette p: KeyboardChromePalette) -> some View {
HStack(spacing: 8) {
Button {
model.onKeyFeedback?()
model.setActiveTray(.language, reduceMotion: reduceMotion)
} label: {
HStack(spacing: 4) {
Image(systemName: "chevron.left")
.font(.system(size: 11, weight: .semibold))
Text("More languages")
.font(.system(size: 13, weight: .medium))
.lineLimit(1)
}
.foregroundStyle(p.textMuted)
.padding(.horizontal, 8)
.frame(height: 26)
}
.buttonStyle(TopBarTriggerButtonStyle(palette: p, leadingHitInset: TopBarMetrics.sideInset))
.accessibilityLabel("Back")
Spacer(minLength: 4)
closeTrayButton(palette: p)
}
.frame(height: TopBarMetrics.height)
}
/// Every other language Apple Speech has, in place of the keys; a tap picks it, which puts
/// it on the switch.
private func moreLanguagesGrid(palette p: KeyboardChromePalette) -> some View {
let names = DictationLanguageSwitch.nativeNames(for: model.languageChoices + model.moreLanguages)
return ScrollView(.vertical, showsIndicators: false) {
LazyVGrid(columns: [GridItem(.adaptive(minimum: 96), spacing: 6)], spacing: 6) {
ForEach(model.moreLanguages, id: \.self) { id in
Button {
model.onKeyFeedback?()
model.onLanguageSelected?(id)
model.setActiveTray(.none, reduceMotion: reduceMotion)
} label: {
Text(names[id] ?? id)
.font(.system(size: 14, weight: .regular))
.foregroundStyle(p.textBase)
.lineLimit(1)
.minimumScaleFactor(0.75)
.padding(.horizontal, 8)
.frame(maxWidth: .infinity)
.frame(height: 34)
.background(p.chipIdleFill, in: Capsule())
.contentShape(Capsule())
}
.buttonStyle(.plain)
}
}
}
.hexScrollEdgeEffectHidden()
.frame(height: Self.wellHeight + 8 + Self.keyHeight)
}
private func closeTrayButton(palette p: KeyboardChromePalette) -> some View {
Button {
model.onKeyFeedback?()
model.setActiveTray(.none, reduceMotion: reduceMotion)
} label: {
Image(systemName: "xmark")
.font(.system(size: 11, weight: .medium))
.foregroundStyle(p.textMuted)
.frame(width: 26, height: 26)
.background(p.chipIdleFill, in: Circle())
.padding(.trailing, TopBarMetrics.sideInset)
.topBarHitTarget(alignment: .trailing)
}
.buttonStyle(.plain)
.accessibilityLabel("Close")
}
// MARK: - Unified 44 pt Recessed Stage Well (all controls permanently mounted)
private var idleTriggerSpec: (icon: String, title: String, width: CGFloat) {
if !model.hasFullAccess {
return ("arrow.up.forward.app.fill", "Set up Hex", 112)
}
if !model.isModelInstalled {
return ("mic.fill", "Set up", 88)
}
return ("mic.fill", "Dictate", 94)
}
private var primaryStage: some View {
let p = palette
let showRecordingControls = model.stagePhase == .recording
let showIdleTrigger = model.stagePhase == .idle || model.stagePhase == .failed
let spec = idleTriggerSpec
let leadInset: Float = showRecordingControls
? Float(Self.wellInset + Self.cancelWidth + 6)
: 0.0
let trailInset: Float = if showRecordingControls {
Float(Self.wellInset + Self.doneWidth + 6)
} else if showIdleTrigger {
Float(Self.wellInset + spec.width + 6)
} else {
0.0
}
return ZStack {
HexRecessedWell(isDark: p.isDark)
if defersDotScopeUntilActive && !isStageActive {
KeyboardRestingDotBar(
isDark: p.isDark,
leadingInset: CGFloat(leadInset),
trailingInset: CGFloat(trailInset)
)
.clipShape(Capsule())
.allowsHitTesting(false)
} else {
DotScopeView(
phase: model.dotScopePhase,
tuning: .bar(leadingInset: leadInset, trailingInset: trailInset, fade: 28.0, spacing: 3.5),
drawPlate: false,
loudnessProvider: { [weak model] in model?.liveLoudnessDB ?? -62.0 }
)
.clipShape(Capsule())
.allowsHitTesting(false)
}
// Recording peer controls (`✕` and `Done`), always mounted so enter/exit springs stay continuous.
HStack(spacing: 8) {
Button {
model.onKeyFeedback?()
model.onCancelTap?()
} label: {
Image(systemName: "xmark")
.font(.system(size: 13, weight: .semibold))
.foregroundStyle(p.textMuted)
.frame(width: Self.cancelWidth, height: Self.controlHeight)
.background(p.controlSubtleFill, in: Circle())
.frame(minWidth: 44, minHeight: Self.wellHeight, alignment: .leading)
.contentShape(Rectangle())
}
.buttonStyle(.plain)
.accessibilityLabel("Cancel dictation")
.hexControlReveal(
showRecordingControls,
reduceMotion: reduceMotion,
scale: 0.90,
blur: 2.5,
anchor: .leading
)
Spacer(minLength: 0)
Button {
model.onKeyFeedback?()
model.onStopTap?()
} label: {
Text("Done")
.font(.system(size: 15, weight: .semibold))
.foregroundStyle(p.textBase)
.frame(width: Self.doneWidth, height: Self.controlHeight)
.background(p.controlProminentFill, in: Capsule())
.frame(minHeight: Self.wellHeight, alignment: .trailing)
.contentShape(Rectangle())
}
.buttonStyle(.plain)
.hexControlReveal(
showRecordingControls,
reduceMotion: reduceMotion,
scale: 0.90,
blur: 2.5,
anchor: .trailing
)
}
.padding(.horizontal, Self.wellInset)
// Single permanently mounted idle trigger (never swapped across 3 Button branches).
Button {
guard !holdTookPress else { return }
model.onKeyFeedback?()
handleIdleStageTap()
} label: {
HStack(spacing: 0) {
Spacer(minLength: 0)
HStack(spacing: 6) {
Image(systemName: spec.icon)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(p.textMuted)
Text(spec.title)
.font(.system(size: 15, weight: .medium))
.foregroundStyle(p.textBase)
}
.frame(width: spec.width, height: Self.controlHeight)
.background(p.idleTriggerFill, in: Capsule())
}
.padding(.horizontal, Self.wellInset)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.contentShape(Capsule())
}
.buttonStyle(.plain)
.accessibilityLabel(spec.title)
.accessibilityHint(canHoldToTalk ? "Hold to talk, release to finish" : "")
.hexControlReveal(
showIdleTrigger,
reduceMotion: reduceMotion,
scale: 0.92,
blur: 2.5,
anchor: .trailing
)
}
.frame(height: Self.wellHeight)
.clipShape(Capsule())
// On the well, not the Dictate button: the button stops taking touches once recording shows.
.simultaneousGesture(pushToTalk)
.onChange(of: isPressingWell) { _, pressing in
guard !pressing else { return }
// A cancelled press never reaches onEnded; an ended one already reset.
DispatchQueue.main.async {
guard pressBegan else { return }
holdTimer?.cancel()
hold.cancel()
pressBegan = false
}
}
}
/// The well dictates in the keyboard (a warm session or in-keyboard dictation), so a
/// hold there can be push to talk; opening Hex or setup stays a tap.
private var canHoldToTalk: Bool {
guard model.hasFullAccess, model.stagePhase == .idle || model.stagePhase == .failed else { return false }
return (model.isWarmAvailable && model.stagePhase != .failed) || model.onLocalDictateTap != nil
}
/// Hold still on Dictate for `HexKeyGesture.holdDuration`: dictation starts with a light
/// tap, and lifting the finger finishes it as Done does. A quick tap keeps tap to start.
private var pushToTalk: some Gesture {
DragGesture(minimumDistance: 0)
.updating($isPressingWell) { _, pressing, _ in pressing = true }
.onChanged { value in
guard pressBegan else {
pressBegan = true
holdTookPress = false
guard canHoldToTalk else { return }
hold.touchDown(at: value.startLocation)
holdTimer?.cancel()
holdTimer = Task { @MainActor in
try? await Task.sleep(for: .seconds(HexKeyGesture.holdDuration))
guard !Task.isCancelled, hold.holdElapsed() == .hold else { return }
holdTookPress = true
model.onKeyFeedback?()
handleIdleStageTap()
}
return
}
if hold.touchMoved(to: value.location) == .openMenu {
// Moved away: not a hold.
holdTimer?.cancel()
}
}
.onEnded { _ in
holdTimer?.cancel()
holdTimer = nil
pressBegan = false
if hold.touchUp() == .release {
model.onStopTap?()
// After the button's own touch-up action, which this press must not repeat.
DispatchQueue.main.async { holdTookPress = false }
}
}
}
private func handleIdleStageTap() {
if !model.hasFullAccess {
model.onOpenURL?(KeyboardLaunchRequest.setup.url)
} else if !model.isWarmAvailable || model.stagePhase == .failed {
if let local = model.onLocalDictateTap {
local()
} else {
model.onOpenURL?(model.coldStartURL)
}
} else {
model.onDictateTap?()
}
}
// MARK: - Bottom Utility Key Row (42 pt, shadow-grounded keycaps with zero strokes)
/// The bar's punctuation keys, the commonest first: as many as leave the space bar
/// `minSpaceWidth` (five on a 402 pt iPhone, three on the SE beside its globe).
private static let punctuation = [",", ".", "?", "!", "'", "\"", "@", "#"]
private static let punctuationKeyWidth: CGFloat = 30
private static let minSpaceWidth: CGFloat = 60
private static let keyHeight: CGFloat = 42
/// The keys' glyphs while the space bar slides the cursor: blank, as on the full keyboard.
private var glyphOpacity: Double { isTrackpadActive ? 0 : 1 }
private var utilityRow: some View {
ViewThatFits(in: .horizontal) {
utilityKeys(punctuation: 8)
utilityKeys(punctuation: 6)
utilityKeys(punctuation: 5)
utilityKeys(punctuation: 4)
utilityKeys(punctuation: 3)
utilityKeys(punctuation: 2)
}
}
private func utilityKeys(punctuation count: Int) -> some View {
let p = palette
return HStack(spacing: 5) {
if model.needsGlobeKey {
GlobeKeyRepresentable(controller: model.inputViewController, isDark: p.isDark)
.opacity(glyphOpacity)
.frame(width: 38, height: 42)
.background(
p.keyFill,
in: RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous)
)
.shadow(color: p.keyShadow, radius: 0.5, x: 0, y: 1)
}
if model.showsEmojiKey {
Button {
model.onKeyFeedback?()
model.onEmojiTap?()
} label: {
Image(systemName: "face.smiling")
.font(.system(size: 17, weight: .regular))
.foregroundStyle(p.textBase)
.opacity(glyphOpacity)
.frame(width: 38, height: 42)
.contentShape(RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous))
}
.buttonStyle(KeyboardKeyButtonStyle(palette: p))
.accessibilityLabel("Emoji")
}
ForEach(Self.punctuation.prefix(count), id: \.self) { mark in
Button {
model.onKeyFeedback?()
model.onInsertText?(mark)
} label: {
Text(mark)
.font(.system(size: 19, weight: .regular))
.foregroundStyle(p.textBase)
.opacity(glyphOpacity)
.frame(width: Self.punctuationKeyWidth, height: 42)
.contentShape(RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous))
}
.buttonStyle(KeyboardKeyButtonStyle(palette: p))
}
TrackpadSpaceKey(
palette: p,
minWidth: Self.minSpaceWidth,
isTrackpad: $isTrackpadActive,
onPress: { model.onKeyFeedback?() },
onSpace: { model.onSpace?() },
onMove: { model.onMoveCursor?($0) },
onStep: { model.onSelectionStep?() }
)
RepeatDeleteKey(palette: p, glyphOpacity: glyphOpacity) {
model.onKeyFeedback?()
model.onDelete?()
}
Button {
model.onKeyFeedback?()
model.onReturn?()
} label: {
Image(systemName: model.returnKey.symbol)
.font(.system(size: 15, weight: .medium))
.foregroundStyle(returnInk(p))
.opacity(glyphOpacity)
.frame(width: 48, height: 42)
.contentShape(RoundedRectangle(cornerRadius: HexTheme.controlRadius, style: .continuous))
}
.buttonStyle(KeyboardKeyButtonStyle(palette: p, fill: returnFill(p)))
.disabled(!model.returnKeyEnabled)
.accessibilityLabel(model.returnKey.accessibilityLabel)
}
}
/// Send, go, search and the other acting types are blue, grey while the field is empty and
/// the host turns them off; plain while the space bar is a trackpad, as on the full keyboard.
private func returnFill(_ p: KeyboardChromePalette) -> (idle: Color, pressed: Color)? {
guard model.returnKey.isAction, !isTrackpadActive else { return nil }
return model.returnKeyEnabled
? (p.actionFill, p.actionPressedFill)
: (p.actionDisabledFill, p.actionDisabledFill)
}
private func returnInk(_ p: KeyboardChromePalette) -> Color {
if !model.returnKeyEnabled { return p.returnDisabledInk }
return model.returnKey.isAction ? .white : p.textBase
}
}