mirror of
https://github.com/anomalyco/hex.git
synced 2026-11-22 21:23:02 +01:00
* iOS keyboard: Code from Messages only where its tap reaches Apple's keyboard, and without Full Access
TestFlight build 126 (iPhone 15 Pro, iOS 27.3): "That autofill for texted codes fails".
Cause, shown on an iPhone 15 Pro simulator (iOS 27.2) with real touches: the chip switches
with advanceToNextInputMode. On a number pad that always lands on Apple's number pad (Emoji and
other third-party keyboards are passed over). On any other code field (Safari's
autocomplete=one-time-code input, a .oneTimeCode field with autocorrection off) it lands on
Emoji in 10 of 21 taps with English + Emoji + Hex (iPhone's default list plus Hex, in any
order), and on another third-party keyboard in 4 of 8 taps with one in the list. Those get no
code, so the chip does nothing. Separately, the chip needed Full Access, though switching
keyboards doesn't.
Change (KeyboardClipboardTracker.offer, KeyboardInputModes.switchReachesAppleKeyboard):
- Outside number pads, Code from Messages shows only when every other keyboard is one of
Apple's language keyboards (no Emoji, no other third-party keyboard). Removed: the chip in
Safari's text-style code fields for anyone with Emoji on; a copied code still gets Paste.
Number pads (including Safari's inputmode=numeric) keep it in every list with Apple's keyboard.
- The chip no longer needs Full Access; Paste still does and still reads nothing without it.
- The comment that said the switch skips Emoji in either order is corrected.
Verified on that simulator, the fixed build:
- English + Emoji + Hex: Safari one-time-code and a .oneTimeCode autocorrection-off field show no
chip (Paste only with a copy); a number-pad field and inputmode=numeric show it and the tap
lands on Apple's number pad.
- English + Hex: chip in both kinds, tap lands on Apple's keyboard. Hex + another third-party
keyboard + English: text field no chip, number pad chip -> Apple's number pad.
- Full Access off (English + Hex): chip shows in both kinds and lands on Apple's keyboard;
with Emoji, on the number pad only. No Paste chip without Full Access.
- Before the change on origin/dev (fd4e98bb, the 44 pt bar): the chip draws and takes its tap
upright and turned, at its edges, and beside Paste.
- xcodebuild test on the rebased head: 857 tests, 3 skipped, 0 failures, including the new
KeyboardClipboardTests.testCodeFromMessagesOnlyWhereTheSwitchReachesApplesKeyboard.
- code-shape.py passes. Not verified: whether Apple's keyboard then shows the code (a simulator
gets no texts), or a real phone.
* iOS keyboard: Code from Messages opens the keyboard list where the next keyboard could be Emoji
Follow-up to the previous commit, at the coordinator's request: hiding the chip in text-style
code fields whenever Emoji or another third-party keyboard is on took it away from almost
everyone (Emoji is on by default) with no pointer to where codes come from.
Change:
- Where advanceToNextInputMode could land elsewhere (Emoji or another third-party keyboard on,
field not a number pad), the chip stays and a tap opens iOS's own keyboard list, where the
person picks Apple's keyboard. Replaced: the previous commit's hiding of the chip there.
KeyboardInputModes.route gives .next or .list (nil without Apple's keyboard);
KeyboardClipboardOffer.code gains opensList (default false).
- The chip's touches go to handleInputModeList(from:with:) as the globe's do, through the
globe's own path (FullKeyboardView.inputModeListTouch, split out of globeTouch unchanged): the
lift of a touch that stayed on the chip is held back, so UIKit's 0.2 s hold opens the list
(as the globe does on the Duo's split posture, #2340). A hold shows it under the finger, and
a slide onto a keyboard picks it on lift. The chip's .touchUpInside does nothing in that mode.
- Number pads and lists with only Apple's keyboards besides Hex keep the direct switch.
- Accessibility hint in list mode: "Shows your keyboards: pick Apple's, where iOS offers codes
from Messages and Mail" (zh-Hans added). The direct mode keeps its hint.
- showsPasteChip matches .code(canPaste: false, _) so the list mode doesn't show Paste.
Verified (iPhone 15 Pro simulator, iOS 27.2, real touches; Apple's keyboard told apart through
its keys in the accessibility tree):
- List mode, a pick of English (US) from the list: 55 of 56 picks landed on Apple's keyboard
across English + Emoji + Hex, Hex + Emoji + English, Hex + another third-party + English and
English + Hex + another third-party; Safari one-time-code and a .oneTimeCode field with
autocorrection off; upright and turned; beside Paste; Full Access on and off; tap, hold and
slide-and-lift. The one miss ended on Hex with the list gone; once, the direct switch did
the same (shown on Apple's keyboard, then Hex again half a second later), so it isn't
specific to the list.
- Direct mode unchanged: number pads in every list and English + Hex reach Apple's keyboard
with no list.
- On the head rebased onto #2386 (Paste alone takes the whole bar): 5 more list picks and 2
number-pad switches reach Apple's keyboard, and Paste beside the chip still pastes.
- xcodebuild test on that head: 858 tests, 3 skipped, 0 failures, including
testCodeFromMessagesOpensTheListWhereTheSwitchCouldMissApplesKeyboard. code-shape.py passes.
- Not verified: VoiceOver with the list mode, a real phone, and whether Apple's keyboard then
shows the code (a simulator gets no texts).
943 lines
46 KiB
Swift
943 lines
46 KiB
Swift
import UIKit
|
||
|
||
/// The 3-slot top bar above the keys, drawn as Apple's iOS 26 predictive bar is (measured in
|
||
/// the iOS 27.2 simulator): SF 17 pt regular in muted ink, slots a third of the keyboard wide,
|
||
/// 1 × 24 pt dividers ending on the thirds, and a pending autocorrection as a full-slot
|
||
/// capsule with the dividers beside it hidden. On an iPhone the strip is Apple's whole 44 pt
|
||
/// bar (`KeyboardMetrics.appleBar`): words, dividers and the cell-wide 38 pt bubble on Apple's
|
||
/// line, 25 pt below the keyboard's top edge (`KeyboardMetrics.stripTextCenter`). Before it was
|
||
/// measured (iOS 18) it is the bar from its pill's top down (38 pt), with a small chip around a
|
||
/// word instead of the capsule. The centred
|
||
/// `Undo dictation` chip or a status message replaces the slots when needed.
|
||
@MainActor
|
||
final class KeyboardStripView: UIView {
|
||
var palette = FullKeyboardPalette(isDark: false) { didSet { if palette != oldValue { applyPalette() } } }
|
||
/// Hosted in iOS's platter (not a snapshot scene's own backdrop).
|
||
var inSystemPlatter = true {
|
||
didSet {
|
||
guard inSystemPlatter != oldValue else { return }
|
||
for button in slotButtons { button.inSystemPlatter = inSystemPlatter }
|
||
setNeedsLayout()
|
||
setNeedsDisplay()
|
||
}
|
||
}
|
||
/// Each slot's frame in this view, from `KeyboardLayout.stripSlotFrames`; thirds of the
|
||
/// view until the keyboard lays it out.
|
||
var slotFrames: [CGRect]? { didSet { if slotFrames != oldValue { setNeedsLayout(); setNeedsDisplay() } } }
|
||
/// Where the words and dividers centre, from the strip's top (`KeyboardMetrics.stripTextCenter`).
|
||
var textCenterY: CGFloat? {
|
||
didSet {
|
||
guard textCenterY != oldValue else { return }
|
||
for button in slotButtons { button.textCenterY = textCenterY }
|
||
setNeedsLayout()
|
||
setNeedsDisplay()
|
||
}
|
||
}
|
||
/// A suggestion's chip and the dividers' height (`KeyboardMetrics.stripChipHeight`).
|
||
var chipHeight: CGFloat? {
|
||
didSet {
|
||
guard chipHeight != oldValue else { return }
|
||
for button in slotButtons { button.chipHeight = chipHeight }
|
||
setNeedsLayout()
|
||
setNeedsDisplay()
|
||
}
|
||
}
|
||
/// The strip is Apple's bar (`KeyboardMetrics.appleBar`): a pending word gets Apple's bubble,
|
||
/// its cell's width, and the dividers beside it hide, as Apple's do.
|
||
var appleBar = false {
|
||
didSet {
|
||
guard appleBar != oldValue else { return }
|
||
for button in slotButtons { button.fillsCell = appleBar }
|
||
setNeedsDisplay()
|
||
}
|
||
}
|
||
/// The Hex key has a cell of its own at the strip's end (Apple's bar): a divider stands
|
||
/// between it and the slot beside it, as between Apple's icon and its first cell.
|
||
var dividerBesideHex = false { didSet { if dividerBesideHex != oldValue { setNeedsDisplay() } } }
|
||
/// How far the pills sit in from the strip's top and bottom (`KeyboardMetrics.stripInset`).
|
||
var pillInset: CGFloat = 0.5 {
|
||
didSet {
|
||
guard pillInset != oldValue else { return }
|
||
for button in slotButtons { button.pillInset = pillInset }
|
||
setNeedsLayout()
|
||
}
|
||
}
|
||
var onSelectSuggestion: ((KeyboardSuggestion) -> Void)?
|
||
/// A slot was held (half a second): the word you typed offers Add to vocabulary.
|
||
var onHoldSuggestion: ((KeyboardSuggestion) -> Void)?
|
||
var onUndoDictation: (() -> Void)?
|
||
var onPaste: (() -> Void)?
|
||
var onNextKeyboard: (() -> Void)?
|
||
/// Code from Messages' touches where it opens iOS's keyboard list (`.code(opensList: true)`).
|
||
var onKeyboardListTouch: ((UIButton, UIEvent) -> Void)?
|
||
/// The Full Access hint's Open Hex was tapped (it opens Hex's setup).
|
||
var onOpenHexFromHint: (() -> Void)?
|
||
/// The notice's chip was tapped (`KeyboardStripNotice`).
|
||
var onOpenNotice: (() -> Void)?
|
||
|
||
private let statusLabel = UILabel()
|
||
private let undoChip = UIButton(type: .custom)
|
||
private let slotButtons: [SlotButton] = [SlotButton(), SlotButton(), SlotButton()]
|
||
private var currentSuggestions: [KeyboardSuggestion] = []
|
||
private var showsUndo = false
|
||
private var statusText: String?
|
||
private var clipboard: KeyboardClipboardOffer?
|
||
private var showsFullAccessHint = false
|
||
/// Built the first time the Hex key is tapped without Full Access.
|
||
private var fullAccessHintView: FullAccessHintView?
|
||
private var notice: KeyboardStripNotice?
|
||
/// Built for the first notice, in the Full Access hint's shape.
|
||
private var noticeView: FullAccessHintView?
|
||
/// The Hex key sits left of the strip (Settings › Keyboard › Hex key): the Full Access
|
||
/// hint's Open Hex leads, beside the key.
|
||
var hexOnLeading = false {
|
||
didSet {
|
||
guard hexOnLeading != oldValue else { return }
|
||
fullAccessHintView?.chipLeads = hexOnLeading
|
||
noticeView?.chipLeads = hexOnLeading
|
||
setNeedsLayout()
|
||
}
|
||
}
|
||
/// Where the bar's middle slot centres, from this view's leading edge: the keyboard's middle,
|
||
/// not this view's, which leaves out the Hex key. Paste and Next keyboard centre on it.
|
||
var barMidX: CGFloat? { didSet { if barMidX != oldValue { setNeedsLayout() } } }
|
||
/// The bar around this view, in its coordinates: from the keyboard's top to the bar's bottom
|
||
/// and across it up to the Hex key's cell. While Paste (or Paste dictation) is the only chip,
|
||
/// a tap anywhere on it pastes; beside Code from Messages each chip keeps its own frame. The
|
||
/// Hex key and row 1's reach, laid over it, keep theirs.
|
||
var barTouchFrame: CGRect? { didSet { if barTouchFrame != oldValue { setNeedsLayout() } } }
|
||
/// Plain text on the words' line, as a suggestion is: `UIPasteControl` renders as an empty
|
||
/// blue box inside a keyboard extension (TestFlight build 4), so this reads the clipboard on
|
||
/// tap instead, once, which iOS asks about until Paste from Other Apps is Allow
|
||
/// (`KeyboardClipboardTracker`).
|
||
private let pasteControl = StripChip()
|
||
private let nextKeyboardChip = UIButton(type: .custom)
|
||
|
||
override init(frame: CGRect) {
|
||
super.init(frame: frame)
|
||
isOpaque = false
|
||
backgroundColor = .clear
|
||
contentMode = .redraw
|
||
|
||
statusLabel.font = .systemFont(ofSize: 13.5)
|
||
statusLabel.textAlignment = .center
|
||
statusLabel.adjustsFontSizeToFitWidth = true
|
||
statusLabel.minimumScaleFactor = 0.8
|
||
statusLabel.isHidden = true
|
||
addSubview(statusLabel)
|
||
|
||
var chip = UIButton.Configuration.plain()
|
||
chip.image = UIImage(
|
||
systemName: "arrow.uturn.backward",
|
||
withConfiguration: UIImage.SymbolConfiguration(pointSize: 12.5, weight: .medium)
|
||
)
|
||
chip.imagePadding = 6
|
||
chip.title = String(localized: "Undo dictation")
|
||
chip.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
|
||
chip.background.cornerRadius = 15
|
||
undoChip.configuration = chip
|
||
undoChip.isHidden = true
|
||
undoChip.addTarget(self, action: #selector(handleUndo), for: .touchUpInside)
|
||
// Apple's bar words: SF 17 pt regular in the bar's ink, no chip.
|
||
var paste = UIButton.Configuration.plain()
|
||
paste.image = UIImage(
|
||
systemName: "doc.on.clipboard",
|
||
withConfiguration: UIImage.SymbolConfiguration(font: Self.pasteFont, scale: .small)
|
||
)
|
||
paste.imagePadding = 5
|
||
paste.title = String(localized: "Paste")
|
||
paste.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { attributes in
|
||
var attributes = attributes
|
||
attributes.font = Self.pasteFont
|
||
return attributes
|
||
}
|
||
paste.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 8, bottom: 0, trailing: 8)
|
||
paste.background.backgroundColor = .clear
|
||
pasteControl.configuration = paste
|
||
pasteControl.isHidden = true
|
||
pasteControl.addTarget(self, action: #selector(handlePaste), for: .touchUpInside)
|
||
addSubview(pasteControl)
|
||
addSubview(undoChip)
|
||
|
||
var next = UIButton.Configuration.plain()
|
||
next.image = UIImage(
|
||
systemName: "keyboard",
|
||
withConfiguration: UIImage.SymbolConfiguration(pointSize: 12.5, weight: .medium)
|
||
)
|
||
next.imagePadding = 6
|
||
next.title = String(localized: "Code from Messages")
|
||
next.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
|
||
next.background.cornerRadius = 15
|
||
nextKeyboardChip.configuration = next
|
||
nextKeyboardChip.isHidden = true
|
||
nextKeyboardChip.addTarget(self, action: #selector(handleNextKeyboard), for: .touchUpInside)
|
||
nextKeyboardChip.addTarget(self, action: #selector(keyboardListTouch(_:with:)), for: .allTouchEvents)
|
||
addSubview(nextKeyboardChip)
|
||
|
||
for (index, button) in slotButtons.enumerated() {
|
||
button.tag = index
|
||
button.addTarget(self, action: #selector(handleSlotTap(_:)), for: .touchUpInside)
|
||
button.addGestureRecognizer(UILongPressGestureRecognizer(target: self, action: #selector(handleSlotHold(_:))))
|
||
addSubview(button)
|
||
}
|
||
applyPalette()
|
||
}
|
||
|
||
@available(*, unavailable)
|
||
required init?(coder: NSCoder) { fatalError() }
|
||
|
||
private static let pasteFont = UIFont.systemFont(ofSize: 17, weight: .regular)
|
||
|
||
/// `fullAccessHint`, while true, replaces everything else in the strip with what
|
||
/// dictation needs (`FullAccessHintView`); `notice` does the same after it.
|
||
func update(
|
||
suggestions: [KeyboardSuggestion],
|
||
showsUndo: Bool,
|
||
statusText: String?,
|
||
clipboard: KeyboardClipboardOffer? = nil,
|
||
fullAccessHint: Bool = false,
|
||
notice: KeyboardStripNotice? = nil
|
||
) {
|
||
let changed = suggestions != currentSuggestions || showsUndo != self.showsUndo
|
||
|| statusText != self.statusText || clipboard != self.clipboard
|
||
|| fullAccessHint != showsFullAccessHint || notice != self.notice
|
||
guard changed else { return }
|
||
currentSuggestions = suggestions
|
||
self.showsUndo = showsUndo
|
||
self.statusText = statusText
|
||
self.clipboard = clipboard
|
||
showsFullAccessHint = fullAccessHint
|
||
self.notice = notice
|
||
|
||
if fullAccessHint, fullAccessHintView == nil { _ = makeFullAccessHintView() }
|
||
if let hint = fullAccessHintView { show(hint, fullAccessHint) }
|
||
if let notice, noticeView == nil { _ = makeNoticeView() }
|
||
if let notice { noticeView?.show(notice) }
|
||
if let noticeView { show(noticeView, notice != nil && !fullAccessHint) }
|
||
let showsHint = fullAccessHint || notice != nil
|
||
show(undoChip, showsUndo && !showsHint)
|
||
let showsClipboard = showsClipboard
|
||
var paste = pasteControl.configuration
|
||
let pasteTitle = clipboard == .dictation ? String(localized: "Paste dictation") : String(localized: "Paste")
|
||
if paste?.title != pasteTitle {
|
||
paste?.title = pasteTitle
|
||
pasteControl.configuration = paste
|
||
}
|
||
show(pasteControl, showsPasteChip)
|
||
show(nextKeyboardChip, showsNextKeyboardChip)
|
||
nextKeyboardChip.accessibilityHint = chipOpensList
|
||
? String(localized: "Shows your keyboards: pick Apple's, where iOS offers codes from Messages and Mail")
|
||
: String(localized: "Switches to the next keyboard, where iOS offers codes from Messages and Mail")
|
||
// Words swap letter by letter (and leave the same way when a chip or status takes the
|
||
// strip); the strip being shown for the first time just draws them.
|
||
let animated = window != nil
|
||
if showsHint || showsUndo || showsClipboard {
|
||
statusLabel.isHidden = true
|
||
slotButtons.forEach { $0.configure(with: nil, palette: palette, animated: animated) }
|
||
} else if let statusText, suggestions.isEmpty {
|
||
statusLabel.text = statusText
|
||
statusLabel.isHidden = false
|
||
slotButtons.forEach { $0.configure(with: nil, palette: palette, animated: false) }
|
||
} else {
|
||
statusLabel.isHidden = true
|
||
let slots = Self.slots(for: suggestions)
|
||
for (idx, button) in slotButtons.enumerated() {
|
||
let item = slots.firstIndex(of: idx).map { suggestions[$0] }
|
||
button.configure(with: item, palette: palette, animated: animated)
|
||
}
|
||
}
|
||
setNeedsLayout()
|
||
setNeedsDisplay()
|
||
}
|
||
|
||
/// Shows or hides a chip, fading it over Apple's 0.2 s word swap (at once with Reduce Motion).
|
||
private func show(_ view: UIView, _ shown: Bool) {
|
||
let visible = !view.isHidden && view.alpha > 0
|
||
guard shown != visible || (shown && view.alpha < 1) else { return }
|
||
guard window != nil, !UIAccessibility.isReduceMotionEnabled else {
|
||
view.layer.removeAllAnimations()
|
||
view.alpha = 1
|
||
view.isHidden = !shown
|
||
return
|
||
}
|
||
if shown {
|
||
if view.isHidden { view.alpha = 0 }
|
||
view.isHidden = false
|
||
}
|
||
UIView.animate(withDuration: 0.2, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction, .curveEaseOut]) {
|
||
view.alpha = shown ? 1 : 0
|
||
} completion: { _ in
|
||
guard view.alpha == 0 else { return }
|
||
view.isHidden = true
|
||
view.alpha = 1
|
||
}
|
||
}
|
||
|
||
/// Which slot shows each suggestion: in order, except a lone emoji, swiped word or reading
|
||
/// of one, which takes the centre. A revert keeps the left slot.
|
||
static func slots(for suggestions: [KeyboardSuggestion]) -> [Int] {
|
||
if suggestions.count == 1, ![.keepLiteral, .secondary, .revert].contains(suggestions[0].kind) { return [1] }
|
||
return Array(suggestions.indices.prefix(3))
|
||
}
|
||
|
||
/// Clipboard chips replace the empty strip; suggestions and status win.
|
||
private var showsClipboard: Bool {
|
||
guard let clipboard, !showsUndo, statusText == nil, !showsFullAccessHint, notice == nil else { return false }
|
||
if case .code = clipboard { return true }
|
||
return currentSuggestions.isEmpty
|
||
}
|
||
|
||
private var showsPasteChip: Bool {
|
||
if case .code(canPaste: false, _)? = clipboard { return false }
|
||
return showsClipboard
|
||
}
|
||
|
||
private var chipOpensList: Bool {
|
||
if case .code(_, opensList: true)? = clipboard { return true }
|
||
return false
|
||
}
|
||
|
||
private var showsNextKeyboardChip: Bool {
|
||
guard showsClipboard, case .code = clipboard else { return false }
|
||
return true
|
||
}
|
||
|
||
@objc private func handlePaste() {
|
||
onPaste?()
|
||
}
|
||
|
||
@objc private func handleNextKeyboard() {
|
||
guard !chipOpensList else { return }
|
||
onNextKeyboard?()
|
||
}
|
||
|
||
@objc private func keyboardListTouch(_ sender: UIButton, with event: UIEvent) {
|
||
guard chipOpensList else { return }
|
||
onKeyboardListTouch?(sender, event)
|
||
}
|
||
|
||
private func makeFullAccessHintView() -> FullAccessHintView {
|
||
let hint = FullAccessHintView()
|
||
hint.chipLeads = hexOnLeading
|
||
hint.onOpenHex = { [weak self] in self?.onOpenHexFromHint?() }
|
||
hint.isHidden = true
|
||
addSubview(hint)
|
||
fullAccessHintView = hint
|
||
applyPalette()
|
||
setNeedsLayout()
|
||
return hint
|
||
}
|
||
|
||
private func makeNoticeView() -> FullAccessHintView {
|
||
let view = FullAccessHintView()
|
||
view.chipLeads = hexOnLeading
|
||
view.onOpenHex = { [weak self] in self?.onOpenNotice?() }
|
||
view.isHidden = true
|
||
addSubview(view)
|
||
noticeView = view
|
||
applyPalette()
|
||
setNeedsLayout()
|
||
return view
|
||
}
|
||
|
||
private func applyPalette() {
|
||
statusLabel.textColor = palette.textMuted
|
||
var paste = pasteControl.configuration
|
||
paste?.baseForegroundColor = palette.stripText
|
||
pasteControl.configuration = paste
|
||
var next = nextKeyboardChip.configuration
|
||
next?.baseForegroundColor = palette.textMuted
|
||
next?.background.backgroundColor = palette.chipFill
|
||
nextKeyboardChip.configuration = next
|
||
var chip = undoChip.configuration
|
||
chip?.baseForegroundColor = palette.textMuted
|
||
chip?.background.backgroundColor = palette.chipFill
|
||
undoChip.configuration = chip
|
||
fullAccessHintView?.palette = palette
|
||
noticeView?.palette = palette
|
||
for (item, slot) in Self.slots(for: currentSuggestions).enumerated() {
|
||
slotButtons[slot].configure(with: currentSuggestions[item], palette: palette, animated: false)
|
||
}
|
||
setNeedsDisplay()
|
||
}
|
||
|
||
private var contentCenterY: CGFloat {
|
||
textCenterY ?? bounds.height * 0.5
|
||
}
|
||
|
||
override func layoutSubviews() {
|
||
super.layoutSubviews()
|
||
let midY = contentCenterY
|
||
statusLabel.frame = CGRect(x: 16, y: max(0, midY - 12), width: max(0, bounds.width - 32), height: 24)
|
||
let chipH = min(34, max(18, min(bounds.height - 2 * pillInset, chipHeight ?? .infinity)))
|
||
let chipSize = undoChip.sizeThatFits(CGSize(width: bounds.width, height: chipH))
|
||
undoChip.frame = CGRect(
|
||
x: (bounds.width - chipSize.width) / 2,
|
||
y: max(0, midY - chipH / 2),
|
||
width: chipSize.width,
|
||
height: chipH
|
||
)
|
||
let pasteW = pasteControl.sizeThatFits(CGSize(width: bounds.width, height: chipH)).width
|
||
let nextSize = nextKeyboardChip.sizeThatFits(CGSize(width: bounds.width, height: chipH))
|
||
// Laid out for what is shown, not what is still fading out.
|
||
let pasteShown = showsPasteChip
|
||
let nextShown = showsNextKeyboardChip
|
||
let pair = pasteShown && nextShown
|
||
let gap: CGFloat = 8
|
||
let total = pair ? pasteW + gap + nextSize.width : (pasteShown ? pasteW : nextSize.width)
|
||
// On the keyboard's middle, as the middle slot's word, kept inside the strip.
|
||
let midX = barMidX ?? bounds.width / 2
|
||
let startX = max(0, min(bounds.width - total, midX - total / 2))
|
||
let chipY = max(0, midY - chipH / 2)
|
||
pasteControl.frame = CGRect(x: startX, y: chipY, width: pasteW, height: chipH)
|
||
nextKeyboardChip.frame = CGRect(
|
||
x: pair ? startX + pasteW + gap : startX,
|
||
y: chipY,
|
||
width: nextSize.width,
|
||
height: chipH
|
||
)
|
||
pasteControl.touchArea = pasteShown && !nextShown ? barTouchFrame ?? bounds : nil
|
||
// The hint's two lines and chip centre on the words' line, as everything in the strip.
|
||
let hintHalf = min(midY, bounds.height - midY)
|
||
let hintY = midY - hintHalf
|
||
let hintFrame = CGRect(x: 12, y: hintY, width: max(0, bounds.width - 24), height: 2 * hintHalf)
|
||
fullAccessHintView?.frame = hintFrame
|
||
fullAccessHintView?.chipHeight = chipH
|
||
noticeView?.frame = hintFrame
|
||
noticeView?.chipHeight = chipH
|
||
let slots = currentSlotFrames
|
||
for (idx, button) in slotButtons.enumerated() {
|
||
button.inSystemPlatter = inSystemPlatter
|
||
button.frame = slots[idx]
|
||
}
|
||
}
|
||
|
||
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
|
||
if pasteControl.touchArea != nil, let barTouchFrame, barTouchFrame.contains(point) { return true }
|
||
return super.point(inside: point, with: event)
|
||
}
|
||
|
||
private var currentSlotFrames: [CGRect] {
|
||
if let slotFrames, slotFrames.count == 3 { return slotFrames }
|
||
let slotW = bounds.width / 3
|
||
return (0..<3).map { CGRect(x: CGFloat($0) * slotW, y: 0, width: slotW, height: bounds.height) }
|
||
}
|
||
|
||
override func draw(_ rect: CGRect) {
|
||
guard !showsUndo, !showsClipboard, !showsFullAccessHint, notice == nil, statusLabel.isHidden, bounds.width > 60 else { return }
|
||
// A chip sits inside its slot, so the dividers stay beside it, but for the one beside a
|
||
// revert, which Apple's bar hides.
|
||
let reverting = currentSuggestions.first?.kind == .revert
|
||
|
||
// Apple's dividers: 1 pt wide, ending on the slot boundary, centred on the words' line, and
|
||
// no taller than a chip (24 pt where there's room).
|
||
let lineH: CGFloat = min(24, bounds.height - 2, chipHeight ?? .infinity, 2 * contentCenterY)
|
||
let y = contentCenterY - lineH / 2
|
||
palette.stripDivider.setFill()
|
||
// Only between two filled slots: nothing to show, no dividers (as Apple's bar in a
|
||
// field it offers nothing for).
|
||
let slots = Self.slots(for: currentSuggestions)
|
||
let filled = Set(slots)
|
||
// Apple's bar hides both dividers beside its bubble (a pending autocorrection or a revert).
|
||
let bubbled: Set<Int> = appleBar ? Set(zip(currentSuggestions, slots).filter { $0.0.willAutoReplace || $0.0.kind == .revert }.map(\.1)) : []
|
||
for (index, slot) in currentSlotFrames.prefix(2).enumerated()
|
||
where slot.maxX < bounds.width - 1 && filled.contains(index) && filled.contains(index + 1) && !(reverting && index == 0)
|
||
&& !bubbled.contains(index) && !bubbled.contains(index + 1) {
|
||
UIRectFill(CGRect(x: slot.maxX - 1, y: y, width: 1, height: lineH))
|
||
}
|
||
let besideHex = hexOnLeading ? 0 : 2
|
||
if dividerBesideHex, filled.contains(besideHex), !bubbled.contains(besideHex) {
|
||
UIRectFill(CGRect(x: hexOnLeading ? 0 : bounds.width - 1, y: y, width: 1, height: lineH))
|
||
}
|
||
}
|
||
|
||
@objc private func handleUndo() {
|
||
onUndoDictation?()
|
||
}
|
||
|
||
@objc private func handleSlotTap(_ sender: SlotButton) {
|
||
guard let item = Self.slots(for: currentSuggestions).firstIndex(of: sender.tag) else { return }
|
||
onSelectSuggestion?(currentSuggestions[item])
|
||
}
|
||
|
||
@objc private func handleSlotHold(_ recognizer: UILongPressGestureRecognizer) {
|
||
guard recognizer.state == .began, let slot = recognizer.view?.tag,
|
||
let item = Self.slots(for: currentSuggestions).firstIndex(of: slot) else { return }
|
||
onHoldSuggestion?(currentSuggestions[item])
|
||
}
|
||
|
||
/// A chip whose touch can reach past its frame (`touchArea`, in the strip's coordinates): it
|
||
/// lights wherever there the finger lands, follows it in and out, and acts only if it lifts
|
||
/// inside, so a finger slid off the bar cancels. Without one, a plain button.
|
||
private final class StripChip: UIButton {
|
||
var touchArea: CGRect?
|
||
private var trackedTouch: UITouch?
|
||
|
||
private func inArea(_ touch: UITouch) -> Bool {
|
||
guard let touchArea, let superview else { return false }
|
||
return touchArea.contains(touch.location(in: superview))
|
||
}
|
||
|
||
override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
|
||
guard let touchArea, let superview else { return super.point(inside: point, with: event) }
|
||
return touchArea.contains(convert(point, to: superview))
|
||
}
|
||
|
||
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
|
||
guard touchArea != nil, trackedTouch == nil, let touch = touches.first else {
|
||
super.touchesBegan(touches, with: event)
|
||
return
|
||
}
|
||
trackedTouch = touch
|
||
isHighlighted = true
|
||
sendActions(for: .touchDown)
|
||
}
|
||
|
||
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
|
||
guard let touch = trackedTouch, touches.contains(touch) else {
|
||
super.touchesMoved(touches, with: event)
|
||
return
|
||
}
|
||
let inside = inArea(touch)
|
||
guard inside != isHighlighted else { return }
|
||
isHighlighted = inside
|
||
sendActions(for: inside ? .touchDragEnter : .touchDragExit)
|
||
}
|
||
|
||
override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
|
||
guard let touch = trackedTouch, touches.contains(touch) else {
|
||
super.touchesEnded(touches, with: event)
|
||
return
|
||
}
|
||
trackedTouch = nil
|
||
let inside = inArea(touch)
|
||
isHighlighted = false
|
||
sendActions(for: inside ? .touchUpInside : .touchUpOutside)
|
||
}
|
||
|
||
override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
|
||
guard let touch = trackedTouch, touches.contains(touch) else {
|
||
super.touchesCancelled(touches, with: event)
|
||
return
|
||
}
|
||
trackedTouch = nil
|
||
isHighlighted = false
|
||
sendActions(for: .touchCancel)
|
||
}
|
||
}
|
||
|
||
/// One suggestion slot. A word that changes swaps letter by letter, as Apple's bar does
|
||
/// (iOS 27.2, recorded at 60 fps): the letters both words share stay, the old word's other
|
||
/// letters fade from its end and the new word's from its start, each in 0.1 s, staggered
|
||
/// over 0.2 s. The capsule and dividers change at once. Reduce Motion swaps at once.
|
||
private final class SlotButton: UIControl {
|
||
var inSystemPlatter = true { didSet { if inSystemPlatter != oldValue { setNeedsDisplay() } } }
|
||
var pillInset: CGFloat = 0.5 { didSet { if pillInset != oldValue { setNeedsDisplay() } } }
|
||
var textCenterY: CGFloat? { didSet { if textCenterY != oldValue { setNeedsDisplay() } } }
|
||
var chipHeight: CGFloat? { didSet { if chipHeight != oldValue { setNeedsDisplay() } } }
|
||
/// Apple's bar: the bubble fills the slot across, from `pillInset` down `chipHeight`.
|
||
var fillsCell = false { didSet { if fillsCell != oldValue { setNeedsDisplay() } } }
|
||
private var suggestion: KeyboardSuggestion?
|
||
private var palette = FullKeyboardPalette(isDark: false)
|
||
/// The word leaving while its letters fade, and when the swap began.
|
||
private var outgoing: KeyboardSuggestion?
|
||
private var swapStart: CFTimeInterval = 0
|
||
private var displayLink: CADisplayLink?
|
||
|
||
static let letterFade: CFTimeInterval = 0.1
|
||
static let swapLength: CFTimeInterval = 0.2
|
||
static let maxStagger: CFTimeInterval = 0.025
|
||
|
||
override init(frame: CGRect) {
|
||
super.init(frame: frame)
|
||
isOpaque = false
|
||
backgroundColor = .clear
|
||
contentMode = .redraw
|
||
isAccessibilityElement = false
|
||
isUserInteractionEnabled = false
|
||
accessibilityTraits = .button
|
||
addTarget(self, action: #selector(redraw), for: [.touchDown, .touchDragEnter, .touchDragExit, .touchCancel, .touchUpInside, .touchUpOutside])
|
||
}
|
||
|
||
@available(*, unavailable)
|
||
required init?(coder: NSCoder) { fatalError() }
|
||
|
||
override var isHighlighted: Bool { didSet { if isHighlighted != oldValue { setNeedsDisplay() } } }
|
||
|
||
/// nil empties the slot (its word fades out when animated).
|
||
func configure(with suggestion: KeyboardSuggestion?, palette: FullKeyboardPalette, animated: Bool) {
|
||
let old = self.suggestion
|
||
self.suggestion = suggestion
|
||
self.palette = palette
|
||
isAccessibilityElement = suggestion != nil
|
||
isUserInteractionEnabled = suggestion != nil
|
||
accessibilityLabel = suggestion?.displayText
|
||
accessibilityHint = suggestion?.kind == .revert ? String(localized: "Undoes the autocorrection") : nil
|
||
if old?.displayText != suggestion?.displayText {
|
||
if animated, window != nil, !UIAccessibility.isReduceMotionEnabled {
|
||
outgoing = old
|
||
swapStart = CACurrentMediaTime()
|
||
startTicking()
|
||
} else {
|
||
endSwap()
|
||
}
|
||
}
|
||
setNeedsDisplay()
|
||
}
|
||
|
||
override func didMoveToWindow() {
|
||
super.didMoveToWindow()
|
||
if window == nil { endSwap() }
|
||
}
|
||
|
||
private func startTicking() {
|
||
guard displayLink == nil else { return }
|
||
let link = CADisplayLink(target: self, selector: #selector(tick))
|
||
link.add(to: .main, forMode: .common)
|
||
displayLink = link
|
||
}
|
||
|
||
private func endSwap() {
|
||
outgoing = nil
|
||
displayLink?.invalidate()
|
||
displayLink = nil
|
||
}
|
||
|
||
@objc private func tick() {
|
||
if CACurrentMediaTime() - swapStart >= Self.swapLength { endSwap() }
|
||
setNeedsDisplay()
|
||
}
|
||
|
||
@objc private func redraw() { setNeedsDisplay() }
|
||
|
||
private struct Word {
|
||
let text: String
|
||
let attributes: [NSAttributedString.Key: Any]
|
||
let origin: CGPoint
|
||
/// Drawn in a box with a truncating tail (too long for the slot): never swapped by letter.
|
||
let truncatedRect: CGRect?
|
||
}
|
||
|
||
private func layout(_ suggestion: KeyboardSuggestion, ink: UIColor) -> Word {
|
||
let midY = textCenterY ?? bounds.height * 0.5
|
||
// Apple's words are all SF 17 pt regular, the one in the capsule included.
|
||
let font = UIFont.systemFont(ofSize: suggestion.kind == .emoji ? 22 : 17, weight: .regular)
|
||
let attributes: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: ink]
|
||
// The word centres in the slot; a revert's with its arrow after it.
|
||
let arrowRoom = suggestion.kind == .revert ? Self.revertArrowSize + Self.revertArrowGap : 0
|
||
let textMidX = (bounds.width - arrowRoom) / 2
|
||
let maxTextW = max(20, bounds.width - 12 - arrowRoom)
|
||
let text = suggestion.displayText
|
||
let size = (text as NSString).size(withAttributes: attributes)
|
||
guard size.width > maxTextW else {
|
||
let origin = CGPoint(x: textMidX - size.width / 2, y: midY - size.height / 2)
|
||
return Word(text: text, attributes: attributes, origin: origin, truncatedRect: nil)
|
||
}
|
||
let style = NSMutableParagraphStyle()
|
||
style.lineBreakMode = .byTruncatingTail
|
||
style.alignment = .center
|
||
let small: [NSAttributedString.Key: Any] = [
|
||
.font: UIFont.systemFont(ofSize: 15, weight: .regular), .foregroundColor: ink, .paragraphStyle: style,
|
||
]
|
||
let smallSize = (text as NSString).size(withAttributes: small)
|
||
let width = min(maxTextW, smallSize.width)
|
||
let box = CGRect(x: textMidX - width / 2, y: midY - smallSize.height / 2, width: width, height: smallSize.height)
|
||
return Word(text: text, attributes: small, origin: box.origin, truncatedRect: box)
|
||
}
|
||
|
||
/// Draws the word with each letter's opacity from alpha (1 is the ink's own).
|
||
private func draw(_ word: Word, alpha: (Int) -> CGFloat) {
|
||
let ink = word.attributes[.foregroundColor] as? UIColor ?? .label
|
||
if let box = word.truncatedRect {
|
||
var attributes = word.attributes
|
||
attributes[.foregroundColor] = ink.withAlphaComponent(ink.cgColor.alpha * max(0, alpha(0)))
|
||
(word.text as NSString).draw(in: box, withAttributes: attributes)
|
||
return
|
||
}
|
||
let string = NSMutableAttributedString(string: word.text, attributes: word.attributes)
|
||
var offset = 0
|
||
for (index, character) in word.text.enumerated() {
|
||
let length = String(character).utf16.count
|
||
let a = alpha(index)
|
||
if a < 1 {
|
||
let faded = ink.withAlphaComponent(ink.cgColor.alpha * max(0, a))
|
||
string.addAttribute(.foregroundColor, value: faded, range: NSRange(location: offset, length: length))
|
||
}
|
||
offset += length
|
||
}
|
||
string.draw(at: word.origin)
|
||
}
|
||
|
||
private static func progress(_ t: CFTimeInterval, start: CFTimeInterval) -> CGFloat {
|
||
let x = min(1, max(0, (t - start) / letterFade))
|
||
return CGFloat(x * x * (3 - 2 * x))
|
||
}
|
||
|
||
static let chipPadding: CGFloat = 12
|
||
static let revertArrowSize: CGFloat = 13
|
||
static let revertArrowGap: CGFloat = 5
|
||
|
||
/// Apple's revert bubble's undo arrow, after the word.
|
||
private func drawRevertArrow(after word: Word, ink: UIColor) {
|
||
let config = UIImage.SymbolConfiguration(pointSize: Self.revertArrowSize, weight: .medium)
|
||
guard let arrow = UIImage(systemName: "arrow.uturn.backward", withConfiguration: config)?
|
||
.withTintColor(ink, renderingMode: .alwaysOriginal) else { return }
|
||
let textWidth = word.truncatedRect?.width ?? (word.text as NSString).size(withAttributes: word.attributes).width
|
||
let x = word.origin.x + textWidth + Self.revertArrowGap
|
||
arrow.draw(at: CGPoint(x: x, y: (textCenterY ?? bounds.height * 0.5) - arrow.size.height / 2))
|
||
}
|
||
|
||
override func draw(_ rect: CGRect) {
|
||
let pilled = suggestion != nil && (isHighlighted || suggestion?.willAutoReplace == true || suggestion?.kind == .revert)
|
||
let ink = pilled ? palette.stripPillText : palette.stripText
|
||
let incoming = suggestion.map { layout($0, ink: ink) }
|
||
if pilled, let incoming {
|
||
// A chip around the word (and a revert's arrow), even above and below the words'
|
||
// line: Apple's slot-wide 38 pt pill reaches into the band iOS draws over a
|
||
// third-party keyboard, and cut short there it read as squashed.
|
||
let textW = incoming.truncatedRect?.width ?? (incoming.text as NSString).size(withAttributes: incoming.attributes).width
|
||
let arrowRoom = suggestion?.kind == .revert ? Self.revertArrowSize + Self.revertArrowGap : 0
|
||
let chipH = chipHeight ?? max(22, bounds.height - 2 * pillInset)
|
||
let chipW = min(bounds.width, textW + arrowRoom + 2 * Self.chipPadding)
|
||
let midY = textCenterY ?? bounds.height * 0.5
|
||
// Apple's bubble (iOS 26.5 and 27.2): the whole cell across, a capsule on the line.
|
||
let chip = fillsCell ? CGRect(x: 0, y: midY - chipH / 2, width: bounds.width, height: chipH) : CGRect(
|
||
x: max(0, min(bounds.width - chipW, incoming.origin.x - (chipW - textW - arrowRoom) / 2)),
|
||
y: midY - chipH / 2,
|
||
width: chipW,
|
||
height: chipH
|
||
)
|
||
(isHighlighted ? palette.stripPillPressedFill : palette.stripPillFill).setFill()
|
||
UIBezierPath(roundedRect: chip, cornerRadius: chipH / 2).fill()
|
||
}
|
||
if let incoming, suggestion?.kind == .revert { drawRevertArrow(after: incoming, ink: ink) }
|
||
guard var leaving = outgoing.map({ layout($0, ink: ink) }) else {
|
||
if let incoming { draw(incoming) { _ in 1 } }
|
||
return
|
||
}
|
||
let t = CACurrentMediaTime() - swapStart
|
||
let oldLetters = Array(leaving.text)
|
||
let newLetters = Array(incoming?.text ?? "")
|
||
let byLetter = leaving.truncatedRect == nil && incoming?.truncatedRect == nil
|
||
// Letters both words start with stay put (drawn once, in the new word).
|
||
var shared = 0
|
||
if byLetter, incoming != nil {
|
||
while shared < min(oldLetters.count, newLetters.count), oldLetters[shared] == newLetters[shared] {
|
||
shared += 1
|
||
}
|
||
}
|
||
if shared > 0, let incoming {
|
||
// The old ending continues from the shared letters, so it never jumps aside.
|
||
leaving = Word(text: leaving.text, attributes: leaving.attributes, origin: incoming.origin, truncatedRect: nil)
|
||
}
|
||
let changing = max(oldLetters.count, newLetters.count) - shared
|
||
let stagger = changing > 1 ? min(Self.maxStagger, (Self.swapLength - Self.letterFade) / Double(changing - 1)) : 0
|
||
draw(leaving) { index in
|
||
guard index >= shared else { return 0 }
|
||
guard byLetter else { return 1 - Self.progress(t, start: 0) }
|
||
return 1 - Self.progress(t, start: Double(oldLetters.count - 1 - index) * stagger)
|
||
}
|
||
if let incoming {
|
||
draw(incoming) { index in
|
||
guard index >= shared else { return 1 }
|
||
guard byLetter else { return Self.progress(t, start: 0) }
|
||
return Self.progress(t, start: Double(index - shared) * stagger)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A two-line message with a chip that replaces the strip for a few seconds, in the Full Access
|
||
/// hint's shape: "Couldn't translate, pasted as spoken" over its fix, and Open Hex.
|
||
struct KeyboardStripNotice: Equatable {
|
||
let title: String
|
||
let detail: String
|
||
let button: String
|
||
}
|
||
|
||
/// What the Hex key shows without Full Access: dictation needs Allow Full Access, where to
|
||
/// turn it on, and an Open Hex chip, the only part that opens Hex, on the Hex key's side.
|
||
@MainActor
|
||
final class FullAccessHintView: UIView {
|
||
static let title = String(localized: "Allow Full Access to dictate")
|
||
static let path = String(localized: "Settings › Apps › Hex › Keyboards")
|
||
static let spokenPath = String(localized: "Settings, Apps, Hex, Keyboards")
|
||
|
||
var palette = FullKeyboardPalette(isDark: false) { didSet { applyPalette() } }
|
||
var chipHeight: CGFloat = 30 { didSet { setNeedsLayout() } }
|
||
/// The Hex key is on the left: Open Hex sits at the leading end, the text after it.
|
||
var chipLeads = false { didSet { if chipLeads != oldValue { setNeedsLayout() } } }
|
||
var onOpenHex: (() -> Void)?
|
||
|
||
private let titleLabel = UILabel()
|
||
private let pathLabel = UILabel()
|
||
private let openButton = UIButton(type: .custom)
|
||
|
||
override init(frame: CGRect) {
|
||
super.init(frame: frame)
|
||
backgroundColor = .clear
|
||
titleLabel.text = Self.title
|
||
titleLabel.font = .systemFont(ofSize: 13, weight: .medium)
|
||
pathLabel.text = Self.path
|
||
pathLabel.font = .systemFont(ofSize: 11.5)
|
||
pathLabel.accessibilityLabel = Self.spokenPath
|
||
for label in [titleLabel, pathLabel] {
|
||
label.adjustsFontSizeToFitWidth = true
|
||
label.minimumScaleFactor = 0.8
|
||
label.lineBreakMode = .byTruncatingTail
|
||
addSubview(label)
|
||
}
|
||
var open = UIButton.Configuration.plain()
|
||
open.title = String(localized: "Open Hex")
|
||
open.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 13, bottom: 0, trailing: 13)
|
||
open.background.cornerRadius = 15
|
||
openButton.configuration = open
|
||
openButton.accessibilityHint = String(localized: "Opens Hex's setup")
|
||
openButton.addTarget(self, action: #selector(handleOpen), for: .touchUpInside)
|
||
addSubview(openButton)
|
||
applyPalette()
|
||
}
|
||
|
||
@available(*, unavailable)
|
||
required init?(coder: NSCoder) { fatalError() }
|
||
|
||
@objc private func handleOpen() {
|
||
onOpenHex?()
|
||
}
|
||
|
||
/// Shows `notice` in place of the Full Access words.
|
||
func show(_ notice: KeyboardStripNotice) {
|
||
titleLabel.text = notice.title
|
||
pathLabel.text = notice.detail
|
||
pathLabel.accessibilityLabel = nil
|
||
var open = openButton.configuration
|
||
open?.title = notice.button
|
||
openButton.configuration = open
|
||
openButton.accessibilityHint = nil
|
||
setNeedsLayout()
|
||
}
|
||
|
||
private func applyPalette() {
|
||
titleLabel.textColor = palette.textBase
|
||
pathLabel.textColor = palette.textMuted
|
||
var open = openButton.configuration
|
||
open?.baseForegroundColor = palette.textBase
|
||
open?.background.backgroundColor = palette.chipFill
|
||
openButton.configuration = open
|
||
}
|
||
|
||
override func layoutSubviews() {
|
||
super.layoutSubviews()
|
||
let buttonWidth = openButton.sizeThatFits(CGSize(width: bounds.width, height: chipHeight)).width
|
||
openButton.frame = CGRect(
|
||
x: chipLeads ? 0 : bounds.width - buttonWidth,
|
||
y: (bounds.height - chipHeight) / 2,
|
||
width: buttonWidth,
|
||
height: chipHeight
|
||
)
|
||
let textX = chipLeads ? openButton.frame.maxX + 10 : 0
|
||
let textWidth = chipLeads ? max(0, bounds.width - textX) : max(0, openButton.frame.minX - 10)
|
||
// Two lines, even above and below the strip's words' line.
|
||
let lineHeight: CGFloat = min(16, (bounds.height + 1) / 2)
|
||
let top = (bounds.height - 2 * lineHeight) / 2
|
||
titleLabel.frame = CGRect(x: textX, y: top, width: textWidth, height: lineHeight)
|
||
pathLabel.frame = CGRect(x: textX, y: top + lineHeight, width: textWidth, height: lineHeight)
|
||
}
|
||
}
|
||
|
||
/// The strip's geometry: Apple's prediction bar on an iPhone (`appleBar`), the 38 pt strip before
|
||
/// it was measured, and the Duo's and iPad's bars.
|
||
nonisolated extension KeyboardMetrics {
|
||
/// The suggestion strip is Apple's predictive bar from the top of its suggestion pill down.
|
||
/// Apple's bar is 44 pt from its panel's edge, the pill around a suggested word starts 6 pt
|
||
/// down, and row 1's keycaps start about 8 pt under the bar (51.7 pt down, iPhone 17 Pro,
|
||
/// iOS 27.2). So the strip is 38 pt, then the same 8 pt gap, and row 1 starts 46 pt down.
|
||
/// iOS 26 and later draw about 17 pt of their own panel above a third-party keyboard in some
|
||
/// presentations and nothing in others (Hex, Gboard and SwiftKey alike on an iPhone 17 Pro,
|
||
/// iOS 27.2: Notes has it, a Safari form's first focus doesn't), and a keyboard can't tell
|
||
/// which, so the strip carries its own room above the words. It was 27 pt, the part of
|
||
/// Apple's bar below that band: without the band the words sat 9 pt under the keyboard's top
|
||
/// edge and a chip touched it. Everything the strip shows (suggestions, Undo dictation, the
|
||
/// Full Access hint, the recording bar, the emoji panel's top row) lives in those 38 pt,
|
||
/// centred on the words' line (`stripTextCenter`).
|
||
static let stripBarHeight: CGFloat = 38
|
||
static let stripGap: CGFloat = 8
|
||
/// On the iPhone Duo iOS sets the keyboard in a platter with its own band above, and the
|
||
/// strip is Apple's whole 44 pt bar, right on the keys.
|
||
static let insetStripHeight: CGFloat = 44
|
||
/// The Duo folded and upright: iOS's band there is 8.7 pt and Apple's keycaps start 48.7 pt
|
||
/// below the panel's edge (iOS 27.2), so the strip is 32 pt with the iPhone's 8 pt gap.
|
||
static let coverStripHeight: CGFloat = 32
|
||
|
||
/// How far below the strip's top its pills (the Hex key, the recording bar) start: they
|
||
/// centre on the words' line, 6 pt down in the phone's portrait strip, in the Duo's 44 pt
|
||
/// bar 4 pt.
|
||
var stripInset: CGFloat { stripTextCenter - stripPillHeight / 2 }
|
||
/// Apple's pill starts 6 pt below its panel's edge (iOS 27.2, iPhone 17 Pro); Hex's pills
|
||
/// start as far below the keyboard's own top edge, which is the panel's edge whenever iOS
|
||
/// draws nothing above the keyboard.
|
||
static let barPillTop: CGFloat = 6
|
||
/// The pills' height. In the phone's portrait strip, even above and below the words' line
|
||
/// from `barPillTop` down (28 pt), inside the strip. Elsewhere it's the strip less half a
|
||
/// point above and below, at most 36 pt.
|
||
var stripPillHeight: CGFloat {
|
||
if appleBar { return min(Self.appleBubbleHeight, 2 * min(stripTextCenter, stripHeight - stripTextCenter)) }
|
||
guard stripHeight == Self.stripBarHeight else { return min(stripHeight - 1, 36) }
|
||
return 2 * min(stripTextCenter - Self.barPillTop, stripHeight - stripTextCenter)
|
||
}
|
||
|
||
/// Where the strip's words, dividers, chips and Hex mark centre. Apple's words sit midway
|
||
/// between the panel's edge and row 1's keycaps (25.3 pt down, keycaps at 52 pt, iPhone 17
|
||
/// Pro, iOS 27.2), so in the phone's portrait strip they're 26 pt above row 1, 20 pt below
|
||
/// the keyboard's top edge. Elsewhere the strip is Apple's bar and they centre in it.
|
||
static let barTextAboveKeys: CGFloat = 26
|
||
var stripTextCenter: CGFloat {
|
||
if appleBar { return stripHeight - Self.appleBarTextAboveBottom }
|
||
return stripHeight == Self.stripBarHeight ? stripHeight + stripBottom - Self.barTextAboveKeys : stripHeight / 2
|
||
}
|
||
/// A suggestion's chip (an autocorrection, a pressed word, a revert) and the dividers: in
|
||
/// the phone's portrait strip a small chip around the word, 18 pt, even above and below the
|
||
/// words' line (not Apple's slot-wide 38 pt pill). Elsewhere the pill height.
|
||
static let barChipHeight: CGFloat = 18
|
||
var stripChipHeight: CGFloat {
|
||
!appleBar && stripHeight == Self.stripBarHeight ? Self.barChipHeight : stripPillHeight
|
||
}
|
||
|
||
/// Apple's prediction bar, measured beside Hex on iOS 26.5 and 27.2 (iPhone 17 Pro, Air, 17 Pro
|
||
/// Max and SE, upright and turned, light and dark, black box): 44 pt from the keyboard's top
|
||
/// edge on every iPhone, row 1's keycaps 8 pt under it upright and 6 pt turned. Its words, its
|
||
/// dividers and the bubble behind a pending autocorrection all centre 25 pt down (19 pt above
|
||
/// the bar's bottom); the bubble fills its cell from 6 pt down to the bar's bottom, a 38 pt
|
||
/// capsule, and the dividers are 1 × 24 pt, hidden beside the bubble.
|
||
static let appleBarHeight: CGFloat = 44
|
||
static let appleBarTurnedGap: CGFloat = 6
|
||
static let appleBarTextAboveBottom: CGFloat = 19
|
||
static let appleBubbleHeight: CGFloat = 38
|
||
/// Apple's bar leads with a 59 pt cell for its writing tools icon, then a divider, then three
|
||
/// equal cells (iPhone 17 Pro Max, iOS 27.2.1, a TestFlight tester's screenshot; the simulator
|
||
/// shows no icon). Hex's key takes that cell at its own end of the bar.
|
||
static let appleIconCellWidth: CGFloat = 59
|
||
/// Hex's key in Apple's bar keeps the 44 × 28 pt mark it had in the 38 pt strip.
|
||
static let barHexKeyHeight: CGFloat = 28
|
||
/// Apple's bar was measured on iOS 26 and 27 (`KeyboardLanguage.systemMajorVersion`); iOS 18
|
||
/// is unmeasured (no simulator runtime) and keeps the 38 pt strip it always had.
|
||
static var appleBarIsMeasured: Bool { KeyboardLanguage.systemMajorVersion >= 26 }
|
||
|
||
/// These metrics with Apple's prediction bar for a strip: 44 pt, then 8 pt to row 1 upright or
|
||
/// 6 pt turned. Upright the keyboard grows 6 pt upward (rows stay put) and its top edge is
|
||
/// Apple's; turned it was already Apple's height (42 + 8 pt), and only the strip changes.
|
||
func withAppleBar(turned: Bool) -> KeyboardMetrics {
|
||
var m = rebuilt(stripHeight: Self.appleBarHeight, stripBottom: turned ? Self.appleBarTurnedGap : Self.stripGap)
|
||
m.appleBar = true
|
||
return m
|
||
}
|
||
/// The tallest band of the strip that is even above and below the words' line, from the
|
||
/// strip's top: what fills the strip (the Full Access hint, the emoji panel's top row, the
|
||
/// emoji search field) centres in it, so it sits on the line too. The whole strip where the
|
||
/// words centre in it.
|
||
var stripLineBand: (top: CGFloat, height: CGFloat) {
|
||
let half = min(stripTextCenter, stripHeight - stripTextCenter)
|
||
return (stripTextCenter - half, 2 * half)
|
||
}
|
||
}
|