flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Drag.js

@@ -0,0 +1,360 @@
+.pragma library
+
+.import "DragOut.js" as DragOut
+.import "Search.js" as Search
+.import "Ops.js" as Ops
+.import "Format.js" as Format
+.import "Swap.js" as Swap
+
+// A drop is a gesture that calls the transfer request Ops.moveToDropbox already sends, with the folder
+// row under the pointer as its destination, so there is no second copy path here. States.dc.html
+// "Drop target": the hovered folder takes the accent frame and reads "move here", and copy versus
+// move reads in the status bar. ui/List.qml wires the handlers; this file decides.
+
+// The rows a drag carries: the whole selection when the pressed row is in it, that row alone when it
+// is not. One file dropped when five were selected is a data surprise; five moved when the operator
+// grabbed one is a worse one, so the pressed row decides which the drag means.
+function carried(pane, index) {
+    var picked = pane.selectedIndices()
+    for (var i = 0; i < picked.length; i++) {
+        if (picked[i] === index) {
+            return picked
+        }
+    }
+    return [index]
+}
+
+// Ctrl copies, Shift moves, Ctrl with Shift links, read at the lift and again at the drop from the key events DragOut.keys tracks during the drag.
+function copying(modifiers) {
+    return (modifiers & Qt.ControlModifier) !== 0
+}
+
+function shifting(modifiers) {
+    return (modifiers & Qt.ShiftModifier) !== 0
+}
+
+function linking(modifiers) {
+    return copying(modifiers) && shifting(modifiers)
+}
+
+// A seen value of 1 is held at the drop, 0 is released before it, and -1 keeps the lift bit.
+function dropHeld(lift, seen) {
+    if (seen === 1) return true
+    if (seen === 0) return false
+    return lift
+}
+
+// Only a directory row takes a drop, and never one the drag itself carries: a folder cannot move into
+// itself, and a selection holding the target is refused whole rather than moved in part.
+function canDrop(rows, index, row) {
+    if (!row || row.d !== true) {
+        return false
+    }
+    return rows.indexOf(index) < 0
+}
+
+// Whole sentences with "%1" for the item count and "%2" for the folder name; the keys held at the drop decide copy or move (dropHeld, ui/RowDrag.qml verbAt).
+var WORDS = {
+    linkTo: "Link %1 to %2",
+    linkToFolder: "Link %1 to a folder",
+    copyTo: "Copy %1 to %2",
+    copyToFolder: "Copy %1 to a folder",
+    moveTo: "Move %1 to %2 · Ctrl copies, Shift moves",
+    moveToFolder: "Move %1 to a folder · Ctrl copies, Shift moves"
+}
+
+// The board's own words on the hovered folder.
+function label(copy, link) {
+    if (link === true) return "link here"
+    return copy ? "copy here" : "move here"
+}
+
+// The hint names the keys held at the drop, so a key pressed after the lift counts once DragOut.keys saw it.
+function line(n, name, copy, link) {
+    var named = name.length > 0
+    var template = link === true ? (named ? WORDS.linkTo : WORDS.linkToFolder)
+        : copy ? (named ? WORDS.copyTo : WORDS.copyToFolder)
+        : (named ? WORDS.moveTo : WORDS.moveToFolder)
+    return Format.fill(template, Ops.items(n), name)
+}
+
+// The by-index drop is the only path a too-wide selection takes, onto its own listing, with links through the Paste-as-links card.
+function dropByIndex(pane, rows, index, verb, listing) {
+    var row = pane.rowFor(index)
+    if (!canDrop(rows, index, row)) {
+        return false
+    }
+    var dest = pane.join(Search.baseOf(pane), row.n)
+    if (verb === "link") {
+        return pane.asks().ask(Swap.named({ c: "link", op: "relative", rows: rows, dest: dest }, listing))
+    }
+    return pane.asks().ask(Swap.named({ c: "transfer", op: verb, rows: rows, dest: dest }, listing))
+}
+
+// The type Flea's own drag carries alongside the uri-list. The compositor hands a window's own
+// platform drag back to that window's own DropAreas, so without a marker an internal move would be
+// indistinguishable from a foreign drop, take the always-copy path below, and leave the source behind
+// while still looking like it worked.
+var ROWS_MIME = "application/x-flea-rows"
+
+// DragOut rule 4: Flea is the one named receiver of a shelf drag. The payload is the single-use
+// token the shelf minted and the intent it fixed at the lift, in that order, one per line. The token
+// is the authority: the backend reads the entries and the intent out of its own record, and this
+// second line is only so the receiver can say the right word before the drop lands.
+var SHELF_MIME = "application/x-flea-shelf"
+
+function shelfToken(payload) {
+    return String(payload || "").split("\n")[0]
+}
+
+function shelfCopying(payload) {
+    return String(payload || "").split("\n")[1] === "copy"
+}
+
+// A value unique to this running Flea. ROWS_MIME names the application, and two Flea windows are two
+// processes: a drag from the other one carries row indices that mean nothing in this listing, so the
+// instance has to be identifiable on its own or the receiver takes the internal path against a
+// selection it never made and the drop does nothing at all.
+var INSTANCE = String(Date.now()) + "-" + String(Math.floor(Math.random() * 1000000000))
+var lifted = { marker: "", backend: null }
+
+// False only when the listed directory cannot be written, which makes a same-device drag copy.
+function listingDeletable(pane) {
+    return !(pane && pane.backend && pane.backend.dirWritable === false)
+}
+
+// One marker, not two mime types, carrying sender, rows and lift bits (fields: 0 sender, 1 rows, 2 ctrl, 3 source, 4 device, 5 deletable, 6 shift, 7 listing).
+function markerPayload(rows, copy, source, dev, deletable, shift, listing) {
+    return INSTANCE + "\n" + rows.join(",") + "\n" + (copy ? "copy" : "move") + "\n" + encodeURIComponent(String(source || "")) + "\n" + String(dev || 0) + "\n" + (deletable === false ? "0" : "1") + "\n" + (shift === true ? "1" : "0") + "\n" + String(listing || 0)
+}
+
+var MARKER_FIELDS = 8
+var SHIFT_MARKER_FIELDS = 7
+var LEGACY_MARKER_FIELDS = 5
+var DELETABLE_MARKER_FIELDS = 6
+
+// Five- and six-field legacy markers have raw paths; current markers percent-encode the path field.
+// Sample input: "foreign\n2\nmove\n%2Ftmp%2Fsource\n56\n1\n1\n7".
+function markerFields(payload) {
+    var fields = String(payload).split("\n")
+    if ([LEGACY_MARKER_FIELDS, DELETABLE_MARKER_FIELDS, SHIFT_MARKER_FIELDS, MARKER_FIELDS].indexOf(fields.length) < 0)
+        return null
+    if (!/^-?[0-9]+$/.test(fields[4]) || (fields[2] !== "copy" && fields[2] !== "move")) return null
+    if (fields.length >= DELETABLE_MARKER_FIELDS && fields[5] !== "0" && fields[5] !== "1") return null
+    if (fields.length >= SHIFT_MARKER_FIELDS) {
+        if (fields[6] !== "0" && fields[6] !== "1") return null
+        try { decodeURIComponent(fields[3]) } catch (error) { return null }
+    }
+    if (fields.length === MARKER_FIELDS && !/^[0-9]+$/.test(fields[7])) return null
+    return fields
+}
+
+// The directory the rows were lifted from, and its filesystem, both baked at the lift: a drop that
+// lands after the listing changed under the drag, which hovering a tab now does, cannot use the row
+// indices any more and resolves by path against these instead.
+function markerSource(payload) {
+    var fields = markerFields(payload)
+    return fields ? (fields.length >= SHIFT_MARKER_FIELDS ? decodeURIComponent(fields[3]) : fields[3]) : ""
+}
+
+function markerDev(payload) {
+    var fields = markerFields(payload)
+    return fields ? Number(fields[4]) || 0 : 0
+}
+
+// Legacy markers carry no listing generation and cannot authorize a Trash drop by index.
+function markerListing(payload) {
+    var fields = markerFields(payload)
+    return fields && fields.length === MARKER_FIELDS ? Number(fields[7]) || 0 : 0
+}
+
+function markerShift(payload) {
+    var fields = markerFields(payload)
+    return !!fields && fields[6] === "1"
+}
+
+// Missing means the source can be deleted. Only an explicit 0 copies a same-device drag.
+function markerDeletable(payload) {
+    var fields = markerFields(payload)
+    return !!fields && fields[5] !== "0"
+}
+
+// Whether the listing under the drop is still the one the rows were lifted from, which is the only
+// case the by-index transfer is safe in.
+function sameListing(payload, path) {
+    return isOwnDrag(payload) && markerSource(payload) === path
+}
+
+// Equal listing generations in two pane backends still number different rows.
+function liftedBy(marker, backend) {
+    return !!backend && backend === lifted.backend && marker === lifted.marker
+}
+
+// Whether a drag carries at least one local path, which is what decides a drop resolves by path.
+function hasPaths(urls) {
+    return DragOut.filePaths(urls).length > 0
+}
+
+// The by-index drop's gate: only a selection too wide to carry paths takes it, only onto its own
+// listing, and never onto a folder it carries itself.
+function canDropByIndex(marker, path, rows, index) {
+    return rows.length > 0 && sameListing(marker, path) && rows.indexOf(index) < 0
+}
+
+// Whether the marked drag was lifted with ctrl down. No marker answers false.
+function markerCopying(payload) {
+    var fields = markerFields(payload)
+    return !!fields && fields[2] === "copy"
+}
+
+// Whether a marked drag began in this very window. An unmarked drag has no payload and answers false,
+// which is the right answer: something that is not Flea is not this Flea.
+function isOwnDrag(payload) {
+    var fields = markerFields(payload)
+    return !!fields && fields[0] === INSTANCE
+}
+
+// A path as a file:// URI. Each component is encoded on its own: encodeURIComponent would escape the
+// separators too, and encodeURI would leave a "#" or a "?" in a filename unescaped.
+function uriFor(path) {
+    return Format.fileUri(path)
+}
+
+// What the drag puts on the wire: the marker naming this drag as Flea's own, which the backend
+// resolves by index and which therefore always carries the whole selection, plus a CRLF-separated
+// uri-list for every other application.
+//
+// The uri-list is offered only when every carried row resolves. A selection reaches past the window
+// the client holds and pane.rowFor answers null outside it, so a wide selection cannot be turned into
+// paths here at all; pushing only the rows that happen to be realised is the defect Ops.js records as
+// "a wide move relocated a few files and abandoned the rest", and here it would hand another
+// application a subset while the bar named the whole count. No list at all is refusable and visible.
+// Whether the key is present is also what tells the bar the drag cannot leave Flea.
+function mimeFor(pane, rows, copy, shift) {
+    var mime = {}
+    mime[ROWS_MIME] = markerPayload(rows, copy, Search.baseOf(pane), pane.backend ? pane.backend.dirDev : 0, listingDeletable(pane), shift === true, pane.backend ? pane.backend.heldListing : 0)
+    lifted = { marker: mime[ROWS_MIME], backend: pane.backend || null }
+    var uris = []
+    var paths = []
+    for (var i = 0; i < rows.length; i++) {
+        var row = pane.rowFor(rows[i])
+        if (!row) {
+            return mime
+        }
+        paths.push(pane.join(Search.baseOf(pane), row.n))
+        uris.push(uriFor(paths[paths.length - 1]))
+    }
+    if (uris.length > 0) {
+        mime["text/uri-list"] = uris.join("\r\n") + "\r\n"
+        // The rule: a terminal or a text field that takes plain text gets the absolute paths, one a line.
+        mime["text/plain"] = paths.join("\n")
+    }
+    return mime
+}
+
+// A path drop lands on another directory only, and only with paths to send; same-directory and pathless drops refuse.
+function canDropInto(marker, urls, dest, plain) {
+    if (marker && !markerFields(marker)) return false
+    // No destination is no drop: a tab with no path for its row and the history's base, which
+    // names no folder of its own, both refuse rather than landing wherever "" resolves.
+    if (!dest) return false
+    // Each path's own folder decides, never the marker's source: a search or Recent row is not a child of its listing's base.
+    var paths = DragOut.sources(urls, plain, marker, "")
+    return paths.length > 0 && DragOut.refusal(paths, dest, marker, "") === ""
+}
+
+// Path drops transfer through dropVerb, the only verb decision, which reads the drop-time keys over the lift bits for a Flea marker.
+function dropInto(pane, marker, urls, dest, destDev, shelf, plain, proposed, seenCopy, seenShift) {
+    // No destination is no drop, even for a shelf drag whose token would otherwise redeem.
+    if (!dest) return false
+    if (marker && !markerFields(marker)) return false
+    var paths = DragOut.sources(urls, plain, marker, shelf)
+    if (!canDropInto(marker, urls, dest, plain) && shelfToken(shelf).length === 0) return false
+    // Rule 4: a shelf drag is redeemed rather than re-read as a list of URIs, because a fallback to
+    // a URI copy after the shelf promised a move is the silent wrong answer it forbids; its URIs only ask first.
+    if (shelfToken(shelf).length > 0) {
+        return pane.asks().ask({ c: "transfer", op: "", paths: [], dest: dest, shelf: shelfToken(shelf) }, DragOut.filePaths(urls))
+    }
+    var verb = dropVerb(marker, proposed, destDev, seenCopy, seenShift)
+    if (verb === "link") {
+        return pane.asks().ask({ c: "link", op: "relative", paths: paths, dest: dest })
+    }
+    return pane.asks().ask({ c: "transfer", op: verb, paths: paths, dest: dest })
+}
+
+// Marker-less platform action, read here only: move-only shifts, copy-only copies, link-only links, both bits set, or neither, stays plain.
+function foreignHeld(proposed) {
+    var moveBit = (proposed & Qt.MoveAction) !== 0
+    var copyBit = (proposed & Qt.CopyAction) !== 0
+    var linkBit = (proposed & Qt.LinkAction) !== 0
+    if (linkBit && !moveBit && !copyBit) return { copy: true, shift: true }
+    if (moveBit && !copyBit) return { copy: false, shift: true }
+    if (copyBit && !moveBit) return { copy: true, shift: false }
+    return { copy: false, shift: false }
+}
+
+// Verb from marker plus drop-time keys: a Flea marker carries the lift's own bits as the baseline and the seen keys override them, a foreign drag follows foreignHeld.
+function dropVerb(marker, proposed, destDev, seenCopy, seenShift) {
+    if (marker) {
+        return verbFor(isOwnDrag(marker), dropHeld(markerCopying(marker), seenCopy),
+                       dropHeld(markerShift(marker), seenShift), markerDev(marker), destDev, markerDeletable(marker))
+    }
+    var held = foreignHeld(proposed)
+    return verbFor(false, held.copy, held.shift, 0, destDev, true)
+}
+
+// Only verb decision: Ctrl with Shift links and needs no device, Ctrl copies, Shift moves; else same-device moves and unknown-device or undeletable copies.
+function verbFor(own, ctrlHeld, shiftHeld, srcDev, destDev, deletable) {
+    void own
+    if (ctrlHeld && shiftHeld) return "link"
+    if (ctrlHeld) return "copy"
+    if (shiftHeld) return "move"
+    if (!srcDev || !destDev || deletable === false) return "copy"
+    return srcDev === destDev ? "move" : "copy"
+}
+
+// Said beside the drag line when the selection cannot be handed to another application. The internal
+// drop is still whole, so the count stands; this only tells the operator the drag will not leave,
+// which beats a drop that silently does nothing over another window.
+function reachNote(canLeave) {
+    return canLeave ? "" : " · too wide to drag out"
+}
+
+// Sample marker "<instance>\n1,3\nmove\n%2Fsource\n42\n1\n0\n7"; feedback never becomes destination row indices.
+function feedbackFor(marker, urls, shelf, proposed) {
+    var fields = markerFields(marker) || []
+    var own = fields[0] === INSTANCE
+    var paths = DragOut.filePaths(urls)
+    if (shelfToken(shelf).length > 0) {
+        return { own: true, copy: shelfCopying(shelf), dev: 0, fixed: shelfCopying(shelf),
+                 count: paths.length, canLeave: paths.length > 0 }
+    }
+    var copy = fields[2] === "copy"
+    var shift = fields[6] === "1"
+    if (!marker) {
+        var held = foreignHeld(proposed)
+        copy = held.copy
+        shift = held.shift
+    }
+    return { own: own, copy: copy, shift: shift,
+             dev: Number(fields[4]) || 0, deletable: fields[5] !== "0",
+             count: own && fields[1] ? fields[1].split(",").length : paths.length,
+             canLeave: paths.length > 0 }
+}
+
+function copyingFor(feedback, destDev) {
+    if (!feedback) return true
+    return feedback.fixed !== undefined ? feedback.fixed === true
+        : verbFor(feedback.own, feedback.copy, feedback.shift, feedback.dev, destDev, feedback.deletable) === "copy"
+}
+
+function linkingFor(feedback, destDev) {
+    if (!feedback || feedback.fixed !== undefined) return false
+    return verbFor(feedback.own, feedback.copy, feedback.shift, feedback.dev, destDev, feedback.deletable) === "link"
+}
+
+function feedbackLine(feedback, name, destDev) {
+    if (!feedback || feedback.count === 0) return ""
+    var link = linkingFor(feedback, destDev)
+    return line(feedback.count, name, !link && copyingFor(feedback, destDev), link) + reachNote(feedback.canLeave)
+}

