buninu-browser 0.2.4 → 0.4.0

package/test/fixtures/qml/flea-theme/ui/js/ExtThumbs.js

@@ -0,0 +1,115 @@
+.pragma library
+
+.import "Thumbs.js" as Thumbs
+.import "Format.js" as Format
+
+// The ExtThumbs board's storage-class gate: network shares and phones are off, USB
+// drives are on, and anything else is local and always gets thumbnails. A class is
+// src/backend/extclass.rs's own word, carried beside the fsinfo line once per
+// directory change, so nothing here classifies and there is no second classifier.
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one; one per state.
+var WORDS = {
+    hide: "Hide %1 thumbnails",
+    show: "Show %1 thumbnails",
+    isOn: "%1 thumbnails are on",
+    isOff: "%1 thumbnails are off"
+}
+
+// Sample input: "network" answers "thumbNetwork", "" answers "".
+function keyForClass(storageClass) {
+    if (storageClass === "network") return "thumbNetwork"
+    if (storageClass === "phone") return "thumbPhone"
+    if (storageClass === "usb") return "thumbUsb"
+    return ""
+}
+
+// The menu row is present only on network, phone or USB storage, never locally.
+function present(storageClass) {
+    return keyForClass(storageClass) !== ""
+}
+
+// Sample input: ("usb", {}) answers true, ("network", {}) answers false.
+function classOn(storageClass, preview) {
+    var key = keyForClass(storageClass)
+    if (key === "") return true
+    if (key === "thumbUsb") return !preview || preview.thumbUsb !== false
+    return !!preview && preview[key] === true
+}
+
+function classOff(storageClass, preview) {
+    return present(storageClass) && !classOn(storageClass, preview)
+}
+
+// Off is cache-only, not blank: a visible row still asks, and the backend answers from
+// the shared cache with one stat and never starts a decoder. Thumbnails already made
+// still show, because the cache answers them. Sample input: ("network", {}) answers true.
+function cacheOnly(storageClass, preview) {
+    if (!classOff(storageClass, preview)) return false
+    return !preview || preview.thumbnails !== "off"
+}
+
+// The thumbed line's record: a cache-only miss on a generating class returns to unasked, any other reply is remembered.
+function thumbReply(state, row, file, cap, known, storageClass, preview) {
+    if (file === "" && state.file[row] === Thumbs.CACHE_ASKED && (!known || !cacheOnly(storageClass, preview)))
+        return { state: Thumbs.miss(state, row, true, cap), missed: true }
+    return { state: Thumbs.remember(state, row, file, cap), missed: false }
+}
+
+// In Columns the preview is manual on a class that is off: one condition, two surfaces.
+function manualHold(storageClass, preview) {
+    return cacheOnly(storageClass, preview)
+}
+
+// The menu row's own entrance: absent off the three classes, otherwise labelled for
+// the class and its state. Sample input: ({storageClass: "usb"}) answers "Hide USB thumbnails".
+function entry(e, p) {
+    if (!present(p.storageClass)) return false
+    e.label = label(p.storageClass, classOn(p.storageClass, p.thumbPreview))
+    return true
+}
+
+// Sample input: ("network", false) answers "Show network thumbnails".
+function label(storageClass, on) {
+    var noun = storageClass === "usb" ? "USB" : storageClass
+    return Format.fill(on ? WORDS.hide : WORDS.show, noun)
+}
+
+// The status bar's own verdict for the toggle, in the board's words.
+// Sample input: ("network", true) answers "Network thumbnails are on".
+function statusLine(storageClass, on) {
+    var noun = storageClass === "usb" ? "USB"
+        : storageClass.charAt(0).toUpperCase() + storageClass.slice(1)
+    return Format.fill(on ? WORDS.isOn : WORDS.isOff, noun)
+}
+
+// A class switched on decodes again: only its cache-only marks leave the map, so a
+// real refusal stays answered and is never decoded twice. Sample input:
+// {file: {3: "", 4: "/c/x.png", 5: "cache-missed"}, order: [3, 4, 5]} forgets 5 alone.
+function forgetMisses(state) {
+    var kept = []
+    for (var i = 0; i < state.order.length; i++) {
+        var at = state.order[i]
+        if (state.file[at] === Thumbs.CACHE_MISS || state.file[at] === Thumbs.CACHE_ASKED) delete state.file[at]
+        else kept.push(at)
+    }
+    state.order = kept
+    return { file: state.file, order: state.order }
+}
+
+// Sample input: ("network", {}) answers "only|media"; a zoom step or another class keeps it, so refreshes nothing.
+function verdict(storageClass, preview) {
+    var mode = preview && preview.thumbnails ? preview.thumbnails : "media"
+    return (cacheOnly(storageClass, preview) ? "only" : "full") + "|" + mode
+}
+
+// FileView reads the whole file, so a row over the gate is refused, not truncated, the
+// same rule ui/PreviewText.qml already keeps. Text previews on network and phone storage
+// read at most the first 256 KiB. Sample input: ("phone") answers 262144.
+var TEXT_PREVIEW_MAX = 1048576
+var REMOTE_TEXT_PREVIEW_MAX = 262144
+
+function textLimit(storageClass) {
+    if (storageClass === "network" || storageClass === "phone") return REMOTE_TEXT_PREVIEW_MAX
+    return TEXT_PREVIEW_MAX
+}

