flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Picker.js

@@ -0,0 +1,353 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Thumbs.js" as Thumbs
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    requestedBy: "Requested by %1",
+    selectedWithSize: "%1 selected · %2",
+    hintsEsc: "%1 · Esc cancel"
+}
+
+// The portal request tools/flea-portal puts in FLEA_PICKER, and the answer ui/picker.qml writes
+// back. Everything here is pure so tests/js/picker.js can drive it without a window.
+
+// The portal's own response codes, mirrored from tools/flea-portal: 1 is the user's no, and this
+// front end never sends 2, because a window that opened at all can only pick or refuse.
+var RESPONSE_OK = 0
+var RESPONSE_CANCELLED = 1
+
+var ALL_FILES = "All files"
+
+// The rail's Recent row is a location and not a directory, so it is named by a token no listing
+// path can equal: every path this window holds is absolute, and this one does not start with "/".
+// SendPicker.html draws it first in the rail and draws this word where the path would be.
+var RECENT = "flea:recent"
+var RECENT_LABEL = "Recent"
+
+function isRecent(location) {
+    return location === RECENT
+}
+
+// SendPicker.html draws a chooser row as the name, a 70px size and an 80px date, so the two columns
+// the window's rows also carry are hidden here at every width rather than at some of them.
+var HIDDEN_COLS = ["mode", "kind"]
+
+// The chooser's s-step order: only columns it draws, since an order no header can mark has no feedback.
+var SORT_ORDERS = ["name", "size", "mtime"]
+
+// Every field defaulted, because a request that arrived short must still open a window.
+function request(text) {
+    var read = {}
+    try {
+        read = JSON.parse(String(text || "{}")) || {}
+    } catch (e) {
+        read = {}
+    }
+    return {
+        mode: read.mode === "save" || read.mode === "savefiles" ? read.mode : "open",
+        title: String(read.title || ""),
+        app: String(read.app || ""),
+        accept: String(read.accept || ""),
+        multiple: read.multiple === true,
+        directory: read.directory === true,
+        hidden: typeof read.hidden === "boolean" ? read.hidden : undefined,
+        folder: String(read.folder || ""),
+        file: String(read.file || ""),
+        name: String(read.name || ""),
+        files: Array.isArray(read.files) ? read.files : [],
+        filters: Array.isArray(read.filters) ? read.filters : [],
+        current: String(read.current || ""),
+        currentIndex: typeof read.currentIndex === "number" ? read.currentIndex : -1
+    }
+}
+
+// The caller's own title wins; the fallback says what the window is for rather than naming Flea.
+function title(req) {
+    if (req.title.length > 0) {
+        return req.title
+    }
+    if (req.mode === "save" || req.mode === "savefiles") {
+        return "Save file"
+    }
+    return req.directory ? "Choose folder" : "Choose file"
+}
+
+// Only a portal identity is ever shown here. A host application has none, and inventing one from
+// the window title would put a name the desktop never vouched for under a trusted-looking label.
+function subtitle(req) {
+    return req.app.length > 0 ? Format.fill(WORDS.requestedBy, req.app) : ""
+}
+
+// The primary button. The count rides on it in the multiple case, which is the board's "Send 3".
+function acceptLabel(req, count) {
+    var base = req.accept.length > 0 ? req.accept : defaultAccept(req)
+    // The count goes in first and the caller's own text last, so a placeholder in it is never filled in.
+    if (req.multiple && count > 1) {
+        return "%2 %1".arg(Format.count(count)).arg(base)
+    }
+    return base
+}
+
+function defaultAccept(req) {
+    if (req.mode === "save") {
+        return "Save"
+    }
+    if (req.mode === "savefiles" || req.directory) {
+        return "Choose folder"
+    }
+    return "Open"
+}
+
+// The footer's left half: what is checked, and what it weighs.
+function statusLine(count, bytes) {
+    if (count === 0) {
+        return "0 selected"
+    }
+    return Format.fill(WORDS.selectedWithSize, Format.count(count), Format.size(bytes))
+}
+
+// The footer's right half, which says only the keys this mode actually answers.
+function hints(req) {
+    if (req.mode === "save") {
+        return "Enter save · Esc cancel"
+    }
+    var pick = req.multiple ? (req.directory ? "Enter open · Space mark folder" : "Space select · Enter open/send") : "Enter open"
+    return Format.fill(WORDS.hintsEsc, pick)
+}
+
+// The collision review's error line, one template so a placeholder inside the name is never filled in.
+function collisionLine(name) {
+    return "%1 already exists here.".arg(name)
+}
+
+// Where a name's stem ends: at its last dot, and a leading dot belongs to the stem.
+function stemEnd(name) {
+    var dot = String(name).lastIndexOf(".")
+    return dot > 0 ? dot : String(name).length
+}
+
+// Callout 12: Back, Up, the rail, the list, Filename, the filter, Cancel and the answer; a hidden or disabled stop is skipped.
+function tabOrder(stops) {
+    return [].concat(stops.chrome, [stops.rail, stops.view], stops.save, stops.answers)
+        .filter(function(item) { return item.visible && item.enabled && item.activeFocusOnTab })
+}
+
+// The filter menu's rows: the caller's filters, then All files, which is always explicit. No filters is no
+// dropdown at all, because a chooser with one filter is a chooser with nothing to choose between.
+function chips(req) {
+    if (req.filters.length === 0) {
+        return []
+    }
+    var out = []
+    for (var i = 0; i < req.filters.length; i++) {
+        out.push({ label: String(req.filters[i].label || ""), index: i })
+    }
+    out.push({ label: ALL_FILES, index: -1 })
+    return out
+}
+
+// Which filter starts current: the caller's current_filter when it names one of them, else the first.
+function currentChip(req) {
+    if (req.filters.length === 0) {
+        return -1
+    }
+    if (req.currentIndex >= 0 && req.currentIndex < req.filters.length) return req.currentIndex
+    for (var i = 0; i < req.filters.length; i++) {
+        if (String(req.filters[i].label || "") === req.current) {
+            return i
+        }
+    }
+    return 0
+}
+
+// A mark is a path, never a row number: the board's rule is that a checked identity survives Back
+// and Parent, and a row number rebinds to whatever else lands in that position.
+function marked(marks, path) {
+    for (var i = 0; i < marks.length; i++) {
+        if (marks[i].path === path) {
+            return true
+        }
+    }
+    return false
+}
+
+function totalBytes(marks) {
+    var sum = 0
+    for (var i = 0; i < marks.length; i++) {
+        sum += marks[i].bytes
+    }
+    return sum
+}
+
+function paths(marks) {
+    var out = []
+    for (var i = 0; i < marks.length; i++) {
+        out.push(marks[i].path)
+    }
+    return out
+}
+
+function reviewedMarks(previous, reviewed) {
+    return reviewed.map(function(item) {
+        var old = previous.find(function(mark) { return mark.path === item.path })
+        return {path: item.path, bytes: item.bytes, uri: old && old.uri ? old.uri : Format.fileUri(item.path)}
+    })
+}
+
+// The save name is the one filename a client hands this window, so it is a trust boundary and it
+// gets the rule the rest of the product already applies. Mirrored from src/backend/ops.rs
+// valid_name() and kept identical to it, character for character, so the two cannot drift.
+function validName(name) {
+    var text = String(name)
+    return text.length > 0 && text !== "." && text !== ".."
+        && text.indexOf("/") < 0 && text.indexOf("\0") < 0
+}
+
+// What both the strip and the status line say about a name validName() refuses, in ops.rs's words.
+var NAME_REFUSED = "a name cannot be empty, . or .., or contain /"
+// Status lines are whole sentences with placeholders, filled by Format.fill.
+var SAVE_REFUSED = "%1 cannot be used: %2"
+var SAVE_EXISTS = "%1 already exists here. Review it before you continue."
+
+// Whole sentences for the selection check, filled by Format.fill; singular and plural are two sentences.
+var NOTES = {
+    skippedOne: "Selected %1 of %2. 1 was left out: %3 (%4).",
+    skippedMany: "Selected %1 of %2. %3 were left out: %4 (%5) and %6 more."
+}
+
+// A name is one token to the wrapper, so its segment joints carry zero-width breaks; zero width keeps one-line draws identical.
+function jointName(name) {
+    return String(name).replace(/([._-])/g, "$1\u200b")
+}
+
+var DOUBLE_OPEN = "open"
+var DOUBLE_MARK = "mark"
+var DOUBLE_ACCEPT = "accept"
+var DOUBLE_MARK_ACCEPT = "markAccept"
+var DOUBLE_NONE = "none"
+
+// Sample input: sameTap("/a/b.txt", "/a/b.txt") answers true, sameTap("/a/b.txt", "/a/c.txt") answers false.
+function sameTap(firstPath, rowPath) {
+    return !!rowPath && rowPath === firstPath
+}
+
+// Sample input: doubleAction({mode:"open",multiple:false}, {d:false}, "/a/b.txt", "/a/b.txt", []) answers "markAccept"; multiple:true answers "mark" for either mark state.
+function doubleAction(req, row, rowPath, firstPath, marks) {
+    if (!row) {
+        return DOUBLE_NONE
+    }
+    if (directory(row)) {
+        return DOUBLE_OPEN
+    }
+    // Save mode and folder requests keep their own rules, so a file double click changes nothing there.
+    if (req.mode === "save" || req.directory || req.mode === "savefiles") {
+        return DOUBLE_NONE
+    }
+    // The row path names the file, so a list rebuilt between the taps never marks or sends another row.
+    if (!sameTap(firstPath, rowPath)) {
+        return DOUBLE_NONE
+    }
+    return req.multiple ? DOUBLE_MARK : marked(marks, rowPath) ? DOUBLE_ACCEPT : DOUBLE_MARK_ACCEPT
+}
+
+// The picker never renames, so Return/Enter still activates and other rename keys stay unhandled.
+function activates(action, key) {
+    if (action === "open" || action === "pageForward") {
+        return true
+    }
+    if (action !== "rename") {
+        return false
+    }
+    return key === Qt.Key_Return || key === Qt.Key_Enter
+}
+
+function join(dir, name) {
+    return dir === "/" ? "/" + name : dir + "/" + name
+}
+
+// A row's own identity, which is what a mark holds and what the caller is answered with. A Recent
+// listing's base is "/" and its rows are named by their path under it, so the row's path is that
+// name and never a join onto the location token; see docs/protocol.md "listpaths".
+function rowPath(location, name) {
+    return isRecent(location) ? "/" + name : join(location, name)
+}
+
+function directory(row) {
+    return !!row && (row.d === true || (Format.isSymlink(row.p) && row.i === "folder"))
+}
+
+// A launch opens only a view the picker draws; anything else opens the list.
+function rememberedView(stored) {
+    return stored === "grid" ? "grid" : "list"
+}
+
+// Only a switch that moves the view owes the state file a write.
+function viewSwitch(current, next) {
+    return (next === "list" || next === "grid") && next !== current ? next : ""
+}
+
+// Visible tiles as listing rows, the same multiplication GridArea.visibleRange does.
+function tileRange(contentY, cellH, tileRows, columns, total) {
+    var view = Thumbs.viewport(contentY, cellH, tileRows, Math.max(1, Math.ceil(total / Math.max(1, columns))))
+    return {
+        first: view.first * columns,
+        last: Math.min(total - 1, (view.last + 1) * columns - 1)
+    }
+}
+
+// One grid step keeps the main grid's edge rule: off its row or past an end stays.
+function gridTarget(index, delta, columns, total) {
+    var next = index + delta
+    if (next < 0 || next >= total) {
+        return Math.max(0, Math.min(total - 1, index))
+    }
+    if ((delta === -1 && index % columns === 0) || (delta === 1 && next % columns === 0)) {
+        return index
+    }
+    return next
+}
+
+// Page steps clamp to the nearer end; single steps refuse instead, see gridTarget.
+function pageTarget(index, delta, total) {
+    return Math.max(0, Math.min(total - 1, index + delta))
+}
+// Twice the wider view's screen plus slack, so the screen still fits after the quarter lead.
+var WINDOW_COVER = 2
+var WINDOW_SLACK = 60
+// Sample input: windowSize(10, 4, 5) is 100, windowSize(30, 2, 5) is 120.
+function windowSize(listRows, tileRows, columns) {
+    var tiles = Math.max(1, tileRows) * Math.max(1, columns)
+    return WINDOW_COVER * Math.max(listRows, tiles) + WINDOW_SLACK
+}
+
+function parentOf(path) {
+    var cut = String(path).lastIndexOf("/")
+    if (cut <= 0) {
+        return "/"
+    }
+    return String(path).substring(0, cut)
+}
+
+// The one place a path becomes a URI: xdg-desktop-portal drops anything that is not file://, and
+// omarchy-file-select turns what comes back into a path with GLib, which refuses a bad encoding.
+function uris(list) {
+    var out = []
+    for (var i = 0; i < list.length; i++) {
+        out.push(Format.fileUri(list[i]))
+    }
+    return out
+}
+
+// What tools/flea-portal reads out of the reply file. A refusal carries no URI at all.
+function reply(response, list, filterIndex) {
+    if (response !== RESPONSE_OK) {
+        return JSON.stringify({ response: response })
+    }
+    var answer = { response: RESPONSE_OK, uris: list.map(function(item) {
+        return typeof item === "string" ? Format.fileUri(item) : item.uri
+    }) }
+    if (typeof filterIndex === "number") answer.filter = filterIndex
+    return JSON.stringify(answer)
+}

