flea-qml 0.0.0-stage → 0.1.0

package/ui/ShareBrowser.qml

@@ -0,0 +1,113 @@
+import QtQuick
+import "." as Flea
+
+// Shows a bare smb://host/'s own shares as ordinary pane rows, the same instantiated-from-shell
+// overlay pattern as ui/EmptyState.qml; see ui/NetworkMounts.qml "listShares" for the source data.
+Item {
+    id: root
+
+    property bool active: false
+    property string baseUri: ""
+    property string baseLabel: ""
+    property var shares: []
+    property int cursorIndex: 0
+
+    signal closed()
+    // The resolved share uri and name, the same shape openShare() already takes for a bookmarked share; ui/WindowBody.qml routes this through the window-long host's openChildShare.
+    signal activated(string uri, string label)
+
+    // active flips instantly (open()/close() below), so shareBrowserOpen()'s IPC read never races
+    // the close fade; visible only stays true a little longer, until content's opacity finishes it.
+    visible: root.active || content.opacity > 0
+
+    // The fade and the rise are the shared reveal of ui/Reveal.qml, built by the first open so a window that never browses shares holds none.
+    property var fade: null
+    onActiveChanged: {
+        if (root.active && root.fade === null)
+            root.fade = Qt.createComponent("Reveal.qml").createObject(root, { target: content, shown: Qt.binding(function () { return root.active }), lift: content })
+    }
+
+    function open(uri, label, names) {
+        root.baseUri = uri
+        root.baseLabel = label
+        root.shares = names
+        root.cursorIndex = 0
+        root.active = true
+    }
+
+    // Idempotent, so wiring this to every Pane navigation (including one this overlay itself just requested) costs nothing once already shut.
+    function close() {
+        if (!root.active)
+            return
+        root.active = false
+        root.closed()
+    }
+
+    function moveCursor(delta) {
+        if (root.shares.length === 0)
+            return
+        root.cursorIndex = Math.max(0, Math.min(root.shares.length - 1, root.cursorIndex + delta))
+    }
+
+    function activateCursor() {
+        var name = root.shares[root.cursorIndex]
+        if (name === undefined)
+            return
+        var base = root.baseUri.charAt(root.baseUri.length - 1) === "/" ? root.baseUri : root.baseUri + "/"
+        root.activated(base + name + "/", name)
+    }
+
+    // Everything visible sits under this one Item so open/close can animate it as a unit; root
+    // itself stays plain (no x/y/opacity) so anchors.fill callers of ShareBrowser are unaffected.
+    Item {
+        id: content
+        x: 0
+        width: root.width
+        height: root.height
+        // Closed means no input, even while the fade-out is still drawn; ui/Reveal.qml owns the fade and the rise.
+        enabled: root.active
+        opacity: 0
+
+        // Opaque so the real listing behind it, still rendering, never shows or flickers through.
+        Rectangle {
+            anchors.fill: parent
+            color: Theme.color.background
+        }
+
+        // Swallows clicks in the gap below the rows so they cannot reach the hidden list beneath.
+        MouseArea {
+            anchors.fill: parent
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            hoverEnabled: true
+            onClicked: {}
+            onWheel: function (wheel) { wheel.accepted = true }
+        }
+
+        Column {
+            anchors.fill: parent
+
+            Repeater {
+                model: root.shares
+
+                // Network.dc.html draws the sidebar's own server mark and the share name, and no
+                // columns: nothing is known about a share until it is mounted, so a "-" size and a
+                // "--" date were columns of nothing. ui/MenuRow.qml is the mark-and-label row.
+                delegate: Flea.MenuRow {
+                    id: shareRow
+                    required property int index
+                    required property string modelData
+                    width: root.width
+                    entry: ({ label: shareRow.modelData, action: "", glyph: "server" })
+                    // The keyboard cursor is the pick and takes the accent; the pointer only lifts
+                    // the row it is over, which is what ui/Row.qml did here before.
+                    picked: shareRow.index === root.cursorIndex
+                    current: shareRow.hovered
+                    onActivated: {
+                        root.cursorIndex = shareRow.index
+                        root.activateCursor()
+                    }
+                }
+            }
+        }
+    }
+}

package/ui/ShareLink.qml

