feat(ui): rebuild the UX around two surfaces — a glance popover and a session window

The menu-bar popover was being used as a session manager: status, five text fields,
thumbnails, three buttons, a history list and eight more flat rows in 320 pt. The
redesign splits the product by job, from a UX pass whose mockups are kept under
design/ux-rework/.

- Popover: only the current session. Review details as one line plus a pencil that
  opens the window with the Lane field focused, at most three thumbnails, a Capture
  and a Send row, a New Session and Open Redline row, one status line when something
  happened, and a footer with the send channel, the retention policy and a ... menu
  for Settings / updates / quit.
- Window: sidebar of sessions grouped Today / Yesterday / This week / by month with
  a Current tag and each session's state, the selected session's pages as cards
  (select, Delete or Remove Page, sent sessions read-only), and an inspector with
  editable review details, the PDF facts (file name, pages, channel, status) and the
  session facts (started, id, files). Past sessions show their details read-only.
- Settings: three labelled groups (Capture, Sending, Sessions) replacing the
  headings-plus-grid layout.
- Sessions list/search/grouping/state live on the model, so the window and the popover
  read the same truth (came-back-marked state comes from the return ledger).
- Verification: 159 tests, the headless panel self-test, and an end-to-end run against
  the active app (scripts/run-e2e-ui.sh) which opens the real window, types into the
  Lane field with key events and clicks New Session, reporting what the launch mode
  could and could not deliver.
