flea-qml 0.0.0-stage → 0.1.0

package/ui/PickerListing.qml

@@ -0,0 +1,149 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/FleaBin.js" as FleaBin
+
+// Listings can block inside FUSE. Only this read-only worker is replaceable; selection identities
+// belong to the picker's separate backend, and the file manager's write backend is never signalled.
+Item {
+    id: root
+    signal message(var value)
+    signal pathsResolved(var paths, int request)
+    signal failed(string reason)
+    signal quitReady()
+    property var current: null
+    property var pending: null
+    property bool quitting: false
+
+    function clear() {
+        pending = null
+        if (current) {
+            current.obsolete = true
+            if (current.running) current.signal(9)
+        }
+    }
+    function request(value) {
+        if (quitting) return
+        // Only list and listpaths have a worker to serve them, so any other request names itself here.
+        if (value.c !== "list" && value.c !== "listpaths") { console.warn("PickerListing refused request " + value.c); return }
+        pending = value
+        if (current) {
+            current.obsolete = true
+            if (current.running) current.signal(9)
+        } else launch()
+    }
+    function launch() {
+        if (quitting || !pending || current) return
+        var value = pending
+        pending = null
+        current = worker.createObject(root, {request: value})
+        current.running = true
+    }
+    function window(start, count) {
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "window", start: start, count: count}) + "\n")
+    }
+    // Resolve names without asking metadata for rows outside the held window.
+    function paths(rows, request) {
+        if (!current || !current.running || current.obsolete || quitting) return false
+        current.pathRequests = current.pathRequests.concat([request])
+        current.write(JSON.stringify({c: "paths", rows: rows}) + "\n")
+        return true
+    }
+    // Storage class for the grid planner, asked after the listing lands.
+    function fsinfo() {
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "fsinfo"}) + "\n")
+    }
+    // Sort reorders the worker's own listing without replacing it; the caller re-asks the window after.
+    function sort(by, desc, foldersFirst, groupByKind, hiddenLast) {
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "sort", by: by, desc: desc, foldersFirst: foldersFirst, groupByKind: groupByKind, hiddenLast: hiddenLast}) + "\n")
+    }
+    // Thumbnails are planned against the rows this worker holds, so the ask goes to it and not to
+    // the picker's selection backend, which holds no listing at all. An empty ask names nothing.
+    function thumb(rows, cacheOnly) {
+        if (!rows || rows.length === 0) return
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "thumb", rows: rows, cacheOnly: cacheOnly === true}) + "\n")
+    }
+    // An empty rows cancels everything queued, so an empty list is never sent; see docs/protocol.md.
+    function thumbcancel(rows) {
+        if (!rows || rows.length === 0) return
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "thumbcancel", rows: rows}) + "\n")
+    }
+    // The path bar's folder jump, asked once per open of the field; the worker is the full backend, so it answers the main window's jumped line.
+    function jump(id, ranking, favourites, recent) {
+        if (current && current.running && !current.obsolete && !quitting) {
+            var message = {c: "jump", id: id, favourites: favourites, recent: recent}
+            if (ranking !== 0) message.ranking = ranking
+            current.write(JSON.stringify(message) + "\n")
+        }
+    }
+    // Tab completion behind the picker's field: the directory the head names.
+    function peek(dir, first, hidden) {
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "peek", path: dir, first: first, hidden: hidden}) + "\n")
+    }
+    // A typed file's row, named from the listing's own names: nothing is statted and no window is walked.
+    function locate(path) {
+        if (current && current.running && !current.obsolete && !quitting)
+            current.write(JSON.stringify({c: "locate", path: path}) + "\n")
+    }
+    function quit() {
+        quitting = true
+        pending = null
+        if (!current) { quitReady(); return }
+        current.obsolete = true
+        if (current.running) current.signal(9)
+    }
+    function ended(process, reason) {
+        if (current !== process) return
+        current = null
+        process.destroy()
+        if (quitting) quitReady()
+        else if (pending) Qt.callLater(launch)
+        else if (!process.obsolete) failed(reason)
+    }
+    Component.onDestruction: if (current && current.running) current.signal(9)
+
+    Component {
+        id: worker
+        Process {
+            id: process
+            property var request
+            property bool obsolete: false
+            property bool started: false
+            property var pathRequests: []
+            command: FleaBin.command(Quickshell.env("FLEA_BIN"), Quickshell.env("BUNINU_BUN"), Quickshell.shellDir, ["--backend"])
+            stdinEnabled: true
+            onStarted: {
+                started = true
+                if (obsolete || root.quitting) { signal(9); return }
+                write(JSON.stringify(request) + "\n")
+            }
+            stdout: SplitParser {
+                onRead: function(line) {
+                    if (process.obsolete || root.quitting || root.current !== process || !line) return
+                    // Sample reply: {"t":"paths","paths":["/folder/file.txt"]}; replies follow request order on this worker.
+                    try {
+                        var message = JSON.parse(line)
+                        if (message.t === "paths") {
+                            var request = process.pathRequests.shift()
+                            if (request !== undefined) root.pathsResolved(message.paths, request)
+                        } else root.message(message)
+                    }
+                    catch (error) { console.warn("PickerListing could not handle a worker reply: " + error); root.failed("This folder could not be listed.") }
+                }
+            }
+            onExited: function(code, status) {
+                // The signal(9) above ends an obsolete or quitting worker on purpose, so only an unasked exit is worth a warning.
+                if (!process.obsolete && !root.quitting) console.warn("PickerListing worker exited with code " + code)
+                root.ended(process, "Flea stopped responding, so this folder could not be listed.")
+            }
+            // A failed QProcess spawn emits runningChanged, but never exited.
+            onRunningChanged: if (!running && !started) root.ended(process, "This folder could not be listed. Restart Flea.")
+        }
+    }
+}

