flea-qml 0.0.0-stage → 0.2.0

package/ui/FatNamesConfirm.qml

@@ -0,0 +1,157 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/Collide.js" as Collide
+import "js/Icons.js" as Icons
+
+// FAT-family names, on CollideConfirm's card, keys and look.
+FocusScope {
+    id: root
+    anchors.fill: parent
+    visible: opened || opacity > 0
+    // Closed means no input, even while the fade-out is still drawn.
+    enabled: opened
+    opacity: 0
+    property bool opened: false
+    property string titleText: ""
+    property var renames: []
+    property string noteText: ""
+    property string focusName: Collide.FAT_DEFAULT
+    // The card geometry lives in ui/js/Collide.js, shared with CollideConfirm.
+    readonly property real referenceScale: Collide.cardReferenceScale(Theme.font.bodySmall)
+    readonly property real cardPadding: Collide.cardPadding(referenceScale)
+    readonly property real cardBottomPadding: Theme.spacing.rowPaddingX
+    // The card grows with the labels rather than wrapping one, and Rename and copy keeps the ring.
+    readonly property real contentWidth: Collide.cardContentWidth(referenceScale, Theme.dialogWidthRatio, buttons.implicitWidth)
+    signal chosen(string choice)
+    readonly property var cardItem: card
+    readonly property bool buttonsFit: buttons.width <= body.holderWidth
+    function buttonItem(name) { return ({cancel: cancelButton, skip: skipButton, rename: renameButton})[name] || null }
+    function open(heading, list, note) {
+        titleText = heading
+        renames = list
+        noteText = note
+        focusName = Collide.FAT_DEFAULT
+        body.contentY = 0
+        opened = true
+        forceActiveFocus()
+    }
+    function choose(choice) {
+        opened = false
+        chosen(choice)
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    // A press lands on its own button first, so the accent never shows one choice while another is taken.
+    function press(choice) {
+        focusName = choice
+        choose(choice)
+    }
+    Keys.onPressed: function(event) {
+        if (event.key === Qt.Key_Escape) root.choose("cancel")
+        else if (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) { event.accepted = true; return }
+        else if (Collide.activates(event.key)) root.choose(root.focusName)
+        else root.focusName = Collide.walk(["cancel", "skip", "rename"], root.focusName, event.key, event.modifiers, "cancel")
+        if (root.opened) body.reveal(root.buttonItem(root.focusName))
+        event.accepted = true
+    }
+    Flea.DialogScrim {
+        onDismissed: root.choose("cancel")
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        width: Theme.cardSpan(root.contentWidth + 2 * root.cardPadding + 2 * Theme.spacing.hairline, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + root.cardPadding + root.cardBottomPadding + 2 * Theme.spacing.hairline, root.height - 2 * Theme.spacing.gap)
+        color: Theme.color.surface
+        border.color: Theme.color.mutedFrame
+        border.width: Theme.spacing.hairline
+        radius: Style.cornerRadius
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onWheel: function(wheel) { wheel.accepted = true }
+        }
+        Flea.CardFrame {
+            id: body
+            bleed: Theme.focusClearance
+            anchors.fill: parent
+            anchors.leftMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.rightMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.topMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.bottomMargin: root.cardBottomPadding + Theme.spacing.hairline - Theme.focusClearance
+            title: Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Flea.DialogTitle {
+                    width: parent.width
+                    text: root.titleText
+                }
+                Rectangle { width: parent.width; height: Theme.spacing.hairline; color: Theme.color.mutedFrame; opacity: 0.4 }
+            }
+            buttons: Row {
+                id: buttons
+                anchors.right: parent.right
+                spacing: Theme.spacing.gap
+                Flea.DialogButton { id: cancelButton; label: Collide.FAT_BUTTONS.cancel; focused: root.focusName === "cancel"; onActivated: root.press("cancel") }
+                Flea.DialogButton { id: skipButton; label: Collide.FAT_BUTTONS.skip; focused: root.focusName === "skip"; onActivated: root.press("skip") }
+                Flea.DialogButton { id: renameButton; label: Collide.FAT_BUTTONS.rename; primary: true; focused: root.focusName === "rename"; onActivated: root.press("rename") }
+            }
+            Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Column {
+                    width: parent.width
+                    Repeater {
+                        model: root.renames
+                        delegate: Row {
+                            id: nameRow
+                            required property var modelData
+                            // The label column: what is left of the row once the mark and its gap are taken.
+                            readonly property real labelWidth: Math.max(0, width - Theme.markSize - spacing)
+                            width: parent.width
+                            height: Theme.fileRowHeight
+                            spacing: Theme.spacing.gap
+                            Flea.Glyph { width: Theme.markSize; height: parent.height; name: nameRow.modelData.d ? "folder" : Icons.glyphFor(nameRow.modelData.i); color: Theme.color.foreground }
+                            Text {
+                                id: oldName
+                                width: Math.min(implicitWidth, Math.max(0, nameRow.labelWidth - arrow.implicitWidth))
+                                anchors.verticalCenter: parent.verticalCenter
+                                text: nameRow.modelData.old
+                                textFormat: Text.PlainText
+                                elide: Text.ElideRight
+                                color: Theme.color.muted
+                                font { family: Theme.font.family; pixelSize: Theme.font.body }
+                            }
+                            Text {
+                                id: arrow
+                                anchors.verticalCenter: parent.verticalCenter
+                                text: " → "
+                                color: Theme.color.foreground
+                                font { family: Theme.font.family; pixelSize: Theme.font.body }
+                            }
+                            Text {
+                                width: Math.max(0, nameRow.labelWidth - oldName.width - arrow.implicitWidth)
+                                anchors.verticalCenter: parent.verticalCenter
+                                text: nameRow.modelData.new
+                                textFormat: Text.PlainText
+                                elide: Text.ElideRight
+                                color: Theme.color.foreground
+                                font { family: Theme.font.family; pixelSize: Theme.font.body }
+                            }
+                        }
+                    }
+                }
+                Text {
+                    width: parent.width
+                    text: root.noteText
+                    textFormat: Text.PlainText
+                    wrapMode: Text.Wrap
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.caption }
+                }
+            }
+        }
+    }
+}

