flea-qml 0.0.0-stage → 0.2.0

package/ui/PaneMenuActions.qml

@@ -0,0 +1,527 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "." as Flea
+import "js/LocalSend.js" as LocalSendJs
+import "js/CopyAs.js" as CopyAs
+import "js/Archive.js" as Archive
+import "js/Menu.js" as Menu
+import "js/Format.js" as Format
+import "js/Ops.js" as Ops
+import "js/Search.js" as Search
+
+Loader {
+    id: root
+    required property var pane
+
+    // Directive 71: the only thing that knows about LocalSend, the way ui/Taildrop.qml is for the
+    // other one. The work is the backend's, which drives localsend-cli on a pty of its own.
+    readonly property alias localSend: localSend
+
+    Flea.LocalSend {
+        id: localSend
+        backend: root.pane.backend
+    }
+
+    Connections {
+        target: root.pane.backend
+        function onLocalSendPeers(peers, reason) {
+            localSend.answered(peers, reason)
+            root.pane.contextMenu().refreshProviderRows()
+        }
+        function onLocalSendSent(ok, reason) { root.pane.message(LocalSendJs.verdict(ok, reason), !ok) }
+    }
+
+    // A menu opened without a selection carries no paths, so a row action means the row under the
+    // cursor, joined against the listing's base: on a search the scope or the folder, never the pane's path.
+    function targets(paths) {
+        if (paths && paths.length) return paths
+        return root.pane.cursorRow ? [root.pane.join(Search.baseOf(root.pane), root.pane.cursorRow.n)] : []
+    }
+
+    // Actions rule 1: every shelf action is a `flea shelf` call, so the menu row makes the same one
+    // a drop onto the card makes and nothing here knows the pile's shape.
+    function shelve(paths) {
+        if (paths.length === 0) { root.pane.message("There is nothing to put on the shelf.", true); return }
+        if (shelver.running) {
+            // A second add while one runs waits its turn, so each exit reports its own count.
+            shelver.pendingAdds = shelver.pendingAdds.concat([paths])
+            return
+        }
+        shelver.startAdd(paths)
+    }
+
+    Process {
+        id: shelver
+        property int count: 0
+        property var pendingAdds: []
+        stderr: StdioCollector { waitForEnd: true }
+        function startAdd(paths) {
+            shelver.count = paths.length
+            shelver.command = [Quickshell.env("FLEA_BIN") || "flea", "shelf", "add"].concat(paths)
+            shelver.running = true
+        }
+        onExited: function (code, status) {
+            if (code === 0) {
+                root.pane.message(shelver.count === 1 ? Ops.WORDS.shelfOne
+                                                      : Format.fill(Ops.WORDS.shelfMany, shelver.count), false)
+            } else {
+                var said = shelver.stderr.text.trim().split("\n").pop().replace(/^flea: /, "")
+                root.pane.message(said.length > 0 ? said : "The shelf did not take that.", true)
+            }
+            if (shelver.pendingAdds.length > 0) {
+                var next = shelver.pendingAdds[0]
+                shelver.pendingAdds = shelver.pendingAdds.slice(1)
+                shelver.startAdd(next)
+            }
+        }
+    }
+
+    // Copy as covers the whole selection, one path per line, as plain text; the leaves read the snapshot, whose paths a window cannot hold.
+    property var copyKinds: ({ copyPath: "path", copyName: "name", copyStem: "stem",
+        copydirpath: "dirpath", copyUri: "uri", copyQuoted: "quoted" })
+    function copyVariant(action, paths) {
+        var leaf = action.indexOf("copyAs:") === 0 ? action.substring("copyAs:".length) : action
+        var kind = copyKinds[leaf]
+        if (kind === undefined) return false
+        var taken = root.targets(paths)
+        if (taken.length === 0) return true
+        root.pane.opener.copyText(CopyAs.lines(taken, kind))
+        return true
+    }
+
+    function perform(action, menuId, paths) {
+        if (action.indexOf("runScript:") === 0) { Flea.Scripts.run(action.substring("runScript:".length), paths || []); return }
+        if (action.indexOf("localsend:") === 0) { LocalSendJs.send(root.pane, localSend, root.pane.backend.providers.localsend, action.substring("localsend:".length), root.targets(paths)); return }
+        if (action.indexOf("taildrop:") === 0) { root.pane.sendTaildrop(action.substring("taildrop:".length), root.targets(paths).length === 1 ? root.targets(paths)[0] : ""); return }
+        if (action === "addToShelf") { root.shelve(root.targets(paths)); return }
+        if (action === "sharelink") { root.pane.copyShareLink(paths && paths.length === 1 ? paths[0] : ""); return }
+        // The Places and Locked menus still send the Copy path alias.
+        if (action === "copypath") { root.pane.opener.copyText(paths && paths.length ? paths[0] : root.pane.join(Search.baseOf(root.pane), root.pane.cursorRow.n)); return }
+        if (copyVariant(action, paths)) return
+        // Show original reveals the link target in its own folder.
+        if (action === "showOriginal") {
+            var taken = root.targets(paths)
+            if (taken.length > 0) root.pane.requestLinkTarget(taken[0])
+            return
+        }
+        // Paste as links through the collision card; the source is the file clipboard, never the menu snapshot.
+        if (action.indexOf("pasteAs:") === 0) {
+            var leaf = action.substring("pasteAs:".length)
+            var kind = leaf === "pasteAbsoluteLink" ? "absolute" : leaf === "pasteHardLink" ? "hard" : "relative"
+            root.pane.pasteLink(kind, null)
+            return
+        }
+        if (action === "invertSelection") { root.pane.invertSelection(); return }
+        if (action.indexOf("col:") === 0) { ViewState.toggleColumn(action.substring("col:".length)); return }
+        root.pane.act(action, menuId, paths)
+    }
+    // A script's own non-zero exit is its last stderr line, said once in the status centre.
+    Connections {
+        target: Flea.Scripts
+        function onSaid(text, isError) { root.pane.message(text, isError) }
+    }
+    anchors.fill: parent
+    z: 2
+    active: false
+    // OpenWith.html rule 4: Open with owns its own card, so the shared dialog is not asked to be one.
+    property string dialogFor: ""
+    source: root.dialogFor === "openWith" ? "OpenWithDialog.qml" : "MenuActionDialog.qml"
+    readonly property bool opened: item !== null && item.opened
+    readonly property bool deleting: item !== null && item.deletionActive
+    property int requestId: 0
+    property string identity: ""
+    property string folder: ""
+    property bool ready: false
+    property var selectedKinds: []
+    property string pendingAction: ""
+    property bool pendingActivation: false
+    // Tag toggles chosen while the first still awaits its snapshot, kept in press order; any other pending action drops them.
+    property var queuedTags: []
+    // A tag activate sent and not yet answered; the backend's menu slot holds one job, so the next queued tag waits for this reply.
+    property bool tagInFlight: false
+    property bool activationUsed: false
+    // The request a keymap sheet activation runs under, which lists hidden rows; the next snapshot moves requestId past it.
+    property int sheetRequest: 0
+    // Which row a keyboard rename was asked for, so its reply cannot open the editor over another.
+    property int pendingRenameIndex: -1
+    // The pointer rename's own reveal context beside it, so a slow click never scrolls; false keeps the keyboard's.
+    property bool pendingRenameStill: false
+    property int launchingId: 0
+    // OpenWith.html's flyout: the registry for the cursor row, asked for as the menu opens so the
+    // submenu is populated by the time the row is reached. The flyout writes nothing; the dialog
+    // stays the only place a default is written, which is Douglas de Moura's architecture kept whole.
+    property var openWithApps: []
+    property bool openWithLoaded: false
+    property var survivors: []
+    property int survivorId: 0
+    property string survivorFolder: ""
+    property string survivorListing: ""
+    property string backgroundFolder: ""
+    property bool providersRefreshing: false
+    property int providerFormatsId: 0
+    property bool providerQueriesStarted: false
+    property bool providerDestinationPending: false
+    property bool providerValidated: false
+    property var providerFacts: ({})
+    property bool taildropRefreshWaiting: false
+    property bool dropboxRefreshWaiting: false
+    property bool refreshingTaildrop: false
+    property bool refreshingDropbox: false
+
+    function providerAction(action) {
+        return action.indexOf("taildrop:") === 0 || action === "dropbox" || action === "sharelink"
+    }
+    function refreshProviders(action) {
+        providersRefreshing = true
+        refreshingTaildrop = !action || action.indexOf("taildrop:") === 0
+        refreshingDropbox = !action || action === "dropbox" || action === "sharelink"
+        providerQueriesStarted = false
+        providerDestinationPending = false
+        taildropRefreshWaiting = false
+        dropboxRefreshWaiting = false
+        providerFormatsId = pane.backend.askFormats()
+        pane.contextMenu().refreshProviderRows()
+    }
+    function finishProviders() {
+        if (!providersRefreshing || !providerQueriesStarted || providerDestinationPending || !ready
+                || taildropRefreshWaiting || dropboxRefreshWaiting
+                || (refreshingTaildrop && pane.taildropService.checking)
+                || (refreshingDropbox && pane.dropboxService && pane.dropboxService.dropboxChecking)) return
+        if (!pendingActivation && pane.dropboxService && pane.dropboxService.dropboxReady) {
+            providerDestinationPending = true
+            pane.backend.send({c: "menuaction", op: "providerDestination", id: requestId, dest: pane.dropboxService.dropboxPath})
+            return
+        }
+        providersFinished()
+    }
+    function providersFinished() {
+        providersRefreshing = false
+        pane.contextMenu().providersSettled()
+        if (pendingActivation && providerAction(pendingAction)) {
+            providerValidated = true
+            validateActivation()
+        }
+    }
+
+    // rows, when the caller has one: a keyboard rename acts on the cursor, and Ops.targetIndices
+    // answers with the selection whenever there is one, so the snapshot covered rows the rename was
+    // never going to touch and the backend refused the cursor's own path as "not in the selection".
+    function snapshot(rows) {
+        if (deleting || survivorId) return
+        requestId++
+        ready = false
+        selectedKinds = []
+        pendingAction = ""
+        pendingActivation = false
+        queuedTags = []
+        tagInFlight = false
+        activationUsed = false
+        identity = pane.menuSelectionIdentity()
+        folder = pane.path
+        // The registry belongs to the row that was snapshotted. Carrying the last row's answer over
+        // offered one file's applications for another, and kept the self-hide rule from ever firing.
+        openWithApps = []
+        openWithLoaded = false
+        pane.backend.send({c: "menuaction", op: "snapshot", id: requestId,
+            rows: rows !== undefined ? rows : Ops.targetIndices(pane), cursor: pane.cursorIndex})
+    }
+    // A ready snapshot over the same selection opens the editor at once, one still in flight takes the F2 route, and a moved selection refuses as activate does.
+    function openRenameFromMenu() {
+        if (pane.renamePending) { pane.message("Rename is still finishing.", false); return }
+        if (deleting || survivorId) { pane.message("The deletion is still finishing.", false); return }
+        var route = Ops.menuRenameRoute(ready, identity, pane.menuSelectionIdentity())
+        if (route === "stale") { pane.message("Selected items changed; reopen the menu.", true); return }
+        if (route === "now" && pane.contextMenu().validateChoice("rename", "")) {
+            show("rename")
+            return
+        }
+        open("rename")
+    }
+    function open(action, menuId, context) {
+        if (opened) return
+        if (action === "rename" && pane.renamePending) { pane.message("Rename is still finishing.", false); return }
+        if (deleting || survivorId) { pane.message("The deletion is still finishing.", false); return }
+        if (action === "newFile") {
+            requestId++
+            folder = pane.path
+            show(action)
+            return
+        }
+        // The row the editor will open over, captured now: the cursor can move between this request
+        // and its reply, and the editor used to open over wherever it had got to by then.
+        if (action === "rename" && !menuId) {
+            pendingRenameIndex = pane.cursorIndex
+            pendingRenameStill = context === 0
+        }
+        if (!requestId || identity !== pane.menuSelectionIdentity() || (action === "rename" && !menuId))
+            snapshot(action === "rename" && !menuId ? [pane.cursorIndex] : undefined)
+        pendingAction = action
+        pendingActivation = false
+        if (ready) show(action)
+    }
+    function activate(action, selected) {
+        // Flash to drive re-reads what the menu showed: the snapshot already proved the selection names it.
+        if (action === "flashDrive") {
+            var flashIdx = Ops.targetIndices(pane)
+            var flashRow = flashIdx.length === 1 ? pane.rowFor(flashIdx[0]) : null
+            if (!requestId || identity !== pane.menuSelectionIdentity() || !flashRow
+                    || !Archive.isDiskImage(flashRow.n, pane.flashZipMember)) {
+                pane.message("Selected items changed; reopen the menu.", true)
+                return
+            }
+            activationUsed = true
+            pane.openFlashImage(pane.join(Search.baseOf(pane), flashRow.n))
+            return
+        }
+        if (!selected) {
+            if (action === "addFavourite") {
+                if (backgroundFolder !== pane.path) { pane.message("Folder changed; reopen the menu.", true); return }
+                addFavourite(backgroundFolder)
+            } else pane.performMenu(action, 0, null)
+            return
+        }
+        if (activationUsed) return
+        if (deleting || survivorId) { pane.message("The deletion is still finishing.", false); return }
+        if (!requestId || identity !== pane.menuSelectionIdentity()) {
+            pane.message("Selected items changed; reopen the menu.", true)
+            return
+        }
+        // A tag toggle repeats inside one open menu; every other choice closes it, so one activation is all it gets.
+        if (action.indexOf("tags:") === 0 && (tagInFlight || (pendingActivation && pendingAction.indexOf("tags:") === 0))) {
+            queuedTags = queuedTags.concat([action])
+            return
+        }
+        queuedTags = []
+        activationUsed = action.indexOf("tags:") !== 0
+        providerValidated = false
+        pendingAction = action
+        pendingActivation = true
+        if (ready) validateActivation()
+    }
+    function validateActivation() {
+        if (providerAction(pendingAction) && !providerValidated) { refreshProviders(pendingAction); return }
+        var action = pendingAction
+        pendingAction = ""
+        pendingActivation = false
+        var split = action.indexOf(":")
+        if (providerAction(action) && !pane.contextMenu().validateChoice(split < 0 ? action : action.substring(0, split),
+                split < 0 ? "" : action.substring(split + 1), sheetRequest === requestId)) return
+        // OpenWith.html rule 2: the flyout is a one-off override that writes nothing, so a chosen
+        // application launches through the same registry op the dialog submits, and the tail row is
+        // the only way into the dialog, which stays the one place a default is written.
+        if (action.indexOf("openWith:") === 0) {
+            var chosen = action.substring("openWith:".length)
+            if (chosen === Menu.OPEN_WITH_OTHER) { root.show("openWith"); return }
+            root.launchingId = requestId
+            pane.backend.send({c: "menuaction", op: "openWith", id: requestId, application: chosen})
+            return
+        }
+        pane.backend.send({c: "menuaction", op: "activate", id: requestId, action: action,
+            dest: pane.dropboxService ? pane.dropboxService.dropboxPath : ""})
+        tagInFlight = action.indexOf("tags:") === 0
+    }
+    // The answer to a tag activate frees the menu slot, so the next queued tag goes out now.
+    function sendNextTag() {
+        tagInFlight = false
+        if (queuedTags.length === 0) return
+        pendingAction = queuedTags[0]
+        queuedTags = queuedTags.slice(1)
+        pendingActivation = true
+        validateActivation()
+    }
+    function show(action) {
+        pendingAction = ""
+        if (action === "rename") {
+            Ops.startRename(pane, requestId, pendingRenameIndex, pendingRenameStill ? 0 : undefined)
+            pendingRenameIndex = -1
+            pendingRenameStill = false
+            return
+        }
+        dialogFor = action
+        active = true
+        item.open(action, requestId, folder, pane.listArea)
+    }
+    function addFavourite(path) {
+        Favourites.add(path, path.split("/").filter(function (part) { return part.length > 0 }).pop() || "/")
+    }
+    function locateSurvivors() {
+        if (!survivorId || pane.listInFlight) return
+        if (pane.path !== survivorFolder) { survivorId = 0; survivors = []; return }
+        survivorListing = pane.menuSelectionIdentity()
+        pane.backend.send({c: "locate", paths: survivors, id: survivorId, menuId: survivorId})
+    }
+    Connections {
+        target: root.pane.contextMenu()
+        function onOpenedChanged() {
+            var menu = root.pane.contextMenu()
+            if (menu.opened && !menu.hasRow && !menu.forRail && !menu.forHeader)
+                root.backgroundFolder = root.pane.path
+            if (menu.opened && menu.hasRow && !menu.forRail && !menu.forHeader) root.refreshProviders()
+        }
+    }
+    Connections {
+        target: root.pane.taildropService
+        function onRefreshed() {
+            if (root.providersRefreshing && root.taildropRefreshWaiting) root.taildropRefreshWaiting = !root.pane.taildropService.refresh(root.providerFacts)
+            root.finishProviders()
+        }
+    }
+    Connections {
+        target: root.pane.dropboxService
+        function onDropboxRefreshed() {
+            if (root.providersRefreshing && root.dropboxRefreshWaiting) root.dropboxRefreshWaiting = !root.pane.dropboxService.refreshDropbox(root.providerFacts)
+            root.finishProviders()
+        }
+    }
+    Connections {
+        target: root.pane
+        function onListInFlightChanged() { if (!root.pane.listInFlight) root.locateSurvivors() }
+    }
+    Connections {
+        target: root.pane.backend
+        function onFormatsResult(message) {
+            if (!root.providersRefreshing || message.id !== root.providerFormatsId) return
+            root.providerFacts = message.providers || {}
+            root.taildropRefreshWaiting = root.refreshingTaildrop && !root.pane.taildropService.refresh(root.providerFacts)
+            root.dropboxRefreshWaiting = root.refreshingDropbox && root.pane.dropboxService
+                ? !root.pane.dropboxService.refreshDropbox(root.providerFacts) : false
+            root.providerQueriesStarted = true
+            root.localSend.refresh((root.providerFacts.localsend || {}).installed === true)
+            root.finishProviders()
+        }
+        function onChanged(path) { if (path === root.folder && root.item) root.item.sourceChanged() }
+        function onLocated(message) {
+            if (!root.survivorId || message.id !== root.survivorId) return
+            root.survivorId = 0
+            root.survivors = []
+            if (message.directory !== root.pane.path || root.pane.path !== root.survivorFolder
+                    || root.survivorListing !== root.pane.menuSelectionIdentity()) return
+            if (!message.ok) { root.pane.message(message.error, true); return }
+            var matches = message.matches || []
+            root.pane.selection.clear()
+            for (var i = 0; i < matches.length; i++) root.pane.selection.toggle(matches[i].index)
+            root.pane.selectionVersion++
+            if (matches.length) root.pane.setCursor(matches[0].index)
+        }
+        function onMenuResult(message) {
+            if (message.op === "openWith" && message.id === root.launchingId) {
+                root.launchingId = 0
+                if (!root.opened || message.id !== root.requestId) {
+                    if (!message.ok && !message.cancelled) root.pane.message(message.error || "The application could not be opened.", true)
+                    return
+                }
+            }
+            if (message.id !== root.requestId) return
+            if (message.op === "applications") {
+                // Both readers want it: the flyout's registry, and an open dialog that asked for it.
+                if (root.item) root.item.receive(message)
+                root.openWithApps = message.applications || []
+                root.openWithLoaded = true
+                root.pane.contextMenu().refreshProviderRows()
+                return
+            }
+            if (message.op === "providerDestination") {
+                root.providerDestinationPending = false
+                if (!message.ok && root.pane.dropboxService) {
+                    root.pane.dropboxService.dropboxReason = message.error
+                    root.pane.dropboxService.dropboxCode = ""
+                }
+                root.providersFinished()
+                return
+            }
+            if (message.op === "snapshot") {
+                root.selectedKinds = message.kinds || []
+                root.ready = message.ok === true && root.identity === root.pane.menuSelectionIdentity()
+                if (!root.ready) {
+                    // A late snapshot answers no dismissed menu with nothing awaiting it; an open one keeps its refusal.
+                    var retired = message.ok === true && !root.pane.contextMenu().opened && !root.opened
+                            && !root.pendingAction && !root.pendingActivation
+                    root.pendingAction = ""
+                    root.pendingActivation = false
+                    root.queuedTags = []
+                    root.tagInFlight = false
+                    root.providersRefreshing = false
+                    root.identity = ""
+                    if (!retired)
+                        root.pane.message(message.error || "Selected items changed; reopen the menu.", true)
+                } else if (root.pendingAction) {
+                    if (root.pendingActivation) root.validateActivation()
+                    else root.show(root.pendingAction)
+                }
+                // Multi-selection has no registry: the backend refuses it, so discovery stays single-item.
+                if (root.ready && message.count === 1 && root.pane.contextMenu().opened && root.pane.contextMenu().hasRow)
+                    // No installed flag: the flyout draws the registry alone, and asking for the
+                    // whole catalogue here walked every applications directory on every right-click.
+                    root.pane.backend.send({c: "menuaction", op: "applications", id: root.requestId})
+                root.pane.contextMenu().refreshProviderRows()
+                root.finishProviders()
+                return
+            }
+            if (message.op === "activate") {
+                if (!message.ok || root.identity !== root.pane.menuSelectionIdentity()) {
+                    root.queuedTags = []
+                    root.tagInFlight = false
+                    root.pane.message(message.error || "Selected items changed; reopen the menu.", true)
+                    return
+                }
+                var split = message.action.indexOf(":")
+                var action = split < 0 ? message.action : message.action.substring(0, split)
+                var subId = split < 0 ? "" : message.action.substring(split + 1)
+                if (root.pane.contextMenu().validateChoice(action, subId, root.sheetRequest === message.id)) {
+                    if (action === "addFavourite") {
+                        if (!message.paths || message.paths.length !== 1) { root.pane.message("The selected folder could not be read.", true); return }
+                        root.addFavourite(message.paths[0])
+                    } else root.pane.performMenu(message.action, message.id, message.paths)
+                }
+                if (action === "tags") root.sendNextTag()
+                return
+            }
+            if (root.item) root.item.receive(message)
+        }
+        function onFailed(where, input, message, mode) {
+            if (where !== "backend") return
+            root.survivorId = 0
+            root.survivors = []
+            root.ready = false
+            root.identity = ""
+            root.pendingAction = ""
+            root.pendingActivation = false
+            root.queuedTags = []
+            root.tagInFlight = false
+            root.providersRefreshing = false
+            if (root.opened || root.deleting) root.item.receive({id: root.requestId, op: root.deleting ? "delete" : "", ok: false, error: message})
+        }
+    }
+    Connections {
+        target: root.item
+        // Two dialogs load here and only one of them creates files or deletes them, so the handlers
+        // the other never raises are absent by design rather than misspelled.
+        ignoreUnknownSignals: true
+        function onRequested(message) {
+            if (message.op === "openWith") root.launchingId = message.id
+            root.pane.backend.send(message)
+        }
+        function onApproved(message) {
+            root.pane.asks().ask({c: "transfer", op: message.action === "moveTo" ? "move" : "copy",
+                menuId: message.id, dest: message.dest})
+        }
+        function onCreated(path) { root.pane.refresh(path); root.pane.message(Ops.createdLine(path), false) }
+        function onDeleted(message) {
+            var text = Ops.deletedLine(message)
+            root.pane.operationResult(text, message.error || "", message.failed > 0)
+            if (root.pane.path !== root.folder) return
+            root.survivors = message.remaining || []
+            root.survivorId = root.survivors.length ? message.id : 0
+            root.survivorFolder = root.folder
+            root.pane.refresh()
+        }
+        function onClosed() {
+            root.ready = false
+            root.identity = ""
+            // The close op kills the launcher this id was waiting on, so its error is the cancellation
+            // the user asked for and not something to raise at them.
+            root.launchingId = 0
+        }
+    }
+}