package/ui/PickerPathBar.qml

@@ -0,0 +1,127 @@
+import QtQuick
+import "js/Format.js" as Format
+import "js/PathBar.js" as PathBar
+import "js/Picker.js" as Picker
+
+// A committed picker line, named by the backend's peek first: a folder opens, a file answers through its row's accept, nothing else.
+Item {
+    id: root
+
+    required property var picker
+    required property var listing
+    required property var backend
+    required property var entry
+
+    // Recent is a location and not a path, so a relative line resolves against home there, never onto the location token.
+    readonly property string basePath: root.picker.recent ? root.picker.home : root.picker.path
+
+    // The path peeked and waiting for its answer.
+    property string asked: ""
+    // A typed file's path, waiting for its parent's listing to name its row, and that row once named.
+    property string leaf: ""
+    property string leafParent: ""
+    property int leafIndex: -1
+    // A listing that fails answers a waiting typed file with the footer's own error, so the leaf waits on nothing.
+    readonly property bool listingFailed: root.picker.listingFailed
+    onListingFailedChanged: if (root.listingFailed) root.leaf = ""
+
+    function commitTyped(text) {
+        var target = PathBar.resolve(text, root.basePath, root.picker.home)
+        if (target === "") {
+            // A URI on another host says its sentence; an empty line only closes, as the chrome's commit does.
+            if (PathBar.refused(text)) {
+                root.picker.say(PathBar.REFUSED_SENTENCE, false)
+                return
+            }
+            root.entry.closeEdit()
+            return
+        }
+        root.ask(target)
+    }
+
+    // A peek of count zero is the stat and nothing else; Tab's own peek asks for rows, so the two replies never mix.
+    function ask(target) {
+        root.asked = target
+        root.leaf = ""
+        root.listing.peek(target, 0, root.picker.showHidden)
+    }
+
+    function answered(path, readFailed, mode) {
+        if (path !== root.asked) return
+        root.asked = ""
+        var kind = PathBar.kindOfPeek(readFailed, mode)
+        if (kind === "missing") {
+            root.picker.say(Format.fill(PathBar.MISSING_SENTENCE, path), true)
+        } else if (kind === "folder") {
+            root.picker.open(path)
+            root.entry.closeEdit()
+        } else {
+            root.openFile(path)
+        }
+    }
+
+    function openFile(path) {
+        // A file where a folder answers is the backend's own refusal: the mark names the folder type and fails it, and a mark in flight keeps its accept.
+        if (root.picker.saving || root.picker.folderMode) {
+            root.picker.pathProbe = root.picker.check({op: "mark", path: path, directory: true, multiple: false})
+            return
+        }
+        root.leaf = path
+        root.leafParent = Picker.parentOf(path)
+        root.leafIndex = -1
+        if (root.leafParent !== root.picker.path) root.picker.open(root.leafParent)
+        else if (root.picker.listingFailed) root.leaf = ""
+        else if (root.picker.pendingListings === 0) root.listing.locate(path)
+    }
+
+    // Sample input: {"t":"located","directory":"/d","path":"/d/a.txt","index":42}; -1 is a name the filter or the hidden files setting left out.
+    function located(message) {
+        // A reply against another listing is stale; the leaf's own listing locates it again when it lands.
+        if (root.leaf === "" || message.path !== root.leaf || message.directory !== root.leafParent) return
+        if (message.index < 0) {
+            root.picker.say(Format.fill(PathBar.FILTERED_SENTENCE, root.leaf.substring(root.leaf.lastIndexOf("/") + 1)), true)
+            root.leaf = ""
+            return
+        }
+        root.leafIndex = message.index
+        root.picker.cursorIndex = message.index
+        root.picker.viewItem().reshow(message.index)
+        root.take()
+    }
+
+    // The row's own accept runs once its window is held; the reshow above asks for that window when it is not.
+    function take() {
+        if (root.leaf === "" || root.leafIndex < 0 || !root.picker.rowFor(root.leafIndex)) return
+        var index = root.leafIndex
+        root.leaf = ""
+        root.leafIndex = -1
+        root.picker.activate(index)
+    }
+
+    // The field closing, or the picker moving on, drops whatever was still being looked for.
+    function editClosed() {
+        root.asked = ""
+        root.leaf = ""
+        root.picker.focusDefault()
+    }
+
+    // Every listing of the leaf's folder, its first or a re-read, renumbers the rows, so the leaf is located afresh against it.
+    Connections {
+        target: root.backend
+        function onListed() {
+            if (root.leaf === "") return
+            if (root.picker.path !== root.leafParent) { root.leaf = ""; return }
+            root.leafIndex = -1
+            root.listing.locate(root.leaf)
+        }
+        function onLocated(message) { root.located(message) }
+        function onRows() { root.take() }
+        function onJumped(id, favourites, zoxide, recent, frecency) {
+            if (root.entry.jump !== null) root.entry.jump.take(id, favourites, zoxide, recent, frecency)
+        }
+        function onPeeked(path, hidden, total, rows, readFailed, mode, hiddenLast, first) {
+            if (first === 0) root.answered(path, readFailed, mode)
+            else root.entry.completeWith(path, hidden, rows)
+        }
+    }
+}