package/ui/js/DragOut.js

@@ -0,0 +1,166 @@
+.pragma library
+
+// Foreign-drop paths and its one refusal sentence; own drags keep their marker and never re-read text/plain.
+function usePlain(marker, shelf) {
+    return !marker && !shelf
+}
+
+// Sample input "file:///d/a%20b.txt" answers "/d/a b.txt"; anything else answers null.
+function filePath(url) {
+    var text = String(url)
+    if (text.indexOf("file://") !== 0) return null
+    var rest = text.substring(7)
+    var path
+    if (rest.charAt(0) === "/") {
+        path = rest
+    } else {
+        var slash = rest.indexOf("/")
+        if (slash < 0 || rest.substring(0, slash) !== "localhost") return null
+        path = rest.substring(slash)
+    }
+    try {
+        return decodeURIComponent(path)
+    } catch (error) {
+        return null
+    }
+}
+
+function filePaths(urls) {
+    var paths = []
+    if (!urls) return paths
+    for (var i = 0; i < urls.length; i++) {
+        var path = filePath(urls[i])
+        if (path) paths.push(path)
+    }
+    return paths
+}
+
+// Sample input "/a/x.txt\nhttp://e/y\n" answers ["/a/x.txt"]; a line not starting with "/" is left behind.
+function plainPaths(plain) {
+    var paths = []
+    if (!plain) return paths
+    var lines = String(plain).split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i]
+        if (line.charAt(line.length - 1) === "\r") line = line.substring(0, line.length - 1)
+        if (line.charAt(0) === "/") paths.push(line)
+    }
+    return paths
+}
+
+function sources(urls, plain, marker, shelf) {
+    var paths = filePaths(urls)
+    if (!usePlain(marker, shelf)) return paths
+    var extra = plainPaths(plain)
+    for (var i = 0; i < extra.length; i++) {
+        if (paths.indexOf(extra[i]) < 0) paths.push(extra[i])
+    }
+    return paths
+}
+
+// Checked in this order: a folder inside the drag, a file already in the destination, then nothing local.
+function refusal(paths, dest, marker, shelf) {
+    var i
+    for (i = 0; i < paths.length; i++) {
+        if (dest === paths[i] || dest.indexOf(paths[i] + "/") === 0)
+            return "That folder is inside the drag."
+    }
+    for (i = 0; i < paths.length; i++) {
+        var slash = paths[i].lastIndexOf("/")
+        var parent = slash <= 0 ? "/" : paths[i].substring(0, slash)
+        if (parent === dest) return "Already in this folder."
+    }
+    if (paths.length === 0 && usePlain(marker, shelf)) return "That drag has no local files."
+    return ""
+}
+
+function askAllowed(pathsPending, clipPending) {
+    return !pathsPending && clipPending === null
+}
+
+// Floor refuses while a listing is out; a hovered tab keeps its stored folder, an unlanded one refuses with the floor.
+function refuseLoading(listInFlight, hoverTab, currentTab) {
+    if (listInFlight !== true) return false
+    if (hoverTab !== true) return true
+    return currentTab === true
+}
+
+function searchTabEnabled(searchMode, current) {
+    return !(searchMode && current)
+}
+
+// The top (-1) or bottom (1) band of a listing, which scrolls it with the hover-open setting on or off; 0 elsewhere.
+var BAND_PX = 37
+function band(y, height) {
+    if (height < BAND_PX * 2)
+        return 0
+    if (y < BAND_PX)
+        return -1
+    if (y > height - BAND_PX)
+        return 1
+    return 0
+}
+// Resting on a folder this long opens it when the setting is on; a move restarts the rest.
+var OPEN_MS = 700
+function shouldOpen(hoverMs, settingOn, moved) {
+    return settingOn && !moved && hoverMs >= OPEN_MS
+}
+
+// #259: the drag's modifier transitions, kept here so a launch builds no store; each key is 1 held, 0 released, -1 unseen.
+var keys = {
+    liftMime: "application/x-flea-lift",
+    lifts: 0,
+    marker: "",
+    lift: "",
+    ctrl: -1,
+    shift: -1,
+    leaving: false,
+
+    // Every drag this window starts carries its own lift number, so two drags of the same rows are never one drag here.
+    stamped: function (mime) {
+        var out = {}
+        for (var key in mime) out[key] = mime[key]
+        keys.lifts += 1
+        out[keys.liftMime] = String(keys.lifts)
+        return out
+    },
+
+    // Another drag resets the pair; the same drag keeps what was seen, and an own lift keeps it across gaps between targets.
+    enter: function (seen, lifted) {
+        var number = lifted || ""
+        keys.leaving = false
+        if (keys.marker !== seen || keys.lift !== number) {
+            keys.marker = seen
+            keys.lift = number
+            keys.ctrl = -1
+            keys.shift = -1
+        }
+    },
+
+    // A drag with no lift, another app's or an older Flea's, ends at a leave that no enter follows in the same turn.
+    leave: function () {
+        if (keys.lift !== "") return
+        keys.leaving = true
+        Qt.callLater(keys.settle)
+    },
+
+    settle: function () {
+        if (keys.leaving) keys.clear()
+    },
+
+    // A drop consumes the drag; taps before any drag never arm tracking because it gates on a marker.
+    clear: function () {
+        keys.leaving = false
+        keys.marker = ""
+        keys.lift = ""
+        keys.ctrl = -1
+        keys.shift = -1
+    },
+
+    // The pane funnels its press and release here; the lift bits stay the baseline, so a key held since the lift still counts.
+    track: function (event, pressed) {
+        if (keys.marker === "") return
+        if (event.key === Qt.Key_Control) keys.ctrl = pressed ? 1 : 0
+        else if (event.key === Qt.Key_Shift) keys.shift = pressed ? 1 : 0
+    }
+}