package/test/fixtures/qml/flea-theme/ui/js/Filter.js

@@ -0,0 +1,284 @@
+.pragma library
+.import "Input.js" as Input
+
+.import "Format.js" as Format
+.import "Match.js" as Match
+.import "Thumbs.js" as Thumbs
+
+// The strip's two sentences and the no-match tile's heading, each filled by Format.fill.
+var WORDS = {
+    noMatchOne: "No match among 1 item",
+    noMatchMany: "No match among %1 items",
+    shown: "%1 of %2 shown",
+    shownOfFolder: "%1 of %2 shown · of %3 in this folder",
+    nothingMatched: "Nothing matched %1"
+}
+
+// The filter narrows the listing already on screen: no walk, no round trip, and every row it keeps
+// is one the backend has already sent. ui/js/Search.js is its bigger sibling, which walks the
+// subtree and replaces the listing; the design canvas draws the two as different things and this
+// file never reaches ui/Backend.qml at all.
+//
+// Two index spaces meet here. A "listing row" is what the backend numbers, what a selection holds
+// and what every write operation sends; a "view position" is where a row is drawn. With no filter
+// up the two are the same number, and at() and viewOf() below are the only places that convert.
+
+// The listing rows a query leaves standing, in the order the backend sent them, or null when there
+// is no filter at all. Only the rows the pane holds can be tested, so the answer is a subsequence
+// of the held window; scope() below is what says so when the window is not the whole listing.
+// It is a subsequence and never a re-ranking, which is what keeps directories ahead of files.
+function shown(rows, held, query) {
+    if (query.length === 0) {
+        return null
+    }
+    var out = []
+    for (var i = 0; i < rows.length; i++) {
+        // The same run ui/js/Match.js paints in the name, so a row can never match without showing why.
+        if (Match.run(rows[i].n, query).start >= 0) {
+            out.push(held + i)
+        }
+    }
+    return out
+}
+
+function at(list, view) {
+    if (list === null) {
+        return view
+    }
+    // A delegate can outlive the view position it was built for by a frame when the match list
+    // shrinks, so a position past the end answers -1: a listing row nothing holds and nothing draws.
+    return view < list.length ? list[view] : -1
+}
+
+// -1 for a row the filter hides, which is what the callers below clamp against.
+function viewOf(list, row) {
+    return list === null ? row : list.indexOf(row)
+}
+
+// Issue 92, nixfred: a query matching nothing leaves the cursor on a row the filter no longer draws.
+function cursorShown(pane) { return viewOf(pane.shown, pane.cursorIndex) >= 0 }
+
+// The strip's own sentence, SearchFilter rules 1 and 2: what the filter kept, out of the rows it
+// could test, and the directory those rows are a window on. The scope is the half that must not be
+// dropped, because zero matches among 350 loaded rows is not zero matches in a 104,812-file
+// directory; the tail goes when the window is the whole listing, which is nothing left to say.
+function summary(list, loaded, total) {
+    if (list === null) {
+        return ""
+    }
+    if (total > loaded) {
+        return Format.fill(WORDS.shownOfFolder, Format.count(list.length), Format.count(loaded), Format.count(total))
+    }
+    return Format.fill(WORDS.shown, Format.count(list.length), Format.count(loaded))
+}
+
+// States' no-match tile: the pane names the query back and says how many rows it tested, because
+// the query is up in a strip the reader may have looked away from.
+function noMatch(total) {
+    return total === 1 ? WORDS.noMatchOne : Format.fill(WORDS.noMatchMany, Format.count(total))
+}
+
+// The rows drawn between two ends, which is not the range between them: a plain index range would
+// sweep up every row the filter hid in the gap, and nothing on screen would say it had.
+function between(list, a, b) {
+    var lo = Math.min(a, b)
+    var hi = Math.max(a, b)
+    var out = []
+    for (var i = 0; i < list.length; i++) {
+        if (list[i] >= lo && list[i] <= hi) {
+            out.push(list[i])
+        }
+    }
+    return out
+}
+
+// A request cut back to the rows still drawn. A filtered viewport covers a set and not a run, so
+// the range-shaped planners hand back rows the filter hides, and asking for those would fetch work
+// nothing draws.
+function keep(asked, list) {
+    if (list === null) {
+        return asked
+    }
+    var drawn = {}
+    for (var i = 0; i < list.length; i++) {
+        drawn[list[i]] = true
+    }
+    var out = []
+    for (var j = 0; j < asked.length; j++) {
+        if (drawn[asked[j]] === true) {
+            out.push(asked[j])
+        }
+    }
+    return out
+}
+
+// A pending thumbnail can be hidden inside the planner's span as well as outside its viewport.
+function cut(work, list, state) {
+    var drop = work.drop.slice()
+    if (list !== null) {
+        var drawn = {}
+        for (var i = 0; i < list.length; i++) drawn[list[i]] = true
+        var dropping = {}
+        for (var j = 0; j < drop.length; j++) dropping[drop[j]] = true
+        for (var key in state.file) {
+            var row = Number(key)
+            if (Thumbs.pending(state.file[key]) && drawn[row] !== true && dropping[row] !== true)
+                drop.push(row)
+        }
+    }
+    return { ask: keep(work.ask, list), drop: drop }
+}
+
+// The listing rows a view range covers, for the two planners that take a first and a last.
+function span(list, first, last) {
+    if (list === null) {
+        return { first: first, last: last }
+    }
+    if (list.length === 0) {
+        return { first: 0, last: -1 }
+    }
+    var lo = Math.max(0, Math.min(list.length - 1, first))
+    var hi = Math.max(0, Math.min(list.length - 1, last))
+    return { first: list[lo], last: list[hi] }
+}
+
+// The transitions, taking ui/Pane.qml's root the way ui/js/Search.js and ui/js/Sort.js do: the pane
+// holds the state, this holds what the state does.
+
+// "/" opens the query line. Unlike the search's, nothing is committed to start a walk: the rows are
+// already here, so the listing narrows on the keystroke itself.
+function start(pane) {
+    pane.filterTyping = true
+}
+
+function typed(pane, character) {
+    apply(pane, pane.filterQuery + character)
+}
+
+function backspace(pane) {
+    apply(pane, pane.filterQuery.substring(0, pane.filterQuery.length - 1))
+}
+
+// Enter hands the keyboard back to the list with the filter standing, which is what makes y, x, d
+// and r work over the narrowed rows; an empty query has nothing to stand, so it closes instead.
+function commit(pane) {
+    if (pane.filterQuery.length === 0) {
+        close(pane)
+        return
+    }
+    pane.filterTyping = false
+}
+
+// Esc, and every fresh listing. The selection is deliberately not cleared: prune() below has already
+// cut it to rows the filter was showing, so what is left is exactly what was on screen.
+function close(pane) {
+    pane.filterQuery = ""
+    pane.filterTyping = false
+}
+
+// The new query is applied here rather than by writing the property alone, because the selection has
+// to lose the rows that just dropped out before anything can act on rows nobody can see. The next
+// match list is computed rather than read back off the pane's binding, so the order is not a guess.
+function apply(pane, query) {
+    var next = shown(pane.rows, pane.held, query)
+    prune(pane, next)
+    if (query !== pane.filterQuery) pane.filterKeyAt = Date.now()
+    pane.filterQuery = query
+    if (query.length > 0) pane.filterNarrowedAt = Date.now()
+    // A cursor the filter just hid takes the first row still standing, so it is never off screen.
+    if (next !== null && next.length > 0 && viewOf(next, pane.cursorIndex) < 0) {
+        pane.cursorIndex = next[0]
+        pane.cursorSeq += 1
+        pane.showRow(0)
+    }
+}
+
+// A selection you cannot see is one you can act on by accident, and trash, cut and copy all take the
+// selection with no confirmation at all: what the filter hides, it takes out of the selection too.
+function prune(pane, list) {
+    if (list === null) {
+        return
+    }
+    var drawn = {}
+    for (var i = 0; i < list.length; i++) {
+        drawn[list[i]] = true
+    }
+    var was = pane.selectedIndices()
+    var dropped = 0
+    for (var j = 0; j < was.length; j++) {
+        if (drawn[was[j]] !== true) {
+            pane.selection.toggle(was[j])
+            dropped += 1
+        }
+    }
+    if (dropped > 0) {
+        pane.selectionVersion += 1
+    }
+}
+
+// Cursor is a listing row but moves through drawn rows, so both steps convert.
+function setCursor(pane, index, context) {
+    setCursorView(pane, viewOf(pane.shown, index), context)
+}
+
+function setCursorView(pane, view, context) {
+    if (pane.shownTotal === 0) {
+        return
+    }
+    var to = Math.max(0, Math.min(pane.shownTotal - 1, view))
+    pane.cursorIndex = at(pane.shown, to)
+    // Every cursor setter bumps cursorSeq, so a plain move ends a Shift gesture.
+    pane.cursorSeq += 1
+    pane.showRow(to, context)
+}
+
+function moveCursor(pane, delta) {
+    setCursorView(pane, viewOf(pane.shown, pane.cursorIndex) + delta)
+}
+
+// The wheel moved the viewport and the cursor follows it. Both ends are view positions, because
+// under a filter the listing rows they name are not a run and a numeric clamp would be meaningless.
+function clampCursor(pane, first, last) {
+    var was = viewOf(pane.shown, pane.cursorIndex)
+    var to = Math.max(first, Math.min(last, was))
+    if (to !== was) {
+        var held = pulledFrom(pane)
+        var from = held >= 0 ? held : pane.cursorIndex
+        pane.cursorIndex = at(pane.shown, to)
+        pane.cursorSeq = (pane.cursorSeq || 0) + 1
+        pane.cursorPulled = { from: from, to: pane.cursorIndex, seq: pane.cursorSeq, version: pane.selectionVersion }
+    }
+}
+
+// The row the cursor held before the wheel pulled it, while no move, mark or new listing came since (issue 286); else -1.
+function pulledFrom(pane) {
+    var pull = pane.cursorPulled
+    var current = pull && pull.seq === (pane.cursorSeq || 0) && pull.to === pane.cursorIndex
+        && pull.version === pane.selectionVersion
+    return current ? pull.from : -1
+}
+
+// The query line's own keys while it has the caret, the shape ui/js/Search.js typeKey uses for the
+// search's. Enter commits, escape abandons, backspace shortens, every printable character narrows.
+function typeKey(event, pane) {
+    // Ctrl+V and Shift+Insert type the clipboard's first line as one narrowing (issue 287).
+    if (Input.isPasteKey(event))
+        return Input.pasteInto(pane, function (text) { typed(pane, text) })
+    if (event.key === Qt.Key_Return || event.key === Qt.Key_Enter) {
+        commit(pane)
+        return true
+    }
+    if (event.key === Qt.Key_Escape) {
+        close(pane)
+        return true
+    }
+    if (event.key === Qt.Key_Backspace) {
+        backspace(pane)
+        return true
+    }
+    if (Input.isPrintable(event.text)) {
+        typed(pane, event.text)
+        return true
+    }
+    return true
+}