package/ui/PickerPlaces.qml

@@ -0,0 +1,189 @@
+import QtQuick
+import "." as Flea
+import "js/Icons.js" as Icons
+import "js/Picker.js" as Picker
+import "js/Places.js" as Places
+import "js/Keymap.js" as Keymap
+
+// The chooser shares Flea's favourites and home locations without importing legacy GTK bookmarks.
+Item {
+    id: root
+
+    property string home: ""
+    required property var picker
+    property string current: ""
+    // The ink the picker draws every rule in, handed down by ui/picker.qml, which says why; the
+    // window's own rule colour stands in so an unwired rail still draws a seam and never a black one.
+    property color edge: Theme.color.surface
+
+    signal chosen(string path)
+    signal networkCompleted(string requestId, string uri, bool success, string reason, bool connectFailed)
+
+    // SendPicker.html draws Recent above Home, and a save has no history to write into, so the one
+    // mode that cannot use the location does not offer it.
+    property bool offerRecent: true
+
+    // Recent is a location and not a path, so its row carries the token ui/js/Picker.js names; the
+    // rail's own cursor and activation then work on it exactly as they do on a favourite.
+    readonly property var recentRow: [{
+        path: Picker.RECENT, label: Picker.RECENT_LABEL, group: "favorite", kind: "favorite", glyph: "history"
+    }]
+    readonly property var placeEntries: (root.offerRecent ? root.recentRow : [])
+        .concat(Places.storedEntries(Flea.Favourites.records, root.home), Places.homeEntries(root.home, Flea.RailPlaces.probed, Icons.sidebarGlyphFor))
+    // Directive 55, from a user's report: a dialog that cannot reach a disk or a share is a
+    // dialog that makes you type the path, so the chooser draws the window's own NETWORK and DEVICES
+    // groups from the same listings. Rows only: nothing here trashes, ejects or renames.
+    // flea-qml: the drives found by looking close the list as plain folders, as they close the window's DEVICES group.
+    readonly property var entries: root.placeEntries.concat(network.entries, devices.entries, phones.entries, Places.volumeEntries(Flea.RailPlaces.probedVolumes, devices.entries))
+
+    implicitWidth: Math.min(parent.width / 3, Theme.space(172))
+    readonly property alias focusItem: rail
+    property bool awaitingNetwork: false
+    property string awaitingDevice: ""
+
+    Rectangle {
+        anchors.fill: parent
+        color: Theme.color.background
+    }
+
+    Rectangle {
+        anchors.right: parent.right
+        width: Theme.spacing.hairline
+        height: parent.height
+        color: root.edge
+    }
+
+    ListView {
+        id: rail
+        anchors.fill: parent
+        anchors.topMargin: Theme.spacing.rowPaddingY
+        clip: true
+        boundsBehavior: Flickable.StopAtBounds
+        model: root.entries
+        activeFocusOnTab: true
+        currentIndex: 0
+        onCurrentIndexChanged: positionViewAtIndex(currentIndex, ListView.Contain)
+        Flea.FastScrollHandler { flickable: rail }
+        // No bar and no lane: rows fill the rail and still scroll by wheel, touchpad and keys.
+        Keys.onTabPressed: function(event) { root.picker.stepFocus(rail, (event.modifiers & Qt.ShiftModifier) !== 0) }
+        Keys.onBacktabPressed: root.picker.stepFocus(rail, true)
+        Keys.onPressed: function(event) {
+            var action = Keymap.lookup(event.key, event.text, event.modifiers, "rail")
+            event.accepted = true
+            if (action === "cursorUp") rail.currentIndex = Math.max(0, rail.currentIndex - 1)
+            else if (action === "cursorDown") rail.currentIndex = Math.min(root.entries.length - 1, rail.currentIndex + 1)
+            else if (action === "open" || action === "pageForward" || event.key === Qt.Key_Space) root.choose(rail.currentIndex)
+            else event.accepted = false
+        }
+
+        // index and modelData are required on ui/SidebarRow.qml itself, so the view fills them;
+        // redeclaring them here left the delegate uninitialised and the rail drew nothing.
+        delegate: Flea.SidebarRow {
+            lit: rail.activeFocus ? index === rail.currentIndex : modelData.path === root.current
+            focused: rail.activeFocus
+            onActivated: function (at) { root.choose(at) }
+        }
+    }
+
+    function choose(index) {
+        if (root.picker.submitting || root.picker.backendUnavailable) return
+        var entry = root.entries[index]
+        if (!entry) return
+        if (entry.error) { root.picker.say(entry.error, true); return }
+        root.awaitingNetwork = false
+        // The three groups below the places, routed the way ui/Sidebar.qml routes them.
+        if (entry.group === "device" && entry.kind === "phone") {
+            root.awaitingNetwork = true
+            network.openShare(entry.uri, entry.mounted, entry.label)
+            return
+        }
+        if (entry.group === "device") {
+            // The row this dialog is waiting on, by device: any other mount's open is not its answer.
+            root.awaitingDevice = entry.device
+            devices.activate(index - root.placeEntries.length - network.entries.length)
+            return
+        }
+        if (entry.group === "network") {
+            root.awaitingNetwork = true
+            network.activate(index - root.placeEntries.length)
+            return
+        }
+        if (entry.path.indexOf("file://") === 0) {
+            try {
+                var path = decodeURIComponent(entry.path.substring(7))
+                if (path.charAt(0) !== "/" || path.indexOf("\0") >= 0) throw new Error("not a local file URI")
+                root.chosen(path)
+            } catch (error) { root.picker.say("This favorite points to a location Flea cannot open.", true) }
+        } else if (entry.path.indexOf("://") >= 0) {
+            root.awaitingNetwork = true
+            network.openShare(entry.path, false, entry.label, false)
+        } else root.chosen(entry.path)
+    }
+    // Only the row the dialog asked for answers it, which the device says and a path alone cannot.
+    function deviceOpened(path) {
+        var awaited = root.awaitingDevice
+        if (awaited.length === 0) return
+        for (var i = 0; i < devices.entries.length; i++) {
+            if (devices.entries[i].device === awaited && devices.entries[i].path === path) {
+                root.awaitingDevice = ""
+                root.chosen(path)
+                return
+            }
+        }
+    }
+
+    function openChild(uri, label) { network.openChildShare(uri, label) }
+    function retry(requestId, uri, label, password) { root.awaitingNetwork = true; network.saveLocation(uri, label, password, requestId) }
+    function cancelNetwork(requestId) {
+        root.awaitingNetwork = false
+        network.cancelLocation(requestId)
+    }
+    Connections {
+        target: root.picker
+        function onPathChanged() { root.awaitingNetwork = false; root.awaitingDevice = "" }
+        function onBackendUnavailableChanged() {
+            if (root.picker.backendUnavailable) { root.awaitingNetwork = false; root.awaitingDevice = "" }
+        }
+    }
+    function controls() {
+        var out = []
+        for (var i = 0; i < rail.count; i++) {
+            var item = rail.itemAtIndex(i)
+            if (item) out.push(root.picker.control(root.entries[i].label, item, !root.entries[i].error && !root.picker.submitting && !root.picker.backendUnavailable))
+        }
+        return out
+    }
+    // Standing, not loaded on demand: its own listing is what the NETWORK rows are, and the window
+    // pays the same five-second rhythm for them.
+    Flea.NetworkMounts {
+        id: network
+        savedFavourites: Flea.Favourites.records
+        onCompleted: function(requestId, uri, success, reason, connectFailed) { root.networkCompleted(requestId, uri, success, reason, connectFailed) }
+        onOpened: function(path) { if (root.awaitingNetwork) root.chosen(path) }
+        // A FUSE path that is a file: the chooser selects it, the way a favourite file resolves.
+        onOpenFileRequested: function(path) { if (root.awaitingNetwork) root.chosen(path) }
+        onMessage: function(text, error) { root.picker.say(text, error) }
+        onRetryRequested: function(uri, label, password, reason, failed) {
+            if (root.awaitingNetwork) root.picker.retryNetwork(uri, label, password, reason, failed)
+        }
+        onSharesListed: function(uri, label, names) {
+            if (root.awaitingNetwork) root.picker.showShares(uri, label, names)
+        }
+    }
+
+    Flea.DeviceMounts {
+        id: devices
+        onOpened: function (path) { root.deviceOpened(path) }
+        // A message carries no device, so it cannot end a wait: only the awaited device's own open does.
+        onMessage: function (text, error) { root.picker.say(text, error) }
+        // The picker's one-line message has no detail view, so the headline stands alone.
+        onOperationResult: function (headline, detail, error) { root.picker.say(headline, error) }
+    }
+
+    // The phone rows the window draws, read off the same gio listing; their mount is the share leg.
+    Flea.PhoneMounts {
+        id: phones
+        listingText: network.mountListing
+        onMessage: function (text, error) { root.picker.say(text, error) }
+    }
+}