package/ui/js/PlaceMenu.js

@@ -0,0 +1,96 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Menu.js" as Menu
+.import "Nav.js" as Nav
+.import "RailKeys.js" as RailKeys
+.import "Places.js" as Places
+.import "Tabs.js" as Tabs
+
+// The sentence a remote favourite answers a new-tab open with, filled by Format.fill.
+var WORDS = {
+    opensHere: "%1 opens in this tab only"
+}
+
+// MenuAdditions rule 3: the folder menu, opened from a Places or Favorites row and acting on that
+// row's own path. The key carries the path because the rail rebuilds on a five second poll and an
+// index taken when the menu opened can name another row by the time a row inside it is chosen, the
+// same reason ui/js/Mounts.js keys a share's menu by its uri.
+function key(entry, favouriteIndex) {
+    return "place:" + favouriteIndex + ":" + entry.path
+}
+
+// The hidden list is ui/ViewState.qml "menuHidden", handed in by the caller: it is the one reader
+// that falls back to the shipped defaults, and a list derived any other way is empty before the
+// state file lands, which switched this menu on in a fresh home. Anything else fails closed.
+function entries(entry, favouriteIndex, hidden) {
+    if (!Array.isArray(hidden))
+        return []
+    return Menu.placeEntries({ hiddenActions: hidden, hasRow: true, placeFavourite: favouriteIndex >= 0 })
+}
+
+// Every row here takes the path the key carries. Properties is not among them: the dialog snapshots
+// row indices through the backend's own menuaction op, which a place has none of, so the board's
+// sixth row waits for that protocol rather than being faked from the listing's cursor.
+function perform(action, key, sidebar, favourites) {
+    // The rail's older key, which only ever carried Remove: kept exactly, identity check included,
+    // because it is what a favourite's menu still is while the Places row menu is switched off.
+    if (key.indexOf("favourite:") === 0) {
+        var end = key.indexOf(":", 10)
+        var at = Number(key.substring(10, end))
+        if (action !== "removeFavourite") return
+        if (JSON.stringify(favourites.records[at]) === key.substring(end + 1)) favourites.remove(at)
+        else sidebar.message("Favorites changed; reopen the menu before removing this row.", true)
+        return
+    }
+    var rest = key.substring("place:".length)
+    var cut = rest.indexOf(":")
+    var index = Number(rest.substring(0, cut))
+    var path = rest.substring(cut + 1)
+    var pane = sidebar.navigationPane
+    if (!pane || path.length === 0)
+        return
+    if (action === "open") { openPath(path, sidebar, pane); return }
+    else if (action === "openTab") Tabs.openNew(pane, path)
+    else if (action === "openTerminal") pane.openTerminal(path)
+    // The Places row's Copy path row acts on its own path, the way the Locked
+    // tile's does: MenuAdditions040 replaced the file menu's row, not this one.
+    else if (action === "copypath") pane.performMenu("copypath", 0, [path])
+    else if (action === "addFavourite") favourites.add(path, leaf(path))
+    else if (action === "removeFavourite") removeAt(sidebar, favourites, index, path)
+}
+
+// Open reuses the rail's own activation handoff: focus follows a ready folder or a started listing, and a refused busy open stays on the rail.
+function openPath(path, sidebar, pane) {
+    if (pane.listInFlight === true) { Nav.openPlace(pane, path); return }
+    sidebar.focusOnOpen = true
+    RailKeys.openFrom(pane, path, sidebar)
+}
+
+// A favourite is removed by index, so the index is checked against the path the menu was opened on:
+// the rail rebuilds on a five second poll and Favourites can be rewritten by the other front end.
+function removeAt(sidebar, favourites, index, path) {
+    var record = favourites.records[index]
+    if (record && String(record.path) === path) favourites.remove(index)
+    else sidebar.message("Favorites changed; reopen the menu before removing this row.", true)
+}
+
+function leaf(path) {
+    var cut = String(path).replace(/\/+$/, "").lastIndexOf("/")
+    return cut < 0 ? path : path.substring(cut + 1)
+}
+
+// A middle click on a Places or Favorites row: its folder in a new tab, the listing's own middle click
+// (ui/js/Tap.js tappedTab). A favourite resolves as ui/Sidebar.qml openFavourite does, and a remote
+// one, which has to mount before it has a path, says so rather than opening somewhere else.
+function openTabAt(sidebar, index) {
+    var entry = sidebar.entries[index]
+    var pane = sidebar.navigationPane
+    if (!entry || !pane || (entry.kind !== "home" && entry.kind !== "favourite"))
+        return
+    // Places.openEntry with a new-tab port: same record check, message and file:// decode; a remote entry answers through the network port.
+    Places.openEntry(entry, { pane: pane,
+        opened: function (path) { Tabs.openNew(pane, path) },
+        networkHost: function () { sidebar.message(Format.fill(WORDS.opensHere, entry.label), false); return null },
+        message: sidebar.message })
+}