flea-qml 0.0.0-stage → 0.2.0

package/ui/TransferCard.qml

@@ -0,0 +1,239 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/Ops.js" as Ops
+import "js/Transfer.js" as Transfer
+
+// The released transfer card remains the pointer cancellation surface above the informational footer.
+Item {
+    id: root
+
+    // ui/js/Ops.js's transfer, reassigned on every wire line; running false is what hides the card.
+    property var transfer: Ops.emptyTransfer()
+    property var owner: null
+    readonly property var cancelItem: cancelButton
+    readonly property alias byteText: byteLine.text
+    readonly property alias headlineText: headline.text
+    signal cancelRequested(int id)
+
+    // Everything drawn comes off this sample rather than straight off the wire, because thirty
+    // thousand small files change the name faster than it can be read. Idle rather than bound to
+    // transfer: a binding would track the wire live until the first tick happened to break it.
+    property var shown: Ops.emptyTransfer()
+    // About four changes a second, which is what the eye reads. The backend's own byte heartbeat is
+    // 150 ms (src/backend/opsreq.rs PROGRESS_EVERY), so a large file loses almost nothing here.
+    readonly property int publishMs: 250
+    // TransferCard rule 3: the rate is what this card published over the last two seconds, so one
+    // slow beat cannot make it jump and a stall reads 0 B/s rather than a stale number.
+    readonly property int rateWindowMs: 2000
+    property var rateSamples: []
+    readonly property real rate: {
+        if (root.rateSamples.length < 2)
+            return 0
+        var first = root.rateSamples[0]
+        var last = root.rateSamples[root.rateSamples.length - 1]
+        var span = (last.at - first.at) / 1000
+        return span > 0 ? Math.max(0, (last.bytes - first.bytes) / span) : 0
+    }
+
+    // Set the instant Cancel is pressed. src/backend/copyfile.rs stops the item in flight and
+    // removes what it wrote, so this covers only the round trip to transferdone and the beat above.
+    property bool cancelling: false
+
+    // The bar's thickness comes off the type scale the way a mark does, so it follows the display
+    // text size instead of pinning a pixel.
+    readonly property int barHeight: Math.round(Theme.font.caption / 2)
+    readonly property real trackOpacity: 0.25
+    // The one other popup in this design, ui/ConvertDialog.qml, is 300 design pixels wide; a second
+    // popup at a second width would be two languages.
+    readonly property int cardWidth: 300
+
+    visible: root.shown.running
+    implicitWidth: Theme.space(root.cardWidth)
+    implicitHeight: body.implicitHeight + 2 * Theme.spacing.rowPaddingX
+    width: root.implicitWidth
+    height: root.implicitHeight
+
+    onTransferChanged: {
+        // The first sample and the last are published at once; the ones between wait for the beat.
+        if (!root.transfer.running || !root.shown.running || root.transfer.id !== root.shown.id) {
+            root.publish()
+        }
+    }
+    onOwnerChanged: root.publish()
+
+    Timer {
+        interval: root.publishMs
+        repeat: true
+        running: root.transfer.running
+        onTriggered: root.publish()
+    }
+
+    // One published sample, and the window the rate is measured over: everything older than two
+    // seconds goes except the one sample just past the edge, which is what the span is taken from.
+    function publish() {
+        var fresh = root.transfer.id !== root.shown.id ? [] : root.rateSamples
+        root.shown = root.transfer
+        var now = Date.now()
+        var next = fresh.concat([{at: now, bytes: Transfer.movedBytes(root.shown)}])
+        var keep = 0
+        while (keep + 1 < next.length && now - next[keep + 1].at > root.rateWindowMs) {
+            keep += 1
+        }
+        root.rateSamples = next.slice(keep)
+    }
+
+    // Dimmed while the drive is being flushed: every file is already complete, so there
+    // is nothing left to stop.
+    function cancel() {
+        if (!Transfer.cancelEnabled(root.transfer) || root.cancelling) return
+        root.cancelRequested(root.transfer.id)
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        hoverEnabled: true
+        acceptedButtons: Qt.AllButtons
+        onWheel: function(wheel) { wheel.accepted = true }
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: Theme.color.surface
+        border.width: Theme.spacing.hairline
+        border.color: Theme.color.mutedFrame
+        // Mirrors hyprland decoration:rounding, the same as the menu and the convert popup; 0 on a
+        // stock box, and the bar inside stays square either way.
+        radius: Style.cornerRadius
+    }
+
+    Column {
+        id: body
+        x: Theme.spacing.rowPaddingX
+        y: Theme.spacing.rowPaddingX
+        width: root.width - 2 * Theme.spacing.rowPaddingX
+        spacing: Theme.spacing.gap
+
+        Item {
+            width: parent.width
+            height: headline.implicitHeight
+
+            // The card is chrome, so its mark is the OEM icon token the chrome bar's own marks
+            // take; the status bar's spiral is caption-sized because the bar's own text is.
+            Flea.Spinner {
+                id: crawl
+                anchors.left: parent.left
+                anchors.verticalCenter: parent.verticalCenter
+                width: Theme.chromeMarkSize
+                height: Theme.chromeMarkSize
+                color: Theme.color.mutedFrame
+            }
+
+            Text {
+                id: headline
+                anchors.left: crawl.right
+                anchors.leftMargin: Theme.spacing.gap
+                anchors.right: parent.right
+                anchors.verticalCenter: parent.verticalCenter
+                text: Transfer.head(root.shown)
+                color: Theme.color.foreground
+                font.family: Theme.font.family
+                font.pixelSize: Theme.font.body
+                textFormat: Text.PlainText
+                elide: Text.ElideRight
+            }
+        }
+
+        Text {
+            width: parent.width
+            visible: text.length > 0
+            text: Transfer.fileLine(root.shown)
+            color: Theme.color.muted
+            font.family: Theme.font.family
+            font.pixelSize: Theme.font.caption
+            textFormat: Text.PlainText
+            // The middle goes and the extension stays: the extension is what says what the file is.
+            elide: Text.ElideMiddle
+        }
+
+        // Square ends, track and fill both: no row or bar in this language rounds. The fill is a
+        // sibling of the track and not its child, because opacity multiplies down into children.
+        Item {
+            width: parent.width
+            height: root.barHeight
+
+            Rectangle {
+                anchors.fill: parent
+                color: Theme.color.mutedFrame
+                opacity: root.trackOpacity
+            }
+
+            Rectangle {
+                width: parent.width * Transfer.fraction(root.shown)
+                height: parent.height
+                color: Theme.color.accentFrame
+
+                // The card publishes four times a second; easing across the gap is what makes the
+                // fill read as movement rather than as four steps a second.
+                Behavior on width {
+                    enabled: !Theme.reducedMotion
+                    NumberAnimation { duration: root.publishMs; easing.type: Easing.Linear }
+                }
+            }
+        }
+
+        // TransferCard rule 1: the bar's own caption, the figures the operator is waiting on inked
+        // in the foreground and the words between them muted. Rule 4 makes it absent, not blank,
+        // until the first byte sample lands, so the card is one row shorter until then.
+        Row {
+            id: byteLine
+            readonly property var parts: Transfer.byteParts(root.shown, root.rate)
+            // The drawn line as one string, so a driven case reads what the card says rather than a shot.
+            readonly property string text: byteLine.parts.map(function (p) { return p.text }).join("")
+            visible: byteLine.parts.length > 0
+            height: visible ? implicitHeight : 0
+
+            Repeater {
+                model: byteLine.parts
+
+                delegate: Text {
+                    required property var modelData
+                    text: modelData.text
+                    color: modelData.figure ? Theme.color.foreground : Theme.color.muted
+                    font.family: Theme.font.family
+                    font.pixelSize: Theme.font.caption
+                    textFormat: Text.PlainText
+                }
+            }
+        }
+
+        Item {
+            width: parent.width
+            height: cancelButton.implicitHeight
+
+            // Variant A: the card's Cancel is the one control every dialog draws.
+            Flea.DialogButton {
+                id: cancelButton
+                anchors.right: parent.right
+                visible: !root.cancelling
+                label: "Cancel"
+                available: Transfer.cancelEnabled(root.shown)
+                enabled: available
+                onActivated: root.cancel()
+            }
+
+            // The cancel is in and the item in flight is being finished rather than torn in half,
+            // which is a state the operator has to be able to see rather than infer from a dead button.
+            Text {
+                visible: root.cancelling
+                anchors.right: parent.right
+                anchors.verticalCenter: parent.verticalCenter
+                text: "Cancelling"
+                color: Theme.color.muted
+                font.family: Theme.font.family
+                font.pixelSize: Theme.font.body
+                textFormat: Text.PlainText
+            }
+        }
+    }
+}