package/ui/PickerRecent.qml

@@ -0,0 +1,92 @@
+import Quickshell
+import Quickshell.Io
+import QtQuick
+import QtQml.XmlListModel
+import "js/Format.js" as Format
+import "js/Recent.js" as Recent
+
+// The desktop's own recent history, read and never written. Qt's XML reader does the parsing, so
+// this file has no parser of its own: XmlListModel is QXmlStreamReader behind a query, and a
+// history Flea hand-parsed would be a second XBEL implementation on a file it does not own.
+// The read is lazy, so a picker whose user never asks for Recent never opens the file at all.
+QtObject {
+    id: root
+
+    // The validated absolute paths, newest first; empty until refresh() has been asked for.
+    property var paths: []
+    property var visits: ({})
+    signal refreshed()
+
+    readonly property string file: Recent.historyPath(Quickshell.env("XDG_DATA_HOME"), Quickshell.env("HOME"))
+    function joinRequesters(current, requester) { return Recent.joinRequesters(current, requester) }
+
+    // Asked for when the Recent location is opened, so the file is re-read rather than remembered:
+    // every other application on the box appends to it while this window is up.
+    function refresh() {
+        if (historyFile.path === root.file) historyFile.reload()
+        else historyFile.path = root.file
+    }
+
+    // Read first so only an absent file is quiet: XmlListModel warns on one, and a fresh account has none.
+    property FileView historyFile: FileView {
+        printErrors: false
+        onLoaded: root.parse()
+        onLoadFailed: function (error) {
+            if (error !== FileViewError.FileNotFound)
+                console.warn("PickerRecent: could not read " + root.file + ": " + error)
+            root.paths = []
+            root.visits = ({})
+            root.refreshed()
+        }
+    }
+
+    // The model re-reads what the check just read, so a present history is a second read from the page cache.
+    function parse() {
+        var url = Format.fileUri(root.file)
+        if (history.source.toString() === url) history.reload()
+        else history.source = url
+    }
+
+    property XmlListModel historyModel: XmlListModel {
+        id: history
+        query: "/xbel/bookmark"
+        // Never on the construction-time Null: that answered refreshed with no rows, and the path jump takes the first answer.
+        onStatusChanged: if (status === XmlListModel.Ready || status === XmlListModel.Error) root.rebuild()
+        XmlListModelRole { name: "href"; attributeName: "href" }
+        XmlListModelRole { name: "visited"; attributeName: "visited" }
+        XmlListModelRole { name: "modified"; attributeName: "modified" }
+        XmlListModelRole { name: "added"; attributeName: "added" }
+    }
+
+    // Qt 6 gives XmlListModel no get(), so the rows are read off the model itself: data() is
+    // invokable and the roles are numbered from Qt.UserRole in the order declared above.
+    readonly property int hrefRole: Qt.UserRole
+    readonly property int visitedRole: Qt.UserRole + 1
+    readonly property int modifiedRole: Qt.UserRole + 2
+    readonly property int addedRole: Qt.UserRole + 3
+
+    // Every bookmark is read, because ui/js/Recent.js LIMIT bounds the rail and not the read: XBEL
+    // promises no order, so a bound in file order hands the sort an arbitrary slice and lists the
+    // newest of that. Measured on oldest-first fixtures, six batches whole against two capped: a
+    // rebuild costs about 3 ms at 500 bookmarks whichever way, tens of ms against 3 at 5,000, and
+    // hundreds of ms against 4 at 50,000, over an XmlListModel parse both pay that is itself a
+    // sixth of a second there. The Instantiator this replaced cost seconds at 50,000.
+    function rebuild() {
+        var found = []
+        var wanted = history.count
+        for (var i = 0; i < wanted; i++) {
+            var at = history.index(i, 0)
+            // visited is when the file itself was last opened, which is what Recent means; the
+            // other two stamp the bookmark and stand in for a writer that left visited out.
+            var visited = String(history.data(at, root.visitedRole) || "")
+            var modified = String(history.data(at, root.modifiedRole) || "")
+            var added = String(history.data(at, root.addedRole) || "")
+            found.push({ href: String(history.data(at, root.hrefRole) || ""),
+                         stamp: visited.length > 0 ? visited : (modified.length > 0 ? modified : added) })
+        }
+        var entries = Recent.entries(found)
+        root.visits = Recent.visits(entries)
+        root.paths = entries.map(function (entry) { return entry.path })
+        root.refreshed()
+    }
+}