package/ui/js/DropDev.js

@@ -0,0 +1,52 @@
+.pragma library
+
+.import "Mounts.js" as Mounts
+
+// A drop target's device is the backend's stat of it, symlinks followed; this keeps the answers and runs no stat.
+
+// Sample input: normalize("/run/media/gm/USB/") is "/run/media/gm/USB".
+function normalize(path) {
+    var p = String(path || "").replace(/\/+$/, "")
+    return p.length > 0 ? p : (String(path || "").charAt(0) === "/" ? "/" : "")
+}
+
+// Sample input: askPaths("/home/u/docs") is ["/", "/home", "/home/u"]; a listing under a gvfs mount asks nothing, so its crumbs copy.
+function askPaths(listing) {
+    var p = normalize(listing)
+    if (p.charAt(0) !== "/" || p === "/" || Mounts.underGvfs(p)) return []
+    var out = ["/"]
+    for (var at = p.indexOf("/", 1); at > 0; at = p.indexOf("/", at + 1)) out.push(p.substring(0, at))
+    return out
+}
+
+// Sample input: merged({"/": 5}, {"/home": 6}) is {"/": 5, "/home": 6}; past 256 paths the older answers go whole.
+function merged(known, answered) {
+    var out = {}
+    var old = known || {}
+    if (Object.keys(old).length <= 256) for (var path in old) out[path] = old[path]
+    for (var key in (answered || {})) out[key] = answered[key]
+    return out
+}
+
+// Sample input: without({"/": 5, "/home": 6}, ["/home"]) is {"/": 5}; an asked path reads unknown, and so copies, until its new answer lands.
+function without(known, paths) {
+    var out = {}
+    var old = known || {}
+    for (var path in old) out[path] = old[path]
+    for (var i = 0; i < (paths || []).length; i++) delete out[normalize(paths[i])]
+    return out
+}
+
+// Sample input: devFor({"/home": 66306}, "/home/") is 66306, and 0 for a path nobody answered, which makes the plain drop copy.
+function devFor(known, path) {
+    var dev = known ? Number(known[normalize(path)]) : 0
+    return dev > 0 ? dev : 0
+}
+
+// Sample input: folderAsks([{n: "deep", d: true}, {n: "a.txt", d: false}, {n: "big", d: true, v: 5}], "/home/u", 0, 2, pane) is ["/home/u/deep"]; a file, a row with its own device and a row out of view ask nothing.
+function folderAsks(rows, dir, first, last, pane) {
+    var out = []
+    for (var i = Math.max(0, first); i <= last && i < (rows || []).length; i++)
+        if (rows[i].d === true && !rows[i].v) out.push(pane.join(dir, rows[i].n))
+    return out
+}