package/ui/TrashConfirm.qml

@@ -0,0 +1,129 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/Trash.js" as Trash
+
+// The destructive choice must be reached deliberately; a reflexive Enter activates Cancel.
+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 var snapshot: ({})
+    property bool destructiveFocus: false
+    property string scopeName: "Trash items"
+    readonly property real referenceScale: Theme.font.bodySmall / 13
+    readonly property real cardPadding: Math.round(16 * referenceScale)
+    readonly property real cardBottomPadding: Theme.spacing.rowPaddingX
+    signal confirmed(int token)
+    signal cancelled()
+    readonly property var cardItem: card
+    readonly property var cancelItem: cancelButton
+    readonly property var dangerItem: dangerButton
+    readonly property string titleText: title.text
+    readonly property string bodyText: bodyLabel.text
+    function open(value) { snapshot = value; destructiveFocus = false; body.contentY = 0; opened = true; forceActiveFocus() }
+    function close() { opened = false }
+    function cancel() { close(); cancelled() }
+    function activate() {
+        if (!destructiveFocus) { cancel(); return }
+        var token = snapshot.token
+        close()
+        confirmed(token)
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    Keys.onPressed: function(event) {
+        if (event.key === Qt.Key_Escape) root.cancel()
+        else if (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) { event.accepted = true; return }
+        else if (event.key === Qt.Key_Tab || event.key === Qt.Key_Backtab) root.destructiveFocus = !root.destructiveFocus
+        else if (event.key === Qt.Key_L || event.key === Qt.Key_Right) root.destructiveFocus = true
+        else if (event.key === Qt.Key_H || event.key === Qt.Key_Left) root.destructiveFocus = false
+        else if (event.key === Qt.Key_Return || event.key === Qt.Key_Enter || event.key === Qt.Key_Space) root.activate()
+        if (root.opened) body.reveal(root.destructiveFocus ? dangerButton : cancelButton)
+        event.accepted = true
+    }
+    Rectangle {
+        anchors.fill: parent
+        color: Theme.color.background
+        opacity: 0.5
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onClicked: root.cancel()
+            onWheel: function(wheel) { wheel.accepted = true }
+        }
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        // TrashSidebar's 340px content width excludes its two 16px paddings and hairlines.
+        width: Theme.cardSpan(Math.round(340 * root.referenceScale * Theme.dialogWidthRatio) + 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: Row {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Flea.Glyph { id: alertMark; width: Theme.font.bodySmall * 1.3; height: title.height; name: "alert"; color: Theme.color.error }
+                Text {
+                    id: title
+                    width: parent.width - alertMark.width - parent.spacing
+                    text: Trash.confirmTitle(root.snapshot)
+                    textFormat: Text.PlainText
+                    wrapMode: Text.Wrap
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.body; bold: true }
+                }
+            }
+            buttons: Flow {
+                width: Math.min(parent.width, cancelButton.implicitWidth + dangerButton.implicitWidth + spacing)
+                anchors.right: parent.right
+                spacing: Theme.spacing.gap
+                Flea.DialogButton {
+                    id: cancelButton
+                    label: "Cancel"
+                    primary: true
+                    focused: !root.destructiveFocus
+                    onActivated: root.cancel()
+                }
+                Flea.DialogButton {
+                    id: dangerButton
+                    label: root.snapshot.all ? "Empty Trash" : "Delete"
+                    destructive: true
+                    focused: root.destructiveFocus
+                    onActivated: { root.destructiveFocus = true; root.activate() }
+                }
+            }
+            Text {
+                id: bodyLabel
+                width: parent.width
+                text: Trash.confirmBody(root.snapshot, root.scopeName)
+                textFormat: Text.PlainText
+                wrapMode: Text.Wrap
+                color: Theme.color.foreground
+                font { family: Theme.font.family; pixelSize: Theme.font.body }
+            }
+        }
+    }
+}