@@ -0,0 +1,67 @@
+import Quickshell
+import Quickshell.Io
+import QtQuick
+
+Item {
+    id: root
+
+    signal copied(string url)
+    signal failed(string reason)
+
+    property string pending: ""
+    property string pendingUrl: ""
+    property bool _shareAwaitingStart: false
+    property string _shareOutput: ""
+
+    function copy(path) {
+        if (pending.length > 0) {
+            root.failed("A share link is still being copied; try again when it finishes.")
+            return
+        }
+        if (typeof path !== "string" || path.charAt(0) !== "/" || path.indexOf("\u0000") >= 0) {
+            root.failed("Flea could not find that file's location, so no share link was made.")
+            return
+        }
+        root.pending = path
+        root._shareOutput = ""
+        root._shareAwaitingStart = true
+        // DropboxCommand bounds each socket operation itself; a total deadline would shorten that contract.
+        sharelink.command = ["dropbox-cli", "sharelink", path]
+        sharelink.running = true
+    }
+
+    function finish(reason) {
+        if (pending.length === 0) return
+        var url = pendingUrl
+        pending = ""
+        pendingUrl = ""
+        _shareAwaitingStart = false
+        if (reason) root.failed(reason)
+        else root.copied(url)
+    }
+
+    Process {
+        id: sharelink
+        stdout: StdioCollector { id: out; waitForEnd: true; onStreamFinished: root._shareOutput = text }
+        onStarted: root._shareAwaitingStart = false
+        onRunningChanged: {
+            if (root._shareAwaitingStart && !running)
+                root.finish("Dropbox could not be asked for a share link.")
+        }
+
+        onExited: function (exitCode) {
+            root._shareAwaitingStart = false
+            if (root.pending.length === 0) return
+            var url = (out.text || root._shareOutput).trim()
+            // Sample output: https://www.dropbox.com/s/example/file.txt?dl=0; exit-zero error text is not a URL.
+            if (exitCode !== 0 || !/^https?:\/\/[^/\s?#]+(?:[/?#][^\s]*)?$/.test(url)) {
+                root.finish("Dropbox could not make a share link for that file.")
+                return
+            }
+            root.pendingUrl = url
+            // flea-qml: the link is plain text, so Quickshell's own clipboard takes it rather than wl-copy.
+            Quickshell.clipboardText = url
+            root.finish("")
+        }
+    }
+}

package/ui/ShelfPins.qml

@@ -0,0 +1,101 @@
+pragma Singleton
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/ShelfPile.js" as ShelfPile
+
+// SettingsRest rule 4: the pins the Settings panel lists are the shelf's own entries, read from the
+// pile the bar plugin reads and written through the same `flea shelf` calls the card makes, so the
+// panel and the card can never disagree about what is pinned.
+QtObject {
+    id: root
+
+    readonly property string pileFile: (Quickshell.env("XDG_STATE_HOME") || Quickshell.env("HOME") + "/.local/state")
+                                       + "/omarchy/flea-shelf/shelf.json"
+    property var records: []
+    property string lastError: ""
+
+    readonly property var pile: FileView {
+        path: root.pileFile
+        watchChanges: true
+        // A home that has pinned nothing has no pile file, which onLoadFailed answers with no rows.
+        printErrors: false
+        onFileChanged: reload()
+        onLoaded: root.records = ShelfPile.pinned(text())
+        onLoadFailed: root.records = []
+    }
+
+    // What the running call was, so a refusal names it, and the one waiting behind it: a pin pressed
+    // while the last one is still running is answered rather than dropped.
+    property string running: ""
+    property var waiting: []
+
+    readonly property var writer: Process {
+        running: false
+        onExited: function (code) {
+            root.lastError = code === 0 ? "" : root.running === "unpin" ? "The shelf could not unpin that item." : "The shelf could not pin that item."
+            root.running = ""
+            root.pile.reload()
+            // Drained from the event loop because the process is still running inside this handler,
+            // and the row stays in the queue until it starts so a call arriving then cannot jump it.
+            if (root.waiting.length > 0) {
+                Qt.callLater(root.drain)
+            }
+        }
+    }
+
+    function pin(path) {
+        root.run(["shelf", "pin", path])
+    }
+
+    function unpin(path) {
+        root.run(["shelf", "unpin", path])
+    }
+
+    // Rule 4: the pins are a list the operator orders, and their order is the pile's own.
+    function move(path, direction) {
+        root.moveTo(path, root.at(path) + direction)
+    }
+
+    function moveTo(path, to) {
+        if (root.at(path) < 0 || to < 0 || to >= root.records.length) {
+            return
+        }
+        root.run(["shelf", "order", path, String(to)])
+    }
+
+    function at(path) {
+        for (var i = 0; i < root.records.length; i++) {
+            if (root.records[i].path === path) {
+                return i
+            }
+        }
+        return -1
+    }
+
+    function run(args) {
+        // Anything already waiting goes first, or a call arriving while the queue drains would jump
+        // it and land a pin and its unpin the wrong way round.
+        if (root.writer.running || root.waiting.length > 0) {
+            root.waiting = root.waiting.concat([args])
+            return
+        }
+        root.lastError = ""
+        root.start(args)
+    }
+
+    function drain() {
+        if (root.writer.running || root.waiting.length === 0) {
+            return
+        }
+        var next = root.waiting[0]
+        root.waiting = root.waiting.slice(1)
+        root.start(next)
+    }
+
+    function start(args) {
+        root.running = args[1]
+        root.writer.command = [Quickshell.env("FLEA_BIN") || "flea"].concat(args)
+        root.writer.running = true
+    }
+}