flea-qml 0.0.0-stage → 0.1.0

package/ui/RowDrag.qml

@@ -0,0 +1,213 @@
+import QtQuick
+import "js/Drag.js" as DragOps
+import "js/DragOut.js" as DragOut
+import "js/DropDev.js" as DropDev
+import "js/Tabs.js" as Tabs
+import "js/Search.js" as Search
+
+// Delegate input and drop eligibility share a view-owned FileDrag; no platform object lives in this row.
+Item {
+    id: root
+
+    required property var session
+    required property int listingIndex
+    required property var row
+    readonly property var pane: root.session.pane
+    // A peek column's session names the directory it shows and the pane whose collide sends its drops; null is the pane's own listing.
+    readonly property var dropScope: root.pane === null && root.session.peekSource ? root.session.peekSource : null
+    readonly property var targetPane: root.dropScope ? root.dropScope.pane : root.pane
+    readonly property string targetDir: root.dropScope ? root.dropScope.dir : (root.pane ? Search.baseOf(root.pane) : "")
+
+    // A listing row names its own device; a peek or carried column row names none, so the backend's answer for its path stands in, and an unanswered path is 0, which copies.
+    readonly property int destDev: !root.row ? 0 : root.row.v ? root.row.v
+        : (root.row.d === true && root.targetPane && root.targetPane.backend
+            ? DropDev.devFor(root.targetPane.backend.pathDevs, root.targetPane.join(root.targetDir, root.row.n)) : 0)
+    // The answer landing while this folder is hovered re-says its line once, in the right verb.
+    onDestDevChanged: if (root.lit()) {
+        root.session.dropDestDev = root.destDev
+        root.session.showTarget(root.row.n, root.destDev)
+    }
+
+    // The drop destination this delegate last recorded on the session, kept so leaving clears only its own record.
+    property string recorded: ""
+    // False where the view answers drops from one shared area, so the row's own area stays disabled.
+    property bool dropsLocal: true
+
+    anchors.fill: parent
+    // A peek column's row lifts through the session's peekSource; which drops it takes is the DropArea's call alone.
+    enabled: !!root.row && (root.pane !== null ? !root.pane.listInFlight && root.listingIndex >= 0
+        : root.session.peekSource !== null)
+
+    DragHandler {
+        id: lift
+        enabled: root.pane === null || (!root.pane.renamePending && root.pane.renamingIndex !== root.listingIndex)
+        target: null
+        // Preserve List's grab contract: the Flickable must not take the row drag after its threshold.
+        grabPermissions: PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByHandlersOfSameType
+        onActiveChanged: {
+            if (active && root.pane !== null) root.session.liftBegan(root.listingIndex, lift.centroid)
+            else if (active) root.session.liftPeek(root.row, lift.centroid)
+            else root.session.liftReleased()
+        }
+        onCentroidChanged: if (active) root.session.liftMoved(lift.centroid)
+    }
+
+    // The row's own area answers where dropsLocal holds; a view with one shared area leaves this one inert. No Loader stands in front of it: a Loader would add an object to every list row for a grid tile's saving.
+    DropArea {
+        anchors.fill: parent
+        // A peek row takes drops only as a folder, through its dropScope; without one it would aim the drop at the pane's own folder.
+        enabled: root.dropsLocal && (root.pane !== null || (root.dropScope !== null && !!root.row && root.row.d === true && root.targetPane !== null && !root.targetPane.listInFlight))
+        keys: [DragOps.ROWS_MIME, "text/uri-list", "text/plain"]
+        onEntered: function (drag) { root.enterAt(drag, drag) }
+        onPositionChanged: function (drag) { root.moveAt(drag) }
+        onExited: root.leaveRow()
+        onDropped: function (drop) { root.dropAt(drop) }
+    }
+
+    // A drop area's entrance, at a point in this row's own coordinates: the per-row area passes its drag, a shared one the mapped point.
+    function enterAt(drag, at) {
+        // xw6: a tab drag carries only the private tab type and is never a file drop.
+        if (drag.getDataAsString(Tabs.TAB_MIME) !== "") {
+            drag.accepted = false
+            return
+        }
+        drag.accepted = root.enter(drag.getDataAsString(DragOps.ROWS_MIME), drag.urls,
+                                   drag.getDataAsString(DragOps.SHELF_MIME),
+                                   drag.getDataAsString("text/plain"), drag.proposedAction,
+                                   drag.getDataAsString(DragOut.keys.liftMime))
+        root.hoverAt(at)
+    }
+
+    function moveAt(at) {
+        if (root.lit()) {
+            root.session.showTarget(root.row.n, root.destDev)
+            root.hoverAt(at)
+        }
+    }
+
+    function leaveAt() { root.leaveRow() }
+
+    function dropAt(drop) {
+        if (drop.getDataAsString(Tabs.TAB_MIME) !== "")
+            return
+        var marker = drop.getDataAsString(DragOps.ROWS_MIME)
+        var shelf = drop.getDataAsString(DragOps.SHELF_MIME)
+        var plain = drop.getDataAsString("text/plain")
+        if (root.refuseDrop(marker, drop.urls, shelf, plain)) return
+        if (root.dropped(marker, drop.urls, shelf, plain, drop.proposedAction)) {
+            drop.accept(Qt.CopyAction)
+        }
+        root.session.hoverEnded()
+    }
+
+    // The pointer leaves this delegate: the destination it recorded goes, even when a swap reused the delegate on another row, and a destination another row recorded since stays.
+    function leaveRow() {
+        if (root.recorded.length > 0 && root.session.dropDest === root.recorded) {
+            root.session.dropIndex = -1
+            root.session.dropDest = ""
+            root.session.dropDestDev = 0
+            root.session.leaveTarget()
+        }
+        root.recorded = ""
+        if (root.session.dragRows.length === 0) {
+            root.session.dragCopy = false
+            root.session.dragLink = false
+        }
+        root.session.hoverEnded()
+        DragOut.keys.leave()
+    }
+
+    // One reset for every finished gesture, refused or dropped: the drag's keys end and the row goes dark again.
+    function clearTarget() {
+        DragOut.keys.clear()
+        root.session.dropIndex = -1
+        root.session.dropDest = ""
+        root.session.dropDestDev = 0
+        root.session.dragCopy = false
+        root.session.dragLink = false
+        root.session.leaveTarget()
+    }
+
+    // Testable entrance: a refused folder row stays dark and names its refusal, never lighting "move here" for a drop that cannot land.
+    function enter(marker, urls, shelf, plain, proposed, lift) {
+        if (!(root.row && root.row.d === true)) return false
+        var dest = root.targetPane.join(root.targetDir, root.row.n)
+        var line = ""
+        var ok = false
+        if (DragOps.hasPaths(urls) || (plain && !marker)) {
+            line = DragOut.refusal(DragOut.sources(urls, plain, marker, ""), dest, marker, "")
+            ok = line === "" && DragOps.canDropInto(marker, urls, dest, plain)
+        } else if (root.dropScope === null) {
+            ok = DragOps.canDropByIndex(marker, root.targetDir, root.session.dragRows, root.listingIndex)
+        }
+        if (!ok) {
+            if (line) root.targetPane.message(line, false)
+            return false
+        }
+        root.session.dropIndex = root.listingIndex
+        // The drop's own address: the swap may rebuild this delegate on another row before the release.
+        root.session.dropDest = dest
+        root.session.dropDestDev = root.destDev
+        root.recorded = dest
+        if (root.targetPane.columnsArea) root.targetPane.columnsArea.askDropDevs(lift)
+        DragOut.keys.enter(marker, lift)
+        root.session.enterTarget(marker, urls, root.row.n, root.destDev, shelf, proposed)
+        return true
+    }
+
+    // Lit means this delegate still shows the hovered folder: after a swap the index may name another row.
+    function lit() {
+        return root.session.dropIndex === root.listingIndex && !!root.row
+                && root.session.dropDest === root.targetPane.join(root.targetDir, root.row.n)
+    }
+
+    // Where a drop lands: the recorded hovered folder, else this row's own folder, since a swap may have reused the delegate.
+    function landing() {
+        if (root.session.dropDest.length > 0) return { dest: root.session.dropDest, dev: root.session.dropDestDev }
+        var folder = root.row && root.row.d === true
+        return { dest: folder ? root.targetPane.join(root.targetDir, root.row.n) : "", dev: folder ? root.destDev : 0 }
+    }
+
+    // Testable refusal: says the sentence and darkens exactly like dropped(), so a refused
+    // drop never leaves the row lit (Qt sends dropped, not exited, after the drop).
+    function refuseDrop(marker, urls, shelf, plain) {
+        var dest = root.landing().dest
+        if (!dest) return ""
+        var line = DragOut.refusal(DragOut.sources(urls, plain, marker, shelf), dest, marker, shelf)
+        if (!line) return ""
+        root.targetPane.message(line, false)
+        root.clearTarget()
+        return line
+    }
+
+    // The drop apart from its platform event, which tests/js/collide.js cannot build: answers whether it was taken.
+    function dropped(marker, urls, shelf, plain, proposed) {
+        var accepted = false
+        var at = root.landing()
+        if (at.dest.length > 0) {
+            if (DragOps.hasPaths(urls) || (plain && !marker && !shelf))
+                accepted = DragOps.dropInto(root.targetPane, marker, urls, at.dest, at.dev, shelf, plain, proposed, DragOut.keys.ctrl, DragOut.keys.shift)
+            else if (root.dropScope === null
+                     && DragOps.canDropByIndex(marker, root.targetDir, root.session.dragRows, root.listingIndex))
+                accepted = DragOps.dropByIndex(root.targetPane, root.session.dragRows, root.listingIndex,
+                    root.session.verbAt(marker, root.row, DragOut.keys.ctrl, DragOut.keys.shift), root.session.dragListing)
+        }
+        root.clearTarget()
+        return accepted
+    }
+
+    // In the view's own coordinates, so the band reads the listing, not the row.
+    function hoverAt(at) {
+        if (root.dropScope !== null || !at)
+            return
+        var viewer = root.session.pane
+        var list = viewer ? viewer.listArea : null
+        if (!list || !viewer || root.targetDir !== Search.baseOf(viewer))
+            return
+        var pt = root.mapToItem(list, at.x, at.y)
+        if (root.lit())
+            root.session.hoverBegan(root.listingIndex, root.targetPane.join(root.targetDir, root.row.n), pt.y, list.height)
+        else
+            root.session.hoverMoved(pt.y, list.height)
+    }
+}