package/ui/TrashDropHandler.qml

@@ -0,0 +1,11 @@
+import QtQuick
+import "js/TrashDrop.js" as TrashDrop
+
+// The rail loads this bridge on its first matching drag, keeping TrashDrop.js off the first frame.
+FileDrag {
+    id: root
+
+    function accepts(marker, urls, path) { return TrashDrop.accepts(marker, urls, path, root.pane ? root.pane.backend : null) }
+    function line(marker, urls, path) { return TrashDrop.line(marker, urls, path, root.pane ? root.pane.backend : null) }
+    function drop(pane, marker, urls) { return TrashDrop.drop(pane, marker, urls) }
+}

package/ui/TrashHost.qml

@@ -0,0 +1,202 @@
+import QtQuick
+import "." as Flea
+import "js/Focus.js" as Focus
+import "js/Menu.js" as Menu
+import "js/Ops.js" as Ops
+import "js/RecentMode.js" as RecentMode
+import "js/TrashDates.js" as TrashDates
+
+// Only Trash-specific operations live here. Pane owns the visible listing,
+// keyboard, filtering, thumbnails and Quick Look, just as for any other location.
+Item {
+    id: root
+    required property var pane
+    property Item overlayParent: null
+    readonly property bool browsing: pane.recentMode === "trash"
+    // Compatibility with callers checking for the old full-pane overlay.
+    readonly property bool opened: false
+    readonly property bool confirming: (confirmation !== null && confirmation.opened) || pendingReview !== null || pendingOp === "prepare"
+    readonly property var item: root
+    readonly property var sheetPane: pane
+    readonly property int total: browsing ? pane.total : 0
+    readonly property int selectedCount: browsing ? pane.selectionCount() : 0
+    readonly property bool active: browsing
+    property int requestId: 1000000
+    property string pendingOp: ""
+    property bool pendingAll: false
+    property int pendingToken: 0
+    property var pendingReview: null
+    property var pendingRows: []
+    property int pendingListing: 0
+    readonly property bool busy: pendingOp.length > 0
+    readonly property var confirmationItem: confirmation
+    readonly property bool confirmationOpen: confirmation !== null && confirmation.opened
+    // The 30 day sweep, decided 2026-09-11. It runs the same three requests the window runs,
+    // in the same order, so prepare still reviews every item against the identity the listing
+    // reported and delete still refuses a token the trash has moved under. This host drives it
+    // because the backend keeps ONE Trash session: two clients listing into it would take each
+    // other's snapshot away, so the window and the sweep are never in flight together.
+    readonly property int sweepDays: 30
+    // One window of the listing, which is also the most the backend will answer with. A Trash holding
+    // more than this is swept over as many days as it takes, which is slower and never wrong.
+    readonly property int sweepWindow: 350
+    property int sweepId: 0
+    property string sweepStage: ""
+    property var sweepDoomed: []
+    readonly property bool sweeping: root.sweepStage.length > 0
+
+    function sweep() {
+        if (root.sweeping || root.browsing || !ViewState.trashAutoEmpty)
+            return
+        if (TrashDates.dayNumber(Date.now()) === ViewState.trashSweptOn)
+            return
+        root.sweepSend("list", {start: 0, count: root.sweepWindow, recover: false})
+    }
+
+    function sweepSend(op, fields) {
+        var message = fields || {}
+        message.c = "trashbrowse"
+        message.op = op
+        message.id = ++root.sweepId
+        root.sweepStage = op
+        root.pane.backend.send(message)
+    }
+
+    // The operator reaching for Trash outranks a sweep nobody asked to watch. Cancelling drops the
+    // prepared confirmation in the backend, so the window's own list starts from a clean session.
+    function sweepStop() {
+        if (!root.sweeping)
+            return
+        root.sweepStage = ""
+        root.sweepDoomed = []
+        root.pane.backend.send({c: "trashbrowse", op: "cancel", id: ++root.sweepId, clearSelection: true})
+    }
+
+    // Every reply while a sweep is in flight is the sweep's, because the window cannot be open then.
+    // A failure at any stage ends the sweep and records nothing, so the next launch tries again.
+    function sweepReceive(message) {
+        if (message.ok !== true) { root.sweepStage = ""; root.sweepDoomed = []; return }
+        if (message.op === "list") {
+            var rows = message.rows || []
+            var now = Date.now()
+            var doomed = []
+            for (var i = 0; i < rows.length; i++) {
+                if (TrashDates.expired(rows[i].deleted, now, root.sweepDays))
+                    doomed.push(rows[i])
+            }
+            if (doomed.length === 0) { root.sweepFinished(); return }
+            root.sweepDoomed = doomed
+            root.sweepSend("prepare", {all: false, emptyTrash: false,
+                uris: doomed.map(function (row) { return row.uri }),
+                identities: doomed.map(function (row) { return row.identity })})
+            return
+        }
+        if (message.op === "prepare") {
+            // A prepare that reviewed nothing has nothing to delete, and asking anyway would spend a
+            // token on an empty confirmation.
+            if (!message.count) { root.sweepFinished(); return }
+            root.sweepSend("delete", {token: message.token})
+            return
+        }
+        if (message.op === "delete") {
+            // The rail is hidden, so its TrashMonitor is unloaded with it: nothing to refresh.
+            if (root.pane.sidebar) root.pane.sidebar.refreshTrash()
+            root.sweepFinished()
+        }
+    }
+
+    function sweepFinished() {
+        root.sweepStage = ""
+        root.sweepDoomed = []
+        ViewState.recordTrashSweep(TrashDates.dayNumber(Date.now()))
+    }
+
+
+    function open(action) {
+        if (confirming || busy) return
+        sweepStop()
+        if (!browsing) {
+            if (pane.preview) pane.preview.close()
+            pane.shareBrowser.close()
+            pane.clearSelection()
+            pane.focusView = Focus.LIST
+            RecentMode.run(pane, [], {}, "trash")
+        }
+        if (action === "emptyTrash" || action === "restoreAll") root.action(action)
+        else pane.listArea.forceActiveFocus()
+    }
+    // Navigation already owns the next listing; do not issue a second list here.
+    function close() { if (browsing && !confirming) RecentMode.leave(pane) }
+    function send(op, fields) {
+        pendingOp = op
+        pane.backend.send(Object.assign({c:"trashbrowse",id:++requestId,op:op},fields || {}))
+    }
+    function action(name, menuId) {
+        if (busy || confirming) return
+        if (name === "openTrash") { open(); return }
+        var all = name === "emptyTrash" || name === "restoreAll"
+        if (!all && !browsing) return
+        if (!all && pane.listInFlight) { pane.message("A directory is already loading.", false); return }
+        pendingAll = all
+        pendingRows = all ? [] : Ops.targetIndices(pane)
+        pendingListing = pane.backend.heldListing
+        if (!all && !menuId && pendingRows.length === 0) return
+        var fields = all ? {all:true,emptyTrash:name === "emptyTrash"}
+                         : {all:false,rows:pendingRows,listing:pendingListing}
+        if (menuId && !all) fields.menuId = menuId
+        send(name === "restoreAll" || name === "restoreTrashSelection" ? "restore" : "prepare", fields)
+    }
+    function refresh() { if (browsing && !pane.listInFlight) RecentMode.refresh(pane, "") }
+    function menuEntries(selection, hidden) {
+        return selection ? Menu.applyHidden([
+            {label:"Restore",action:"restoreTrashSelection",glyph:"undo",disabled:busy},
+            {separator:true},
+            {label:"Delete permanently",action:"deletePermanently",glyph:"trash",danger:true,disabled:busy}
+        ],hidden) : Menu.trashEntries(total,busy)
+    }
+    function sheetFocus() { pane.listArea.forceActiveFocus() }
+    function sheetActionRows(rows) { return rows }
+    function sheetMenuModel() { return menuEntries(true,[]).concat(menuEntries(false,[])) }
+    function sheetMenuAction(name) { action(name) }
+    function sheetAction(name) { Focus.dispatchAction(name,pane) }
+    readonly property var confirmation: confirmationLoader.item
+    Loader { id:confirmationLoader; active:false; source:"TrashConfirm.qml"; onLoaded:{item.parent=root.overlayParent || root;item.z=5;if(root.pendingReview){item.open(root.pendingReview);root.pendingReview=null}} }
+    Connections {
+        target:root.confirmation
+        function onConfirmed(token) { root.send("delete",{token:token}) }
+        function onCancelled() { root.send("cancel");root.pane.listArea.forceActiveFocus() }
+    }
+    Connections {
+        target: root.pane.backend
+        function onTrashResult(message) {
+            if (root.sweeping) { root.sweepReceive(message); return }
+            if (message.id !== root.requestId || message.op !== root.pendingOp) return
+            root.pendingOp = ""
+            if (!message.ok) {
+                if (confirmation) confirmation.close()
+                root.pane.message(message.error || "Trash operation failed",true)
+                root.pane.listArea.forceActiveFocus()
+                root.refresh()
+                return
+            }
+            if (message.op === "prepare") { root.pendingToken=message.token; if(confirmation)confirmation.open(message);else{root.pendingReview=message;confirmationLoader.active=true;} return }
+            if (message.op === "check" && !message.valid) { if (confirmation) confirmation.close(); root.pane.message("The Trash changed; review it again.",true) }
+            if (message.op === "restore" || message.op === "delete") {
+                root.pane.operationResult((message.op === "restore" ? "Restored " : "Deleted ")+message.done+" items",
+                    (message.failures || []).map(function(f){return f.error}).join("\n"),message.failed > 0)
+                if(root.pane.sidebar)root.pane.sidebar.refreshTrash()
+                root.refresh()
+            }
+            if (message.op !== "check") root.pane.listArea.forceActiveFocus()
+        }
+    }
+    Timer { interval:2500; repeat:true; running:root.confirmationOpen && !root.busy; onTriggered:root.send("check",{token:root.pendingToken}) }
+    Connections {
+        target: root.pane.sidebar
+        function onTrashChanged() { if(root.browsing && !root.busy && !root.confirming)root.refresh() }
+    }
+    Connections {
+        target: root.pane.contextMenu()
+        function onRailChosen(action,key) { if(key === "trash")root.action(action) }
+    }
+}