package/ui/js/Dropbox.js

@@ -0,0 +1,41 @@
+.pragma library
+
+// The code names the state for logic (readFailed, signedOut, invalid, or "" when ready); the reason is for people.
+// Sample input: {"personal":{"path":"/home/gm/Dropbox"}}; personal precedes business in the OEM helper.
+function account(raw, error) {
+    if (error) return { path: "", reason: error, code: "readFailed" }
+    if (!raw) return { path: "", reason: "Dropbox is signed out", code: "signedOut" }
+    var data
+    try { data = JSON.parse(raw) } catch (e) { return { path: "", reason: "Dropbox account details could not be read", code: "invalid" } }
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return { path: "", reason: "Dropbox account details could not be read", code: "invalid" }
+    for (var i = 0, keys = ["personal", "business"]; i < keys.length; i++) {
+        var value = data[keys[i]]
+        if (!value || typeof value !== "object" || Array.isArray(value)) continue
+        var path = value.path
+        if (typeof path !== "string" || path.charAt(0) !== "/" || path === "/" || path.indexOf("\u0000") >= 0)
+            return { path: "", reason: "The Dropbox folder could not be found", code: "invalid" }
+        return { path: path.replace(/\/+$/, ""), reason: "", code: "" }
+    }
+    return { path: "", reason: "Dropbox is signed out", code: "signedOut" }
+}
+
+function contains(root, path) {
+    return typeof root === "string" && root.length > 1 && root.charAt(0) === "/"
+        && typeof path === "string" && (path === root || path.indexOf(root + "/") === 0)
+}
+
+// The code names the state for logic (statusFailed, notRunning, or "" when ready); the reason is for people.
+// Sample output: dropbox-cli status prints "Up to date" or "Dropbox isn't running!" even with exit status zero.
+function status(output, exitCode, error) {
+    var text = String(output || "").trim(), detail = String(error || "").trim()
+    if (exitCode !== 0) return { reason: detail || text || "Dropbox could not be checked", code: "statusFailed" }
+    if (!text) return { reason: detail || "Dropbox did not report its status", code: "statusFailed" }
+    if (detail) return { reason: detail, code: "statusFailed" }
+    var lower = text.toLowerCase()
+    if (lower.indexOf("not running") >= 0 || lower.indexOf("isn't running") >= 0 || lower === "stopped"
+            || text.indexOf("Couldn't get status:") === 0 || text === "Dropbox isn't responding!"
+            || text === "Dropbox daemon stopped.")
+        return { reason: text, code: "notRunning" }
+    return { reason: "", code: "" }
+}