package/ui/Favourites.qml

@@ -0,0 +1,143 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/UiState.js" as UiState
+import "js/Startup.js" as Startup
+
+// All callers share one operation writer; the Rust updater locks and re-reads before editing.
+QtObject {
+    id: root
+    readonly property var records: ((ViewState.state.places || {}).favourites || [])
+    readonly property bool busy: writer.running
+    property bool operationActive: false
+    property int recordCount: 0
+    property var statuses: ({})
+    onRecordsChanged: {
+        var previousCount = root.recordCount
+        root.recordCount = root.records.length
+        root.statuses = ({})
+        if (!root.operationActive) root.externalChanged(previousCount)
+    }
+    property string lastError: ""
+    signal wrote()
+    signal failed(string message)
+    signal completed(string requestId, bool success, string message)
+    signal externalChanged(int previousCount)
+
+    function apply(operation, requestId) {
+        if (root.busy) { root.failed("A Favorites change is still being saved."); return false }
+        root.lastError = ""
+        writer.answer = ""
+        writer.errorText = ""
+        writer.requestId = requestId || ""
+        writer.beforeRecords = root.records
+        writer.expectedRecords = UiState.favouritesAfter(root.records, operation)
+        root.operationActive = true
+        writer.command = [Quickshell.env("FLEA_BIN") || "flea", "--favourites", JSON.stringify(operation)]
+        writer.pending = true
+        writer.running = true
+        return true
+    }
+    function add(path, label, requestId) {
+        return root.apply({ op: "add", record: { label: label, path: path } }, requestId)
+    }
+    function remove(index) {
+        return root.apply({ op: "remove", index: index, expected: root.records })
+    }
+    function move(index, to) {
+        return root.apply({ op: "move", index: index, to: to, expected: root.records })
+    }
+    function rename(index, label) {
+        return root.apply({ op: "rename", index: index, label: label, expected: root.records })
+    }
+    // One favourite on a dead mount must not hold the single-flight guard forever.
+    readonly property int inspectWaitMs: Startup.INSPECT_WAIT_MS
+    property var inspectTimeout: Timer {
+        interval: root.inspectWaitMs
+        onTriggered: inspector.running = false
+    }
+
+    function inspect(indices) {
+        var pending = indices.filter(function (index) { return root.statuses[index] === undefined })
+        if (pending.length === 0 || inspector.running) return
+        inspector.answer = ""
+        inspector.command = [Quickshell.env("FLEA_BIN") || "flea", "--favourites", JSON.stringify({ op: "inspect", indices: pending.slice(0, 128) })]
+        inspector.running = true
+        inspectTimeout.restart()
+    }
+    function finish(expected) {
+        var changed = JSON.stringify(root.records) !== JSON.stringify(expected)
+        root.operationActive = false
+        if (changed) root.externalChanged(writer.beforeRecords.length)
+    }
+    property var stateChanges: Connections {
+        target: ViewState
+        function onFavouritesReadFailed(message) { root.failed(message) }
+    }
+    property var inspection: Process {
+        id: inspector
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: inspector.answer = this.text }
+        onExited: function (code) {
+            inspectTimeout.stop()
+            if (code !== 0) return
+            try {
+                var rows = JSON.parse(inspector.answer).statuses
+                var next = Object.assign({}, root.statuses)
+                for (var i = 0; i < rows.length; i++) {
+                    if (JSON.stringify(root.records[rows[i].index]) === JSON.stringify(rows[i].record))
+                        next[rows[i].index] = rows[i].error
+                }
+                root.statuses = next
+            } catch (error) { root.failed("Flea could not check which favorites still exist.") }
+        }
+    }
+
+    property var process: Process {
+        id: writer
+        property string answer: ""
+        property string errorText: ""
+        property bool pending: false
+        property string requestId: ""
+        property var beforeRecords: []
+        property var expectedRecords: []
+        onStarted: writer.pending = false
+        onRunningChanged: {
+            if (!running && pending) {
+                pending = false
+                root.finish(writer.beforeRecords)
+                root.lastError = "Favorites could not be saved."
+                root.failed(root.lastError)
+                root.completed(writer.requestId, false, root.lastError)
+            }
+        }
+        stdout: StdioCollector { onStreamFinished: writer.answer = this.text }
+        stderr: StdioCollector { onStreamFinished: writer.errorText = this.text.trim() }
+        onExited: function (code) {
+            writer.pending = false
+            if (code !== 0) {
+                ViewState.refreshFavourites()
+                root.finish(writer.beforeRecords)
+                root.lastError = writer.errorText.replace(/^flea: /, "").split("\n")[0] || "Favorites could not be saved."
+                root.failed(root.lastError)
+                root.completed(writer.requestId, false, root.lastError)
+                return
+            }
+            try {
+                var state = JSON.parse(writer.answer)
+                if (!state.places || !Array.isArray(state.places.favourites)) throw new Error("missing favorites")
+                if (!ViewState.refreshFavourites()) throw new Error("saved favorites could not be read")
+                root.finish(writer.expectedRecords)
+                root.wrote()
+                root.completed(writer.requestId, true, "")
+            } catch (error) {
+                root.finish(writer.beforeRecords)
+                root.lastError = "Favorites were saved, but their new state could not be read."
+                root.failed(root.lastError)
+                // CLI exit zero means the write committed; a response error must never replay the add.
+                root.completed(writer.requestId, true, root.lastError)
+            }
+        }
+    }
+}