package/ui/TrashMonitor.qml

@@ -0,0 +1,30 @@
+import QtQuick
+
+// flea-qml: the shared Trash count, as the pane's backend reports it with a `trashcount` line at
+// start and on every change. The backend reads the FreeDesktop.org Trash that src/trash.js writes;
+// upstream ran `gio monitor` and `gio info` under setpriv and sh here. Nothing extra runs: the
+// backend already lives as long as the interface.
+Item {
+    id: root
+    // Not named enabled, which would shadow Item's own input switch.
+    property bool watching: true
+    property var backend: null
+    readonly property int reported: root.backend ? root.backend.trashCount : -1
+    readonly property int revision: root.backend ? root.backend.trashRevision : 0
+    property int count: 0
+    property bool ready: false
+    signal changed()
+    signal failed(string message)
+
+    // The backend reports every change itself, so there is nothing to ask for again.
+    function refresh() {}
+
+    onRevisionChanged: if (root.watching && root.ready) root.changed()
+    onReportedChanged: {
+        if (!root.watching || root.reported < 0) return
+        root.count = root.reported
+        root.ready = true
+    }
+    onWatchingChanged: if (root.watching && root.reported >= 0) { root.count = root.reported; root.ready = true }
+    Component.onCompleted: if (root.reported >= 0) { root.count = root.reported; root.ready = true }
+}

package/ui/TrashToolbar.qml

@@ -0,0 +1,19 @@
+import QtQuick
+import qs.Commons
+Item {
+    id: root
+    property var trash: null
+    Repeater {
+        model: [{label:"Restore",action:"restoreTrashSelection"},{label:"Restore all",action:"restoreAll"},{label:"Empty Trash",action:"emptyTrash"}]
+        delegate: Rectangle {
+            required property var modelData
+            required property int index
+            x: index * (width + Theme.spacing.gap)
+            height: root.height
+            width: Math.min(Math.max(110, Theme.font.body * 8), (root.width - 2*Theme.spacing.gap)/3)
+            color: Theme.color.surface
+            Text { anchors.centerIn:parent; text:modelData.label; color:Theme.color.foreground; font {family:Theme.font.family;pixelSize:Theme.font.body} }
+            MouseArea { anchors.fill:parent; onClicked:if(root.trash)root.trash.action(modelData.action) }
+        }
+    }
+}