package/test/fixtures/qml/flea-theme/ui/js/FolderSorts.js

@@ -0,0 +1,108 @@
+.pragma library
+.import "UserDirs.js" as UserDirs
+
+// Owned here so Backend.qml loads no sort closure at startup.
+var ORDERS = ["name", "size", "mtime", "kind"]
+
+// Written only on a user sort in that folder, read once per listing, oldest first.
+
+// The cap ui.json holds, oldest first; setting past it drops the folders sorted longest ago.
+var MAX = 500
+
+// Sample input: XDG_DOWNLOAD_DIR="$HOME/Inbox"; absent PICTURES and VIDEOS use their conventional names.
+function newestPaths(body, home) {
+    var roles = ["DOWNLOAD", "PICTURES", "VIDEOS"]
+    var names = ["Downloads", "Pictures", "Videos"]
+    var paths = []
+    if (!home) return paths
+    var configured = {}
+    var entries = UserDirs.readRoles(body, home)
+    for (var e = 0; e < entries.length; e++)
+        configured[entries[e].role] = entries[e].path
+    for (var i = 0; i < roles.length; i++) {
+        var path = configured[roles[i]] === undefined ? home + "/" + names[i] : configured[roles[i]]
+        if (path && path !== home && paths.indexOf(path) < 0)
+            paths.push(path)
+    }
+    return paths
+}
+
+function defaultOrder(path, newest) {
+    var folder = String(path || "").replace(/\/+$/, "")
+    return newest && newest.indexOf(folder) >= 0 ? { key: "mtime", reverse: true } : null
+}
+
+// Settings stores Modified as "date" while ORDERS and the backend spell it "mtime".
+function liveKey(key) {
+    return key === "date" ? "mtime" : key
+}
+
+// Sample input: {"/home/gm/Work": {"key": "size", "reverse": true}}.
+function get(sorts, path) {
+    var entry = sorts ? sorts[path] : null
+    if (!entry || ORDERS.indexOf(liveKey(entry.key)) < 0)
+        return null
+    return { key: liveKey(entry.key), reverse: entry.reverse === true }
+}
+
+function has(sorts, path) {
+    return get(sorts, path) !== null
+}
+
+function count(sorts) {
+    return sorts ? Object.keys(sorts).length : 0
+}
+
+// A re-sort moves its folder to the most recent end; past the cap the oldest entries go.
+function set(sorts, path, key, reverse) {
+    var next = {}
+    if (sorts) {
+        for (var k in sorts) {
+            if (k !== path)
+                next[k] = sorts[k]
+        }
+    }
+    next[path] = { key: key, reverse: reverse === true }
+    var keys = Object.keys(next)
+    while (keys.length > MAX)
+        delete next[keys.shift()]
+    return next
+}
+
+function forget(sorts, path) {
+    var next = {}
+    if (sorts) {
+        for (var k in sorts) {
+            if (k !== path)
+                next[k] = sorts[k]
+        }
+    }
+    return next
+}
+
+// A user sort writes its folder only while remembering is on.
+function shouldRemember(remember, path) {
+    return remember !== false && !!path
+}
+
+// Columns pass keep: a saved order wins over XDG defaults; remembering off uses the global order, except kind, unsupported by peeks.
+function peekOrder(sorts, path, remember, keep, newest, fallback) {
+    if (!Array.isArray(keep)) return {}
+    var own = remember !== false ? get(sorts, path) || defaultOrder(path, newest)
+                                : fallback ? orderFor(null, path, fallback, false) : null
+    if (remember === false && own && own.key === "name" && !own.reverse) return {}
+    return own && own.key !== "kind" ? { by: own.key, desc: own.reverse } : {}
+}
+
+// An unknown stored key reads as the default, so a newer Flea never wedges this one.
+function orderFor(sorts, path, fallback, remember, newest) {
+    if (remember !== false) {
+        var own = get(sorts, path) || defaultOrder(path, newest)
+        if (own)
+            return own
+    }
+    fallback = fallback || {}
+    var key = liveKey(fallback.key)
+    return { key: ORDERS.indexOf(key) >= 0 ? key : "name",
+             reverse: fallback.reverse === true }
+}