This commit is contained in:
Claude Fable 5
2026-10-31 13:03:08 +04:00
parent 02fa791b78
commit 3061e45bcb
11 changed files with 2389 additions and 1273 deletions
+115 -160
View File
@@ -2,163 +2,156 @@ import AppKit
import SwiftUI
import ShotdeckCore
/// Settings: three labelled groups, every row "what it is" on the left and the control
/// on the right. Nothing here is needed while reviewing, which is why it is its own
/// window and not part of the session surfaces.
struct SettingsView: View {
@Environment(AppModel.self) private var model
@State private var isRecordingHotkey = false
@State private var recorder = HotkeyRecorderBox()
private let labelWidth: CGFloat = 104
var body: some View {
Grid(alignment: .leading, horizontalSpacing: 12, verticalSpacing: 10) {
GridRow {
Text("Hotkey")
.font(.headline)
.frame(maxWidth: .infinity, alignment: .leading)
.gridCellColumns(2)
}
GridRow(alignment: .center) {
fieldLabel("Capture")
HStack(spacing: 8) {
Form {
Section("Capture") {
LabeledContent("Capture shortcut") {
Button {
armHotkeyRecorder()
} label: {
Text(isRecordingHotkey ? "Press keys…" : model.hotkeyDisplayString)
.foregroundStyle(isRecordingHotkey ? .secondary : .primary)
.lineLimit(1)
}
Spacer(minLength: 0)
}
.frame(minHeight: 22)
}
GridRow {
Text("Send via")
.font(.headline)
.frame(maxWidth: .infinity, alignment: .leading)
.gridCellColumns(2)
.padding(.top, 6)
}
GridRow {
Picker("Send via", selection: transportBinding) {
ForEach(SendTransport.allCases, id: \.self) { transport in
Text(transport.displayName).tag(transport)
}
}
.labelsHidden()
.pickerStyle(.segmented)
.gridCellColumns(2)
}
GridRow {
Text("Folders")
.font(.headline)
.frame(maxWidth: .infinity, alignment: .leading)
.gridCellColumns(2)
.padding(.top, 6)
}
if model.transport == .airDrop {
GridRow(alignment: .center) {
fieldLabel("Watch folder")
folderValue(path: model.watchFolderURL.path) {
model.chooseWatchFolder()
.frame(minWidth: 54)
}
}
GridRow(alignment: .center) {
fieldLabel("Output folder")
folderValue(path: model.outboxURL.path) {
model.chooseOutboxFolder()
}
}
} else {
GridRow(alignment: .center) {
fieldLabel("OneDrive folder")
if let folder = model.resolvedOneDriveFolder {
folderValue(path: folder.path) {
model.chooseOneDriveFolder()
}
} else {
// One-line row, same shape as the normal path row: "Not found"
// where the path would be, Choose… stays live. The explanation
// moves to the caption below instead of wrapping this row.
folderValue(path: "Not found") {
model.chooseOneDriveFolder()
LabeledContent("Area") {
HStack(spacing: 8) {
Text(areaSummary)
.foregroundStyle(.secondary)
Button("Choose…") {
Task { await model.rePickRegion() }
}
}
}
}
GridRow {
Section("Sending") {
LabeledContent("Send with") {
Picker("Send with", selection: transportBinding) {
ForEach(SendTransport.allCases, id: \.self) { transport in
Text(transport.displayName).tag(transport)
}
}
.labelsHidden()
.pickerStyle(.segmented)
.frame(maxWidth: 220)
}
if model.transport == .airDrop {
LabeledContent("Save PDFs to") {
folderRow(path: model.outboxURL.path) { model.chooseOutboxFolder() }
}
LabeledContent("Watch for returns in") {
folderRow(path: model.watchFolderURL.path) { model.chooseWatchFolder() }
}
} else {
LabeledContent("OneDrive folder") {
folderRow(path: oneDrivePath) { model.chooseOneDriveFolder() }
}
Text(
model.resolvedOneDriveFolder != nil
? "The PDF is saved here and this same folder is watched for the marked-up copy. On the iPad open it from Files > OneDrive."
: "No OneDrive folder found. Sign in to OneDrive, or choose a folder."
)
.font(.caption)
.foregroundStyle(.secondary)
.foregroundStyle(model.resolvedOneDriveFolder != nil ? .secondary : .primary)
.fixedSize(horizontal: false, vertical: true)
.gridCellColumns(2)
}
}
GridRow {
Text("Sessions")
.font(.headline)
.frame(maxWidth: .infinity, alignment: .leading)
.gridCellColumns(2)
.padding(.top, 6)
}
GridRow(alignment: .center) {
fieldLabel("Delete after")
Picker("Delete after", selection: retentionBinding) {
ForEach(SessionRetention.presets, id: \.self) { preset in
Text(preset.displayName).tag(preset)
Section("Sessions") {
LabeledContent("Delete sessions older than") {
Picker("Delete sessions older than", selection: retentionBinding) {
ForEach(SessionRetention.presets, id: \.self) { preset in
Text(preset.displayName).tag(preset)
}
}
.labelsHidden()
.frame(maxWidth: 150)
}
LabeledContent(keptSummary) {
Button("Clean Up Now…") {
Task { await model.cleanUpExpiredSessions() }
}
.disabled(model.retention == .never || model.expiredSessionCount == 0)
}
.labelsHidden()
.pickerStyle(.menu)
.frame(maxWidth: .infinity, alignment: .leading)
}
GridRow {
Text(retentionDetail)
.font(.caption)
.foregroundStyle(.secondary)
.fixedSize(horizontal: false, vertical: true)
.gridCellColumns(2)
}
GridRow {
HStack(spacing: 8) {
Button("Clean up now") {
Task { await model.cleanUpExpiredSessions() }
}
.disabled(model.retention == .never)
Spacer(minLength: 0)
Button("Sessions folder") { model.openSessionsFolder() }
}
.gridCellColumns(2)
.frame(maxWidth: .infinity, alignment: .leading)
}
GridRow {
Text("Only Redline's saved screenshots are removed. Sent PDFs are never touched.")
Text("Deleting removes Redline's own screenshots only. PDFs you sent stay where they are.")
.font(.caption)
.foregroundStyle(.secondary)
.fixedSize(horizontal: false, vertical: true)
.gridCellColumns(2)
}
}
.padding(16)
.frame(minWidth: 320, idealWidth: 360, maxWidth: 360, alignment: .leading)
.controlSize(.small)
.formStyle(.grouped)
.frame(width: 460, height: 520)
.controlSize(.regular)
.onDisappear { disarmHotkeyRecorder() }
}
// MARK: - Rows
private var areaSummary: String {
guard let region = model.region else { return "Not chosen" }
return "\(Int(region.rect.width)) × \(Int(region.rect.height))"
}
private var oneDrivePath: String {
model.resolvedOneDriveFolder?.path ?? "Not found"
}
private var keptSummary: String {
let count = model.pastSessions.count + 1
return "\(count) session\(count == 1 ? "" : "s") kept"
}
private func folderRow(path: String, choose: @escaping () -> Void) -> some View {
HStack(spacing: 8) {
Text(abbreviateHome(path))
.lineLimit(1)
.truncationMode(.middle)
.foregroundStyle(.secondary)
.frame(maxWidth: 150, alignment: .trailing)
.help(path)
Button("Choose…") { choose() }
}
}
private func abbreviateHome(_ path: String) -> String {
let home = FileManager.default.homeDirectoryForCurrentUser.path
guard path.hasPrefix(home) else { return path }
return "~" + path.dropFirst(home.count)
}
// MARK: - Detail text
private var retentionDetail: String {
guard model.retention != .never else {
return "All sessions are kept. Nothing is deleted automatically."
}
let count = model.expiredSessionCount
if count == 0 {
return "No kept session is older than \(model.retention.displayName) yet."
}
return "\(count) session\(count == 1 ? " is" : "s are") already older than \(model.retention.displayName) and will be removed on the next launch or cleanup."
}
// MARK: - Bindings
private var transportBinding: Binding<SendTransport> {
Binding(get: { model.transport }, set: { model.chooseTransport($0) })
}
@@ -169,18 +162,7 @@ struct SettingsView: View {
})
}
/// States what the chosen limit does right now, using the real count of sessions
/// that have already expired — never a guess.
private var retentionDetail: String {
guard model.retention != .never else {
return "All sessions are kept. Nothing is deleted automatically."
}
let count = model.expiredSessionCount
if count == 0 {
return "No kept session is older than \(model.retention.displayName) yet."
}
return "\(count) session\(count == 1 ? " is" : "s are") already older than \(model.retention.displayName) and will be removed on the next launch or cleanup."
}
// MARK: - Hotkey recorder
private func armHotkeyRecorder() {
guard !isRecordingHotkey else { return }
@@ -209,26 +191,6 @@ struct SettingsView: View {
recorder.onKey = nil
isRecordingHotkey = false
}
private func fieldLabel(_ title: String) -> some View {
Text(title)
.lineLimit(1)
.frame(width: labelWidth, alignment: .trailing)
.gridColumnAlignment(.trailing)
.frame(minHeight: 22, alignment: .trailing)
}
private func folderValue(path: String, choose: @escaping () -> Void) -> some View {
HStack(spacing: 8) {
Text(path)
.lineLimit(1)
.truncationMode(.middle)
.foregroundStyle(.secondary)
.frame(maxWidth: .infinity, alignment: .leading)
Button("Choose…") { choose() }
}
.frame(minHeight: 22)
}
}
/// Local keyDown monitor for the Settings capture-hotkey recorder. Callbacks hop onto the
@@ -274,6 +236,7 @@ extension AppModel: SettingsWindowPresenting {
window.title = "Redline Settings"
window.styleMask = [.titled, .closable]
window.isReleasedWhenClosed = false
window.setContentSize(NSSize(width: 460, height: 520))
window.center()
let controller = NSWindowController(window: window)
Self.settingsWindowController = controller
@@ -285,7 +248,7 @@ extension AppModel: SettingsWindowPresenting {
guard let url = chooseDirectory(startingAt: outboxURL) else { return }
FolderSettings.setOutbox(url)
setFolderURLs(outbox: url, watch: watchFolderURL)
setStatus("Output folder set to \(url.lastPathComponent).")
setStatus("PDFs are saved to \(url.lastPathComponent).")
}
func chooseWatchFolder() {
@@ -295,7 +258,7 @@ extension AppModel: SettingsWindowPresenting {
Task {
do {
try await watcher.updateWatchFolder(url)
setStatus("Watch folder set to \(url.lastPathComponent).")
setStatus("Watching \(url.lastPathComponent) for returns.")
} catch {
setStatus(
(error as? ShotdeckError)?.errorDescription ?? "Could not switch the watch folder."
@@ -304,21 +267,13 @@ extension AppModel: SettingsWindowPresenting {
}
}
/// Settings "Send via" picker action. Persists the choice, recomputes the effective
/// Settings "Send with" picker action. Persists the choice, recomputes the effective
/// outbox/watch folder for the new transport, creates the OneDrive folder if it
/// doesn't exist yet, and re-points the running watcher (folder + recordUncommented)
/// at the new state. Switching back to AirDrop restores its own stored overrides
/// untouched, since AirDrop and OneDrive folder settings are stored under separate keys.
/// Refuses while a send is in flight (send() snapshots its own folder/transport, but
/// switching mid-send is still confusing UX — nothing to gain by allowing it).
/// The async reconcile below is generation-guarded: `reconcileGeneration` is bumped
/// synchronously before the Task starts, and the Task checks its own snapshot against
/// the live value before every mutating step, so rapid toggling (this function or
/// chooseOneDriveFolder, in any order) always lets the LAST choice win instead of an
/// earlier, superseded call applying its stale folder/flag after a later one already won.
/// The Task's handle is stored in `pendingReconcileTask` so send() can await its
/// completion before snapshotting transport/folder — closing the OTHER race, where a
/// toggle is immediately followed by Send before this reconcile has settled.
/// at the new state. Refuses while a send is in flight.
/// The async reconcile below is generation-guarded so rapid toggling always lets the
/// LAST choice win; its handle is stored in `pendingReconcileTask` so send() can
/// await it before snapshotting transport/folder.
func chooseTransport(_ value: SendTransport) {
guard !isSending else {
setStatus("Finish the current send first.")