package/ui/PickerSave.qml

@@ -0,0 +1,101 @@
+import QtQuick
+import "." as Flea
+import "js/Format.js" as Format
+import "js/Picker.js" as Picker
+
+// The save area: Filename and its field in one column, and under it the collision review's error line.
+Item {
+    id: root
+    required property var picker
+    property Item keyTarget: null
+    // Only keys left unhandled by Filename reach the listing, after editing and the field's Tab walk.
+    Keys.forwardTo: root.keyTarget ? [root.keyTarget] : []
+    signal nameEdited(string text)
+    signal accepted()
+    readonly property alias fieldItem: field
+    readonly property alias scrollItem: body
+    readonly property alias statusItem: statusLine
+    readonly property string askedName: root.picker.saveName || root.picker.req.name
+    readonly property bool refused: root.askedName.length > 0 && !Picker.validName(root.askedName)
+    visible: root.picker.saving
+    property real maximumHeight: parent.height
+    // The answer row below is the column's last row and brings the gap under the field; the column keeps only its top padding.
+    implicitHeight: visible ? Math.min(maximumHeight, body.wanted + Theme.spacing.rowPaddingX) : 0
+
+    Rectangle { anchors.fill: parent; color: Theme.color.surface }
+    Rectangle {
+        width: parent.width
+        height: Theme.spacing.hairline
+        color: root.picker.edge
+    }
+    Flea.CardScroll {
+        id: body
+        bleed: Theme.focusClearance
+        anchors.fill: parent
+        anchors.margins: Theme.spacing.rowPaddingX - Theme.focusClearance
+        anchors.bottomMargin: -Theme.focusClearance
+        Column {
+            id: column
+            width: parent.width
+            spacing: Theme.spacing.gap
+
+            Text {
+                text: "Filename"
+                textFormat: Text.PlainText
+                color: Theme.color.foreground
+                font { family: Theme.font.family; pixelSize: Theme.font.caption }
+            }
+            Rectangle {
+                width: parent.width
+                height: Math.max(Theme.hitMin, Theme.rowHeight - Theme.spacing.rowPaddingY)
+                color: Theme.color.background
+                border.width: Theme.spacing.hairline
+                // Muted at rest, accent on focus: the frame DialogField, MenuActionDialog, OpenWithDialog and PermissionsDialog draw.
+                border.color: field.activeFocus ? Theme.color.accent : Theme.color.mutedFrame
+                TextInput {
+                    id: field
+                    anchors.fill: parent
+                    anchors.leftMargin: Theme.spacing.gap
+                    anchors.rightMargin: Theme.spacing.gap
+                    verticalAlignment: TextInput.AlignVCenter
+                    text: root.picker.saveName
+                    color: Theme.color.foreground
+                    selectionColor: Theme.color.accent
+                    selectedTextColor: Theme.color.background
+                    font { family: Theme.font.family; pixelSize: Theme.font.body }
+                    clip: true
+                    activeFocusOnTab: true
+                    enabled: !root.picker.submitting
+                    Accessible.name: "Filename"
+                    onTextEdited: root.nameEdited(text)
+                    onAccepted: root.accepted()
+                    // Enter remains the field's save action when it opens a collision review.
+                    Keys.onReturnPressed: root.accepted()
+                    Keys.onEnterPressed: root.accepted()
+                    Keys.onTabPressed: function(event) { root.picker.stepFocus(field, (event.modifiers & Qt.ShiftModifier) !== 0) }
+                    Keys.onBacktabPressed: root.picker.stepFocus(field, true)
+                }
+            }
+            Text {
+                id: statusLine
+                width: parent.width
+                visible: text.length > 0
+                text: root.refused ? Format.fill(Picker.SAVE_REFUSED, root.askedName, Picker.NAME_REFUSED)
+                    : root.picker.saveError || (root.picker.collisionReview ? Picker.collisionLine(Picker.jointName(root.picker.saveName)) : "")
+                textFormat: Text.PlainText
+                wrapMode: Text.Wrap
+                color: Theme.color.errorOnSurface
+                font { family: Theme.font.family; pixelSize: Theme.font.caption }
+            }
+        }
+    }
+    // The review returns the keyboard to the field with the stem selected and the caret at its end.
+    function selectStem() {
+        field.forceActiveFocus(Qt.TabFocusReason)
+        field.select(0, Picker.stemEnd(field.text))
+    }
+    function focusItems() { return root.visible ? [field] : [] }
+    function controls() {
+        return root.focusItems().map(function(item) { return root.picker.control("Filename", item, item.enabled) })
+    }
+}