package/ui/FigureService.qml

@@ -0,0 +1,120 @@
+pragma Singleton
+
+import QtQuick
+
+// The block view's diagrams, drawn by the backend (src/figure.js, Pele in a Bun Worker) through a
+// window's Backend, which WindowBody adopts and releases. Answers come by ticket through `done`,
+// and recent ones are held here, so a revisit or a theme flip back asks nothing.
+QtObject {
+    id: root
+
+    signal done(int ticket, string svg, string error)
+
+    // Every open window's Backend, adopted as each window is built and released as it closes; the
+    // first still open draws. With none every ask fails, and the figure shows its source.
+    property var backends: []
+    readonly property var backend: root.backends.length > 0 ? root.backends[0] : null
+    function adopt(backend) {
+        if (backend && root.backends.indexOf(backend) < 0)
+            root.backends = root.backends.concat([backend]);
+    }
+    function release(backend) {
+        var at = root.backends.indexOf(backend);
+        if (at < 0)
+            return;
+        root.backends = root.backends.filter(function (other) { return other !== backend; });
+        if (at !== 0)
+            return;
+        // The drawing backend went with its window: what it still owed fails, and a new ask goes to the next one.
+        var owed = Object.keys(root.waiting);
+        root.waiting = ({});
+        root.byRequest = ({});
+        for (var i = 0; i < owed.length; i++)
+            root.done(Number(owed[i]), "", "backend closed");
+    }
+    readonly property int cacheMax: 64
+    property int seq: 0
+    // ticket -> cache key, and backend request id -> ticket, for the answer that names only its id.
+    property var waiting: ({})
+    property var byRequest: ({})
+    property var answerCache: ({})
+    property var answerOrder: []
+
+    // FNV-1a over the table's comma-joined text, "0" for none.
+    function tableDigestOf(table) {
+        if (!table || table.length === 0)
+            return "0";
+        var fnvOffset = 0x811c9dc5;
+        var fnvPrime = 0x01000193;
+        var hexRadix = 16;
+        var text = table.join(",");
+        var hash = fnvOffset;
+        for (var i = 0; i < text.length; i++)
+            hash = Math.imul(hash ^ text.charCodeAt(i), fnvPrime);
+        return (hash >>> 0).toString(hexRadix);
+    }
+
+    // The cache key: everything the drawing depends on; a dated figure's day joins it, so the next day's ask draws that day's chart.
+    function cacheKeyOf(kind, source, t, display) {
+        var key = [t.bg, t.fg, t.accent || "", t.muted || "", t.surface || "", t.font || "", t.bodyPx || 0,
+            root.tableDigestOf(t.advances), root.tableDigestOf(t.boldAdvances)].join("|");
+        return kind + "\n" + key + (t.today ? "|" + t.today : "") + "\n" + !!display + "\n" + source;
+    }
+
+    function cached(kind, source, theme, display) {
+        var key = root.cacheKeyOf(kind, source, theme, display);
+        var hit = root.answerCache[key];
+        if (hit !== undefined) {
+            var at = root.answerOrder.indexOf(key);
+            if (at >= 0)
+                root.answerOrder.splice(at, 1);
+            root.answerOrder.push(key);
+        }
+        return hit;
+    }
+
+    function store(key, svg) {
+        var at = root.answerOrder.indexOf(key);
+        if (at >= 0)
+            root.answerOrder.splice(at, 1);
+        root.answerCache[key] = svg;
+        root.answerOrder.push(key);
+        while (root.answerOrder.length > root.cacheMax)
+            delete root.answerCache[root.answerOrder.shift()];
+    }
+
+    // A ticket for one figure; its answer comes later through done(ticket, svg, error), never during this call.
+    function ask(kind, source, display, theme) {
+        root.seq++;
+        var ticket = root.seq;
+        var hit = root.cached(kind, source, theme, display);
+        if (hit !== undefined) {
+            Qt.callLater(function () { root.done(ticket, hit, ""); });
+            return ticket;
+        }
+        if (kind !== "mermaid" || root.backend === null || typeof root.backend.askFigure !== "function") {
+            Qt.callLater(function () { root.done(ticket, "", kind !== "mermaid" ? "unknown figure kind" : "no backend"); });
+            return ticket;
+        }
+        var id = root.backend.askFigure(source, theme);
+        root.waiting[ticket] = root.cacheKeyOf(kind, source, theme, display);
+        root.byRequest[id] = ticket;
+        return ticket;
+    }
+
+    property Connections answers: Connections {
+        target: root.backend
+        ignoreUnknownSignals: true
+        function onFigureResult(message) {
+            var ticket = root.byRequest[message.id];
+            if (ticket === undefined)
+                return;
+            delete root.byRequest[message.id];
+            var key = root.waiting[ticket];
+            delete root.waiting[ticket];
+            if (message.svg)
+                root.store(key, message.svg);
+            root.done(ticket, message.svg || "", message.svg ? "" : (message.error || "render failed"));
+        }
+    }
+}