package/ui/RowDropTarget.qml

@@ -0,0 +1,27 @@
+import QtQuick
+import "js/Drag.js" as DragOps
+
+// The file row's shared drop cue and clipboard mark, compiled only when either is drawn.
+DropTarget {
+    id: root
+
+    required property var row
+    property alias mark: clipGlyph
+    anchors.fill: parent
+    shown: root.row.dropTarget
+    paintWidth: root.row.paintWidth
+    text: DragOps.label(root.row.dropCopying, root.row.dropLinking)
+
+    // A clipboard row under a drag keeps its mark beside the label, one pixel above the text centre line.
+    Glyph {
+        id: clipGlyph
+        visible: root.row.clipMark.length > 0 && !root.row.renaming && !root.row.searching
+        width: root.row.clipPx
+        height: root.row.clipPx
+        x: root.row.clipMark.length > 0 ? root.row.nameItem().x + Math.min(root.row.nameItem().implicitWidth, root.row.nameItem().width) + Theme.spacing.gap : 0
+        anchors.verticalCenter: parent.verticalCenter
+        anchors.verticalCenterOffset: -1
+        name: root.row.clipMark
+        color: Theme.color.mutedFrame
+    }
+}

package/ui/RunCard.qml

@@ -0,0 +1,286 @@
+import Quickshell
+import Quickshell.Io
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/RunFile.js" as RunFile
+
+// Opening an executable file asks once, in this one card: Cancel, Open as text, Run and Run in terminal, with the ring on the default. An AppImage the desktop names a handler for offers that application first, by its own name, and focuses it instead.
+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 path: ""
+    property string kind: "script"
+    property double size: 0
+    // The listed path the ask was opened from, which names the row; path names the resolved target it runs.
+    property string listedPath: ""
+    property bool hasHandler: false
+    property string handlerId: ""
+    property string handlerName: ""
+    // The mark the listing draws for the asked row, read once at open.
+    property string listedGlyph: ""
+    // dev and ino stay strings end to end: a double cannot hold every 64-bit value exactly.
+    property string dev: ""
+    property string ino: ""
+    property double mtimeS: 0
+    property double mtimeNs: 0
+    property string tweak: ""
+    property var pane: null
+    readonly property string fileName: RunFile.leafOf(root.path)
+    readonly property var buttons: RunFile.buttonsFor(root.kind, root.hasHandler)
+    // The board's own default: the handler where one is named, Run in terminal elsewhere.
+    readonly property string defaultName: RunFile.defaultButton(root.kind, root.hasHandler)
+    property string focusName: RunFile.START
+    // The card's own single-flight run lane, one per window: a second press while one runs is refused out loud, never queued.
+    property string runCurrent: ""
+    property string runAction: ""
+    readonly property int isDirectoryStatus: 3
+    // The run card's own failures, the same numbers src/runfile.rs answers with.
+    readonly property int runChangedStatus: 6
+    readonly property int runNoExecStatus: 7
+    readonly property int runSpawnStatus: 8
+    readonly property int runHandlerGoneStatus: 9
+    readonly property var cardItem: card
+    readonly property string titleText: title.text
+    readonly property bool buttonsFit: buttons.width <= body.holderWidth
+    function buttonItem(name) {
+        var at = root.buttons.indexOf(name)
+        return at >= 0 ? buttonRow.itemAt(at) : null
+    }
+    // One shot: the ask's raw text is parsed here so the card names the resolved target, and the next open re-derives the ring.
+    function open(info, pane) {
+        var ask = RunFile.parseAsk(info.raw || "")
+        if (ask === null) {
+            if (pane) pane.message("Flea could not check that file, so it was not run.", true)
+            return
+        }
+        root.pane = pane
+        root.path = ask.target
+        root.listedPath = info.path || ask.target
+        root.kind = ask.kind
+        root.size = ask.size
+        root.hasHandler = ask.hasHandler
+        root.handlerId = ask.handlerId
+        root.handlerName = ask.handlerName
+        root.listedGlyph = RunFile.listedGlyph(pane, root.listedPath)
+        root.dev = ask.dev
+        root.ino = ask.ino
+        root.mtimeS = ask.mtimeS
+        root.mtimeNs = ask.mtimeNs
+        root.tweak = info.tweak || ""
+        root.focusName = RunFile.startFocus(root.buttons, root.tweak)
+        body.contentY = 0
+        root.opened = true
+        root.forceActiveFocus()
+    }
+    // Closing hands the keyboard back to the asking pane, whatever closed it.
+    function close() {
+        root.opened = false
+        if (root.pane) root.pane.forceActiveFocus()
+    }
+    // A press lands on its own button first, so the accent never shows one choice while another is taken.
+    function press(choice) {
+        root.focusName = choice
+        root.choose(choice)
+    }
+    function launch(action, command, path) {
+        if (runChild.running) {
+            root.pane.message("Still running the last file; try again in a moment.", false)
+            return
+        }
+        root.runAction = action
+        root.runCurrent = path
+        runChild.command = command
+        runChild.running = true
+    }
+    // Sample argv: flea --run /home/gm/tool.sh <the card's identity>, never a shell string.
+    function run(path, dev, ino, size, mtimeS, mtimeNs) {
+        root.launch("run", [Quickshell.env("FLEA_BIN") || "flea", "--run", path, dev, ino, size, mtimeS, mtimeNs], path)
+    }
+    function runTerminal(path, dev, ino, size, mtimeS, mtimeNs) {
+        root.launch("terminal", [Quickshell.env("FLEA_BIN") || "flea", "--run-terminal", path, dev, ino, size, mtimeS, mtimeNs], path)
+    }
+    function openText(path, pane) {
+        if (pane) root.pane = pane
+        root.launch("text", [Quickshell.env("FLEA_BIN") || "flea", "--open-text", path], path)
+    }
+    // Sample argv: flea --open-handler /home/gm/app.AppImage appimagelauncher.desktop <the card's identity>.
+    function openHandler(path, id, dev, ino, size, mtimeS, mtimeNs) {
+        root.launch("handler", [Quickshell.env("FLEA_BIN") || "flea", "--open-handler", path, id, dev, ino, size, mtimeS, mtimeNs], path)
+    }
+    // The choice lands on the pane that asked, through ui/js/RunFile.js.
+    function choose(choice) {
+        root.close()
+        RunFile.choose(root.pane, root, choice)
+    }
+    // A held key never presses the default: repeats move nothing and run nothing.
+    function keyPressed(key, autoRepeat, modifiers) {
+        if (key === Qt.Key_Escape) { root.choose("cancel"); return }
+        if (modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) return
+        if (autoRepeat === true) return
+        if (RunFile.activates(key)) root.choose(root.focusName)
+        else root.focusName = RunFile.moved(root.buttons, root.focusName, key, modifiers)
+        if (root.opened) body.reveal(root.buttonItem(root.focusName))
+    }
+    Keys.onPressed: function (event) {
+        root.keyPressed(event.key, event.isAutoRepeat, event.modifiers)
+        event.accepted = true
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    Process {
+        id: runChild
+
+        onExited: function (exitCode, exitStatus) {
+            var action = root.runAction
+            var path = root.runCurrent
+            root.runAction = ""
+            root.runCurrent = ""
+            if (exitCode === 0)
+                return
+            if (exitCode === root.isDirectoryStatus) {
+                root.pane.open(path)
+                return
+            }
+            if (exitCode === root.runChangedStatus) {
+                root.pane.message(action === "handler" ? "That file changed after Flea checked it, so it was not opened."
+                    : "That file changed after Flea checked it, so it was not run.", true)
+                return
+            }
+            if (exitCode === root.runNoExecStatus) {
+                root.pane.message("That program is on a volume that does not allow running files.", true)
+                return
+            }
+            if (exitCode === root.runHandlerGoneStatus) {
+                root.pane.message("That application is no longer installed.", true)
+                return
+            }
+            if (exitCode === root.runSpawnStatus) {
+                if (action === "run")
+                    root.pane.message("Nothing on this system could run that file.", true)
+                else if (action === "terminal")
+                    root.pane.message("Nothing on this system could run that file in a terminal.", true)
+                else if (action === "handler")
+                    root.pane.message("Nothing on this system could be asked to open that file.", true)
+                else
+                    root.pane.message("Nothing on this system could open that file as text.", true)
+                return
+            }
+            if (action === "run")
+                root.pane.message("That program could not be run.", true)
+            else if (action === "terminal")
+                root.pane.message("That program could not be run in a terminal.", true)
+            else if (action === "handler")
+                root.pane.message("That application did not open the file.", true)
+            else
+                root.pane.message("No text editor opened that file.", true)
+        }
+    }
+    Flea.DialogScrim {
+        onDismissed: root.choose("cancel")
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        // The board's own 448, grown by the text size the way the collision card is.
+        width: Theme.cardSpan(card.contentWidth + 2 * card.cardPadding + 2 * Theme.spacing.hairline, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + card.cardPadding + card.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
+        readonly property real referenceScale: Theme.font.bodySmall / referenceBody
+        readonly property real cardPadding: Math.round(cardPad * referenceScale)
+        readonly property real cardBottomPadding: Math.round(cardBottomPad * referenceScale)
+        // RunFile's buttons keep 6 px of air over the gap.
+        readonly property real buttonsAir: Math.round(buttonsPad * referenceScale)
+        // The board's 414 content, since four buttons at DialogButton's pad and gap need 409.
+        readonly property real contentWidth: Math.max(card.boardContent, buttons.implicitWidth)
+        // The board's own reference size, pad and content width, so no bare number sits in an expression.
+        readonly property real referenceBody: 13
+        readonly property real cardPad: 16
+        readonly property real cardBottomPad: 12
+        readonly property real buttonsPad: 6
+        readonly property real contentBase: 414
+        readonly property real boardContent: Math.round(contentBase * referenceScale * Theme.dialogWidthRatio)
+        // The handler's name elides inside what the board's content leaves beside the other buttons, so a long name never widens the card.
+        readonly property real handlerRoom: {
+            var used = 0
+            for (var i = 0; i < buttonRow.count; i++) {
+                var item = buttonRow.itemAt(i)
+                if (item && item.modelData !== "handler") used += item.implicitWidth + buttons.spacing
+            }
+            return Math.max(Theme.hitMin, card.boardContent - used - 2 * Theme.spacing.gap - 2 * Theme.spacing.hairline)
+        }
+        TextMetrics {
+            id: handlerLabel
+            font.family: Theme.font.family
+            font.pixelSize: Theme.font.body
+            elide: Text.ElideRight
+            elideWidth: card.handlerRoom
+            text: root.handlerName
+        }
+        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: card.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.rightMargin: card.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.topMargin: card.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.bottomMargin: card.cardBottomPadding + Theme.spacing.hairline - Theme.focusClearance
+            title: Flea.DialogHeader {
+                id: title
+                width: parent.width
+                text: RunFile.titleFor(root.fileName)
+            }
+            buttons: Row {
+                id: buttons
+                anchors.right: parent.right
+                topPadding: card.buttonsAir
+                spacing: Theme.spacing.gap
+                Repeater {
+                    id: buttonRow
+                    model: root.buttons
+                    Flea.DialogButton {
+                        required property string modelData
+                        label: RunFile.labelFor(modelData, handlerLabel.elidedText) || modelData
+                        primary: modelData === root.defaultName
+                        focused: root.focusName === modelData
+                        onActivated: root.press(modelData)
+                    }
+                }
+            }
+            Row {
+                width: parent.width
+                height: Theme.fileRowHeight
+                spacing: Theme.spacing.gap
+                Flea.Glyph {
+                    width: Theme.markSize
+                    height: parent.height
+                    name: RunFile.glyphFor(root.kind, root.listedGlyph)
+                    color: Theme.color.foreground
+                }
+                Text {
+                    width: Math.max(0, parent.width - Theme.markSize - parent.spacing)
+                    anchors.verticalCenter: parent.verticalCenter
+                    text: RunFile.subtitleFor(root.kind, root.size)
+                    textFormat: Text.PlainText
+                    elide: Text.ElideRight
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.body }
+                }
+            }
+        }
+    }
+}