package/ui/PanePath.qml

@@ -0,0 +1,90 @@
+import QtQuick
+import "." as Flea
+import "js/Crumbs.js" as Crumbs
+
+// A dual pane's own path, drawn with the chrome's crumbs so issue 45's one tap on a parent reaches either pane.
+Rectangle {
+    id: root
+
+    property string path: ""
+    property string home: ""
+    property var pathAlias: null
+    property bool focused: false
+    // ui/ChromeBar.qml's inputLive: false while Quick Look covers the strip, so a press on it stays Quick Look's.
+    property bool inputLive: true
+    // Drops callout 4: the pane whose collide sends a drop on a crumb.
+    property var pane: null
+    readonly property alias crumbItems: crumbs
+    readonly property alias crumbSlot: slot
+
+    signal chosen(string path)
+    signal editRequested()
+
+    color: root.focused ? Glass.surface : Glass.background
+
+    // Where no crumb is, the strip keeps the one gesture it had before issue 45: a double click types the path.
+    component TypeArea: Item {
+        HoverHandler {
+            enabled: root.inputLive
+            cursorShape: Qt.IBeamCursor
+        }
+        TapHandler {
+            enabled: root.inputLive
+            acceptedButtons: Qt.LeftButton
+            onDoubleTapped: root.editRequested()
+        }
+    }
+
+    // One glyph's advance is every glyph's advance in this face, the same fit ui/ChromeBar.qml makes.
+    TextMetrics {
+        id: metrics
+        font.family: Theme.font.family
+        font.pixelSize: Theme.font.caption
+        text: "0"
+    }
+
+    Item {
+        id: slot
+        anchors.fill: parent
+        clip: true
+
+        Row {
+            id: row
+            x: Theme.spacing.rowPaddingX
+            height: slot.height
+
+            Repeater {
+                id: crumbs
+                // Empty while the strip is hidden, because the single view keeps it at height 0 and would rebuild its crumbs on every move.
+                model: root.visible
+                       ? Crumbs.fitCrumbs(Crumbs.crumbs(root.path, root.home, root.pathAlias),
+                                          Math.floor((slot.width - 2 * Theme.spacing.rowPaddingX) / metrics.advanceWidth))
+                       : []
+
+                delegate: Flea.Crumb {
+                    height: slot.height
+                    restColor: Theme.color.foreground
+                    inputLive: root.inputLive
+                    dropPane: root.pane
+                    onChosen: function (path) { root.chosen(path) }
+                    onEditRequested: root.editRequested()
+                }
+            }
+        }
+
+        TypeArea {
+            anchors { left: parent.left; top: parent.top; bottom: parent.bottom }
+            width: Theme.spacing.rowPaddingX
+        }
+
+        TypeArea {
+            anchors { left: row.right; right: parent.right; top: parent.top; bottom: parent.bottom }
+        }
+    }
+
+    Rectangle {
+        anchors { left: parent.left; right: parent.right; bottom: parent.bottom }
+        height: Theme.spacing.hairline
+        color: Theme.color.mutedFrame
+    }
+}