package/ui/FileDrag.qml

@@ -0,0 +1,267 @@
+import QtQuick
+import "js/Drag.js" as DragOps
+import "js/DragOut.js" as DragOut
+import "js/Ops.js" as Ops
+import "js/Search.js" as Search
+
+// The platform drag belongs to the view: a tab switch may destroy the pressed delegate inside QDrag.exec().
+Item {
+    id: root
+
+    required property var pane
+    // A peek column's {pane, dir, v, w}: its rows are in no listing, so a lift carries the row's own path instead.
+    property var peekSource: null
+    // The window the gesture speaks in: the listing's pane, or the pane a peek column belongs to.
+    readonly property var host: root.pane || (root.peekSource ? root.peekSource.pane : null)
+    property var dragRows: []
+    // The numbering dragRows were read in, fixed at the lift so a drop after a re-list is refused rather than resolved anew.
+    property real dragListing: 0
+    property int dropIndex: -1
+    // The hovered folder a drop lands in after it opens: a swap may rebuild the lit delegate on another row.
+    property string dropDest: ""
+    property int dropDestDev: 0
+    property bool dragCopy: false
+    property bool dragShift: false
+    property bool dragLink: false
+    property bool awaitingPaths: false
+    property bool buttonUp: false
+    property var dragMime: ({})
+    property var feedback: null
+    // Drops callout 2: the folder the pointer rests on and the autoscroll band it rests in; the timers are built on first use.
+    property int hoverIndex: -1
+    property string hoverPath: ""
+    property int scrollDir: 0
+    property var hoverTimers: null
+
+    Drag.dragType: Drag.Automatic
+    // Plain lift offers copy alone, narrowed by modifiers (a browser uploader refuses move); Ctrl copy, Shift move, both link, so any receiver takes the lift's verb.
+    Drag.supportedActions: root.dragLink ? Qt.LinkAction : root.dragCopy ? Qt.CopyAction : root.dragShift ? Qt.MoveAction : Qt.CopyAction
+    Drag.proposedAction: root.dragLink ? Qt.LinkAction : root.dragCopy ? Qt.CopyAction : root.dragShift ? Qt.MoveAction : Qt.CopyAction
+    Drag.mimeData: root.dragMime
+    // The receiver moves or copies itself: deleting on its acceptance would trash files before Files reads them.
+    Drag.onDragFinished: function () { root.liftEnded() }
+
+    function liftBegan(index, centroid) {
+        if (!root.pane || root.pane.listInFlight || index < 0 || !root.pane.rowFor(index)) return
+        if (root.pane.cancelSlowClick) root.pane.cancelSlowClick()
+        root.buttonUp = false
+        root.awaitingPaths = false
+        if (root.pane) root.pane.awaitingPaths = false
+        root.dragRows = DragOps.carried(root.pane, index)
+        root.dragListing = root.pane.backend ? root.pane.backend.heldListing : 0
+        root.dropIndex = -1
+        root.dropDest = ""
+        root.dropDestDev = 0
+        // Ctrl is the threshold's, and a paths reply must not sample it again.
+        root.dragCopy = DragOps.copying(centroid.modifiers)
+        root.dragShift = DragOps.shifting(centroid.modifiers)
+        root.dragLink = DragOps.linking(centroid.modifiers)
+        root.dragMime = DragOps.mimeFor(root.pane, root.dragRows, root.dragCopy, root.dragShift)
+        if (root.dragMime["text/uri-list"]) {
+            root.startOffer()
+            return
+        }
+        if (!root.pane.backend || !DragOut.askAllowed(root.pane.pathsPending, root.pane.clipPending)) {
+            root.cannotLeave()
+            return
+        }
+        root.awaitingPaths = true
+        if (root.pane) root.pane.awaitingPaths = true
+        var dev = root.pane.backend.dirDev || 0
+        root.feedback = { own: true, copy: root.dragCopy, shift: root.dragShift, dev: dev,
+                          deletable: DragOps.listingDeletable(root.pane), count: root.dragRows.length, canLeave: true }
+        root.say(DragOps.feedbackLine(root.feedback, "", dev))
+        var rows = root.dragRows.slice()
+        var listing = root.dragListing
+        var copy = root.dragCopy
+        var shift = root.dragShift
+        var link = root.dragLink
+        root.pane.pathsPending = {
+            kind: "drag", rows: rows, listing: listing, copy: copy, shift: shift, link: link,
+            deliver: function (list, pending) { root.deliverPaths(list, pending) }
+        }
+        root.pane.backend.send({ c: "paths", rows: rows, listing: listing })
+    }
+
+    function liftPeek(row, centroid) {
+        if (!root.peekSource || !row) return
+        root.buttonUp = false
+        root.dragRows = []
+        root.dragListing = 0
+        root.dropIndex = -1
+        root.dropDest = ""
+        root.dropDestDev = 0
+        root.dragCopy = DragOps.copying(centroid.modifiers)
+        root.dragShift = DragOps.shifting(centroid.modifiers)
+        root.dragLink = DragOps.linking(centroid.modifiers)
+        root.dragMime = root.peekMime(row, root.dragCopy, root.dragShift)
+        root.startOffer()
+    }
+
+    // No rows in the marker, so no receiver resolves it by index (DragOps.canDropByIndex needs rows); the uri is the column's directory plus the name.
+    function peekMime(row, copy, shift) {
+        var src = root.peekSource
+        var path = src.pane.join(src.dir, row.n)
+        var mime = {}
+        mime[DragOps.ROWS_MIME] = DragOps.markerPayload([], copy, src.dir, src.v, src.w, shift === true)
+        mime["text/uri-list"] = DragOps.uriFor(path) + "\r\n"
+        mime["text/plain"] = path
+        return mime
+    }
+
+    function liftReleased() {
+        root.buttonUp = true
+    }
+
+    function liftMoved(centroid) {
+        if (root.awaitingPaths || root.Drag.active) return
+        root.dragCopy = DragOps.copying(centroid.modifiers)
+        root.dragShift = DragOps.shifting(centroid.modifiers)
+        root.dragLink = DragOps.linking(centroid.modifiers)
+    }
+
+    function startOffer() {
+        root.dragMime = DragOut.keys.stamped(root.dragMime)
+        root.feedback = DragOps.feedbackFor(root.dragMime[DragOps.ROWS_MIME],
+            (root.dragMime["text/uri-list"] || "").split("\r\n"))
+        root.showTarget("", root.feedback.dev)
+        // Drag.Automatic runs QDrag::exec synchronously, so a finish inside it must not overwrite the hold: arm the watch first.
+        if (root.host) root.host.dragHolding = true
+        root.Drag.active = true
+    }
+
+    function deliverPaths(list, pending) {
+        root.awaitingPaths = false
+        if (root.pane) root.pane.awaitingPaths = false
+        var held = root.pane && root.pane.backend ? root.pane.backend.heldListing : 0
+        if (root.buttonUp || held !== pending.listing || !list || list.length !== pending.rows.length) {
+            root.cannotLeave()
+            return
+        }
+        root.dragCopy = pending.copy
+        root.dragShift = pending.shift === true
+        root.dragLink = pending.link === true || (pending.copy === true && pending.shift === true)
+        root.dragMime = root.mimeForPaths(pending.rows, list, pending.copy, root.dragShift)
+        root.startOffer()
+    }
+
+    function mimeForPaths(rows, paths, copy, shift) {
+        var mime = {}
+        var dev = root.pane.backend ? root.pane.backend.dirDev : 0
+        mime[DragOps.ROWS_MIME] = DragOps.markerPayload(rows, copy, Search.baseOf(root.pane), dev, DragOps.listingDeletable(root.pane), shift === true)
+        var uris = []
+        for (var i = 0; i < paths.length; i++) uris.push(DragOps.uriFor(paths[i]))
+        mime["text/uri-list"] = uris.join("\r\n") + "\r\n"
+        mime["text/plain"] = paths.join("\n")
+        return mime
+    }
+
+    // Too wide carries no uri-list, so the gesture ends here and the refusal reads as a pane message.
+    function cannotLeave() {
+        var line = DragOps.line(root.dragRows.length, "", root.dragCopy, root.dragLink) + DragOps.reachNote(false)
+        root.awaitingPaths = false
+        root.liftEnded()
+        if (root.host) root.host.message(line, false)
+    }
+
+    function verbAt(marker, row, seenCopy, seenShift) {
+        return DragOps.verbFor(DragOps.isOwnDrag(marker), DragOps.dropHeld(DragOps.markerCopying(marker), seenCopy),
+                               DragOps.dropHeld(DragOps.markerShift(marker), seenShift), DragOps.markerDev(marker),
+                               row ? row.v : 0, DragOps.markerDeletable(marker))
+    }
+
+    function liftEnded() {
+        root.Drag.active = false
+        if (root.host) { root.host.dragHolding = false; root.host.awaitingPaths = false; root.host.pointerHeld = false }
+        root.dragRows = []
+        root.dragListing = 0
+        root.dragMime = ({})
+        root.dropIndex = -1
+        root.dropDest = ""
+        root.dropDestDev = 0
+        root.dragCopy = false
+        root.dragShift = false
+        root.dragLink = false
+        root.feedback = null
+        root.hoverIndex = -1
+        root.hoverPath = ""
+        root.scrollDir = 0
+        if (root.hoverTimers) root.hoverTimers.stopRest()
+        // A different view may now speak for this gesture; its activity is separate from every transfer.
+        var bar = root.host ? root.host.statusBar : null
+        if (bar && bar.dragFeedbackOwner) bar.dragFeedbackOwner.say("")
+    }
+
+    // A folder row under the pointer starts the rest that opens it and the band that scrolls; a move restarts both.
+    function hoverBegan(index, path, y, height) {
+        root.hoverIndex = index
+        root.hoverPath = path
+        root.scrollDir = DragOut.band(y, height)
+        root.ensureHoverTimers()
+        root.hoverTimers.rest()
+    }
+
+    function hoverMoved(y, height) {
+        root.scrollDir = DragOut.band(y, height)
+        if (root.scrollDir !== 0) root.ensureHoverTimers()
+        if (root.hoverTimers) root.hoverTimers.rest()
+    }
+
+    function hoverEnded() {
+        root.hoverIndex = -1
+        root.hoverPath = ""
+        root.scrollDir = 0
+        if (root.hoverTimers) root.hoverTimers.stopRest()
+    }
+
+    function ensureHoverTimers() {
+        if (root.hoverTimers !== null)
+            return
+        root.hoverTimers = Qt.createComponent("HoverTimers.qml").createObject(root, { session: root })
+    }
+
+    function say(text) {
+        var bar = root.host ? root.host.statusBar : null
+        if (!bar) return
+        if (!text) {
+            if (bar.dragFeedbackOwner === root) {
+                bar.dragFeedbackOwner = null
+                bar.setActivity(root, "", Ops.emptyTransfer())
+            }
+            return
+        }
+        if (bar.activities.some(function (entry) { return entry.transfer.running })) return
+        if (bar.dragFeedbackOwner && bar.dragFeedbackOwner !== root)
+            bar.setActivity(bar.dragFeedbackOwner, "", Ops.emptyTransfer())
+        bar.dragFeedbackOwner = root
+        bar.setActivity(root, text, Ops.emptyTransfer())
+    }
+
+    function enterTarget(marker, urls, name, destDev, shelf, proposed) {
+        root.feedback = DragOps.feedbackFor(marker, urls, shelf, proposed)
+        root.showTarget(name, destDev)
+    }
+
+    function showTarget(name, destDev) {
+        if (!root.feedback) return
+        root.dragCopy = DragOps.copyingFor(root.feedback, destDev)
+        root.dragLink = DragOps.linkingFor(root.feedback, destDev)
+        root.say(DragOps.feedbackLine(root.feedback, name, destDev))
+    }
+
+    function leaveTarget() {
+        var bar = root.host ? root.host.statusBar : null
+        if (!bar || bar.dragFeedbackOwner !== root) return
+        root.say(root.feedback && root.feedback.own
+            ? DragOps.feedbackLine(root.feedback, "", root.feedback.dev) : "")
+    }
+
+    Connections {
+        target: root.host ? root.host.statusBar : null
+        function onActivitiesChanged() {
+            var bar = root.host.statusBar
+            if (bar.dragFeedbackOwner === root
+                    && bar.activities.some(function (entry) { return entry.transfer.running })) root.say("")
+        }
+    }
+}