package/ui/Scripts.qml

@@ -0,0 +1,65 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/Scripts.js" as Model
+
+// MenuAdditions rule 2: the scripts a menu can run, read out of ~/.config/flea/scripts when a menu
+// opens rather than watched, and run with the selected paths as arguments in the first one's folder.
+// The one thing here that touches the outside world, the way ui/NetworkMounts.qml is for gio.
+Item {
+    id: root
+
+    // [{ id, label, path }], sorted by name, the label the file name without its extension.
+    property var entries: []
+    property bool loaded: false
+    readonly property string directory: (Quickshell.env("XDG_CONFIG_HOME") && Quickshell.env("XDG_CONFIG_HOME").length > 0
+                                         ? Quickshell.env("XDG_CONFIG_HOME") : Quickshell.env("HOME") + "/.config") + "/flea/scripts"
+
+    signal said(string text, bool isError)
+
+    function refresh() {
+        if (!lister.running)
+            lister.running = true
+    }
+
+    function run(id, paths) {
+        var script = ""
+        for (var i = 0; i < root.entries.length; i++)
+            if (root.entries[i].id === id) script = root.entries[i].path
+        if (script.length === 0 || paths.length === 0) {
+            root.said("That script is no longer there.", true)
+            return
+        }
+        runner.script = script
+        runner.workingDirectory = paths[0].substring(0, paths[0].lastIndexOf("/")) || "/"
+        runner.command = [script].concat(paths)
+        runner.running = true
+    }
+
+    // An executable regular file, one level down and nothing else: a directory of scripts is a flat
+    // one, and -perm -u+x is the owner bit the board names.
+    Process {
+        id: lister
+        command: ["find", root.directory, "-maxdepth", "1", "-type", "f", "-perm", "-u+x", "-printf", "%f\\n"]
+        stdout: StdioCollector {
+            waitForEnd: true
+            onStreamFinished: {
+                root.entries = Model.parse(text, root.directory)
+                root.loaded = true
+            }
+        }
+    }
+
+    // A script's own last stderr line is the report, elided to one sentence by the status centre.
+    Process {
+        id: runner
+        property string script: ""
+        stderr: StdioCollector { waitForEnd: true }
+        onExited: function (code, status) {
+            if (code === 0)
+                return
+            root.said(Model.failure(runner.script.substring(runner.script.lastIndexOf("/") + 1), runner.stderr.text, code), true)
+        }
+    }
+}