flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Archive.js

@@ -0,0 +1,157 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Which rows get an Extract, and what a new archive is called; the backend sends no is-archive flag, so this is the mechanism.
+
+// The widened tail of EXTENSIONS, which 7z reads; tar and the zip class keep their own rules.
+var SEVEN_TAILS = [".appimage", ".cpio", ".cab", ".jar", ".apk", ".rpm", ".deb", ".iso"]
+
+// Longest form first, so ".tar.gz" matches before ".gz"; .rar is read here and never offered to write (src/backend/archive.rs).
+var EXTENSIONS = [".tar.zst", ".tar.bz2", ".tar.gz", ".tar.xz", ".tgz", ".tzst", ".tar", ".zip", ".7z", ".rar"].concat(SEVEN_TAILS)
+
+// A disk image lists in the archive preview and is never extracted.
+var LIST_ONLY = [".iso"]
+
+function isArchive(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < EXTENSIONS.length; i++) {
+        if (lower.length > EXTENSIONS[i].length && lower.indexOf(EXTENSIONS[i], lower.length - EXTENSIONS[i].length) !== -1) {
+            return true
+        }
+    }
+    return false
+}
+
+// The name an extract unpacks into: the archive's own, with every archive extension taken off.
+function extractDir(name) {
+    var text = String(name)
+    var lower = text.toLowerCase()
+    for (var i = 0; i < EXTENSIONS.length; i++) {
+        if (lower.length > EXTENSIONS[i].length && lower.indexOf(EXTENSIONS[i], lower.length - EXTENSIONS[i].length) !== -1) {
+            return text.substring(0, text.length - EXTENSIONS[i].length)
+        }
+    }
+    return text
+}
+
+// One row compresses under its own name; several compress under the directory holding them.
+function archiveStem(names, parentLeaf) {
+    if (names.length === 1) {
+        return stripExtension(names[0])
+    }
+    return parentLeaf.length > 0 ? parentLeaf : "archive"
+}
+
+function stripExtension(name) {
+    var text = String(name)
+    var cut = text.lastIndexOf(".")
+    return cut > 0 ? text.substring(0, cut) : text
+}
+
+var SHEET_COMPRESS = "Compress to .%1"
+
+// The compress submenu is the probed table, so no 7zip means no .7z; the sheet reads each leaf "Compress to .zip" beside the board's file mark.
+function formatEntries(formats) {
+    var out = []
+    for (var i = 0; i < formats.length; i++) {
+        out.push({ id: formats[i], label: "." + formats[i], sheetLabel: SHEET_COMPRESS.replace("%1", formats[i]), glyph: "file" })
+    }
+    return out
+}
+
+// A disk image by name, longest form first so ".img.xz" wins over ".img"; a zip needs one such member.
+function imageKind(name) {
+    var lower = String(name || "").toLowerCase()
+    var table = [[".img.xz", "xz"], [".img.gz", "gz"], [".img.zst", "zst"], [".img.bz2", "bz2"],
+                 [".iso", "iso"], [".img", "img"], [".raw", "raw"], [".zip", "zip"]]
+    for (var i = 0; i < table.length; i++) {
+        var suffix = table[i][0]
+        if (lower.length > suffix.length && lower.lastIndexOf(suffix) === lower.length - suffix.length)
+            return table[i][1]
+    }
+    return ""
+}
+
+function isDiskImage(name, zipMember) {
+    var kind = imageKind(name)
+    if (kind === "" || kind === "zip")
+        return kind === "zip" && imageKind(zipMember) !== "" && imageKind(zipMember) !== "zip"
+    return true
+}
+
+// Whether an installed tool reads this archive: .7z needs 7z, .zip and .rar either tool, tar bsdtar, a disk image none.
+function canExtract(name, extraction) {
+    var lower = String(name).toLowerCase()
+    var caps = extraction || ({})
+    if (isListOnly(name)) return false
+    if (hasSuffix(lower, ".7z")) return caps.sevenZip === true
+    if (hasSuffix(lower, ".zip") || hasSuffix(lower, ".rar")) return caps.zip === true
+    if (isSevenSuffix(lower)) return caps.sevenZip === true
+    return caps.archive === true
+}
+
+// A disk image lists in the archive preview and is never extracted.
+function isListOnly(name) {
+    var lower = String(name).toLowerCase()
+    for (var i = 0; i < LIST_ONLY.length; i++) {
+        if (hasSuffix(lower, LIST_ONLY[i])) return true
+    }
+    return false
+}
+
+// The seven-tail membership, read off the one table above.
+function isSevenSuffix(lower) {
+    for (var i = 0; i < SEVEN_TAILS.length; i++) {
+        if (hasSuffix(lower, SEVEN_TAILS[i])) return true
+    }
+    return false
+}
+
+// The missing program for a disabled Extract: only bsdtar offers "tar" and only 7z offers "7z".
+function extractHint(formats) {
+    var table = formats || []
+    if (table.indexOf("7z") >= 0) return "bsdtar is not installed"
+    if (table.indexOf("tar") >= 0) return "7-Zip is not installed"
+    return "No archive tool is installed"
+}
+
+// Menu.js's Extract row: absent for none and for a disk image, disabled with its reason for no reader.
+function extractEntry(entry, p, count) {
+    if (!p.rowIsArchive || count !== 1) return false
+    if (isListOnly(p.archiveName || "")) return false
+    if (p.canExtract !== true) {
+        entry.disabled = true
+        entry.hint = extractHint(p.archiveFormats)
+        entry.hintWrap = true
+    }
+    return true
+}
+
+function hasSuffix(lower, suffix) {
+    return lower.length >= suffix.length && lower.indexOf(suffix, lower.length - suffix.length) !== -1
+}
+
+// The compress submenu's last row, which opens the password dialog; hidden where 7z is missing, since bsdtar writes no encryption.
+function passwordEntry(formats) {
+    var table = formats || []
+    if (table.indexOf("7z") < 0) return []
+    return [{ separator: true },
+        { id: "compressPassword", label: "With password…", glyph: "key" }]
+}
+
+// The backend's two password codes, matched exactly the way "cancelled" routes, never as sentences.
+function needsPassword(err) {
+    return String(err) === "encrypted"
+}
+
+function wrongPassword(err) {
+    return String(err) === "wrong-password"
+}
+
+// What an extract's terminal line does: "password" opens the card, "wrong" reopens it with its sentence, "" messages.
+function doneAction(ok, err) {
+    if (!ok && needsPassword(err)) return "password"
+    if (!ok && wrongPassword(err)) return "wrong"
+    return ""
+}

package/ui/js/ArchiveCard.js

@@ -0,0 +1,44 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The archive cards' own sentences and leaves, built with the first compress or password card so a launch compiles none of it.
+
+// One whole sentence per count for the compress card's title, so no caller joins a fragment.
+function compressTitle(count) {
+    if (count === 1) return "Compress 1 item"
+    return "Compress %1 items".replace("%1", Format.count(count))
+}
+
+// The extract card's title, from the same template rule.
+function encryptedTitle(leaf) {
+    return "%1 is encrypted".replace("%1", leaf)
+}
+
+// The card's sentence for a wrong answer, one template filled once.
+function wrongPasswordSentence(leaf) {
+    return "That password did not open %1.".replace("%1", leaf)
+}
+
+// The leaf of one path, the one cut every leaf reader shares.
+function leafOf(path) {
+    var text = String(path)
+    var cut = text.lastIndexOf("/")
+    return cut >= 0 ? text.substring(cut + 1) : text
+}
+
+// The leaf of the archive a card was opened over.
+function sourceLeaf(source) {
+    return leafOf(source && source.path ? source.path : "")
+}
+
+// The leaf of each resolved path, for a card opened over more than one file.
+function pathLeaves(paths) {
+    var out = []
+    var list = paths || []
+    for (var i = 0; i < list.length; i++) out.push(leafOf(list[i]))
+    return out
+}
+
+// What a second password request is told while a card is open, one sentence for compress and extract alike.
+var CARD_BUSY = "Another archive is waiting for its password. Enter it, then try again."

package/ui/js/ArchiveOps.js

@@ -0,0 +1,44 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Ops.js" as Ops
+.import "Search.js" as Search
+
+// The With-password compress and the encrypted extract's retry, over resolved paths: a row index names another file once the listing moves.
+function openCompressPassword(pane, menuId, cards) {
+    var idx = Ops.targetIndices(pane)
+    if (idx.length === 0) return Ops.sayNoTarget(pane)
+    pane.pathsPending = { kind: "compressPassword",
+        deliver: function (list) { compressPasswordResolved(cards, pane, list, menuId) } }
+    pane.backend.askPaths(idx)
+}
+
+// The answer to askPaths: the paths and menu id the cards host opens over.
+function compressPasswordResolved(cards, pane, paths, menuId) {
+    if (paths.length === 0) return Ops.sayNoTarget(pane)
+    cards.openCompressDialog({ paths: paths, menuId: menuId || 0 }, Ops.leaf(pane.path), pane)
+}
+
+// The dialog's Compress: the name is free, and the backend refuses a destination that appeared meanwhile.
+function submitCompressPassword(pane, source, format, name, password, encryptNames) {
+    if (!source || !source.paths || source.paths.length === 0) {
+        return
+    }
+    var dest = pane.join(Search.baseOf(pane), name)
+    pane.backend.compressPassword(source.paths, dest, format, password, encryptNames, source.menuId)
+    // A refused send parks nothing, so only a sent compress shows its running line.
+    if (!pane.backend.queueing) pane.sticky(compressSticky(source.paths.length, format))
+}
+
+// The sticky line as one whole sentence per count, filled once, never joined from fragments.
+function compressSticky(count, format) {
+    return Format.fill(Ops.WORDS.compressing, Ops.items(count), format)
+}
+
+// The extract card's Extract: the archive and destination the card was opened over, retried with a password.
+function submitExtractPassword(pane, source, password) {
+    if (!source || !source.path) {
+        return
+    }
+    pane.backend.extractPassword(source.path, source.dest, password, 0)
+}

package/ui/js/BackReturn.js

@@ -0,0 +1,118 @@
+.pragma library
+
+// Back and Forward entries and the landing ui/PaneSwap.qml runs in the rows' turn.
+
+// A stack entry names the directory and the row its cursor stood on; bare paths read as empty rows.
+function makeEntry(path, name, index) {
+    return { path: String(path), name: String(name || ""), index: Math.max(0, Math.floor(Number(index) || 0)) }
+}
+
+function pathOf(entry) {
+    return typeof entry === "string" ? entry : String(entry.path || "")
+}
+
+function asEntry(target) {
+    return typeof target === "string" ? makeEntry(target, "", 0) : target
+}
+
+// The place a listing still out asked for, with the cursor its Back or Forward owes it; null when none is out or it re-reads the drawn folder.
+function pending(pane) {
+    if (!pane.listInFlight || !pane.listingPath || pane.listingPath === pane.path)
+        return null
+    var owed = pane.swap ? pane.swap.restore : null
+    if (owed && owed.path === pane.listingPath)
+        return makeEntry(owed.path, owed.name, owed.index)
+    return makeEntry(pane.listingPath, "", 0)
+}
+
+// A tab switch left its cursor, order and located row to its landing; the listing let go never lands, so a later one must not take them.
+function dropOwed(pane) {
+    if (pane.tabs)
+        Object.assign(pane.tabs, { pendingCursor: -1, pendingCursorName: null, pendingLocatePath: "", pendingSortBy: "", pendingSortDesc: false })
+}
+
+// The stack a Back or Forward still out pushed the drawn place onto, or "" when the listing out is any other.
+function pushedOnto(pane) {
+    var owed = pending(pane) && pane.swap ? pane.swap.restore : null
+    return owed && owed.pushedOnto ? owed.pushedOnto : ""
+}
+
+// The drawn folder with the cursor row it stands on; leaving a walk names no row, so the landing stays at the top.
+function drawn(pane) {
+    var walk = pane.searchMode === "results" || (pane.searchFrom || "").length > 0
+    var row = !walk && pane.rowFor ? pane.rowFor(pane.cursorIndex) : null
+    var entry = makeEntry(pane.path, row ? row.n : "", walk ? 0 : pane.cursorIndex)
+    if (pane.recentMode === "trash") { entry.collection = "trash"; entry.collectionFrom = pane.recentFrom }
+    return entry
+}
+
+// The departing cursor, or the pending place while a listing is out.
+function capture(pane) {
+    return pending(pane) || drawn(pane)
+}
+
+// One step through the stacks after Nav's guard, popping before the open pushes back.
+function travel(pane, from, to) {
+    var stack = pane[from]
+    var target = asEntry(stack[stack.length - 1])
+    pane[to] = (pane[to] || []).concat([capture(pane)])
+    pane[from] = stack.slice(0, -1)
+    if (target.collection === "trash") {
+        pane.trash.open()
+        if (target.collectionFrom) pane.recentFrom = target.collectionFrom
+        pane.pendingSelect = target.name ? pane.join(target.path, target.name) : ""
+        return
+    }
+    pane.openWithoutHistory(pathOf(target), { restore: Object.assign({}, target, { pushedOnto: to }), supersede: true })
+}
+
+// The landing in the rows reply's turn: name, then clamped index, then the top.
+function landRestore(pane, entry) {
+    if (!entry)
+        return
+    if (pane.path !== entry.path || (pane.searchMode || "").length > 0 || pane.total === 0)
+        return
+    var name = String(entry.name || "")
+    if (name.length > 0) {
+        for (var i = 0; i < pane.rows.length; i++) {
+            if (String(pane.rows[i].n) === name) {
+                pane.setCursor(pane.held + i)
+                return
+            }
+        }
+    }
+    pane.setCursor(Math.min(entry.index, pane.total - 1))
+}
+
+// True when a Back listing's first window lacks the owed name: the existing locate is sent and the rows wait for its window.
+function deferForLocate(pane, entry, items, listed) {
+    if (!entry || entry.pendingPath || !listed || listed.path !== entry.path)
+        return false
+    var name = String(entry.name || "")
+    if (name.length === 0 || !(listed.total > items.length) || (pane.searchMode || "").length > 0)
+        return false
+    for (var i = 0; i < items.length; i++) {
+        if (String(items[i].n) === name)
+            return false
+    }
+    if (!(pane.windowSize > 0) || typeof pane.backend.window !== "function")
+        return false
+    entry.pendingPath = pane.join(entry.path, name)
+    entry.total = listed.total
+    pane.backend.send({ c: "locate", path: entry.pendingPath })
+    return true
+}
+
+// The locate reply for a waiting landing fetches the window holding the row, or the clamped index on a miss.
+function takeLocated(pane, message) {
+    var entry = pane.swap ? pane.swap.restore : null
+    if (!entry || !entry.pendingPath || entry.fetched || !message
+            || message.path !== entry.pendingPath || message.directory !== entry.path)
+        return false
+    var index = Number(message.index)
+    if (!(index >= 0) || index >= entry.total)
+        index = Math.min(entry.index, entry.total - 1)
+    entry.fetched = true
+    pane.backend.window(index, pane.windowSize)
+    return true
+}

package/ui/js/BulkRename.js

@@ -0,0 +1,100 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Every user-facing string is one whole template with %1 slots, filled in one place, with no qsTr.
+var WORDS = {
+    footerPair: "%1 renamed · %2 unchanged",
+    footerInvalid: "%1 renamed · %2 unchanged · %3 invalid",
+    renameButton: "Rename %1",
+    cardTitle: "Rename %1 items",
+    sameLine: "same as line %1"
+}
+function applyFindReplace(oldNames, find, replace) {
+    var out = []
+    for (var i = 0; i < oldNames.length; i++) {
+        if (!find) out.push(oldNames[i])
+        else out.push(String(oldNames[i]).split(find).join(replace))
+    }
+    return out
+}
+
+// Linux filename components hold at most 255 bytes of UTF-8, the bound the backend refuses past.
+var NAME_BYTES = 255
+
+// Sample input: "\u00e9" counts 2, and a surrogate pair counts 4, as UTF-8 does.
+function utf8Bytes(text) {
+    var bytes = 0
+    for (var i = 0; i < text.length; i++) {
+        var code = text.charCodeAt(i)
+        if (code < 0x80) bytes += 1
+        else if (code < 0x800) bytes += 2
+        else if (code >= 0xd800 && code <= 0xdbff && (text.charCodeAt(i + 1) & 0xfc00) === 0xdc00) { bytes += 4; i += 1 }
+        else bytes += 3
+    }
+    return bytes
+}
+
+// Sample input: "trip/4123.HEIC" at line 4 names "contains /".
+function reasons(newNames) {
+    var out = new Array(newNames.length)
+    var seen = new Map()
+    for (var i = newNames.length - 1; i >= 0; i--) {
+        var text = String(newNames[i])
+        var r = ""
+        if (text.length === 0) r = "empty"
+        else if (text.indexOf("/") >= 0) r = "contains /"
+        else if (text === "." || text === ".." || text.indexOf("\u0000") >= 0 || text.indexOf("\r") >= 0 || text.indexOf("\n") >= 0) r = "invalid"
+        else if (utf8Bytes(text) > NAME_BYTES) r = "too long"
+        else if (seen.has(text)) r = WORDS.sameLine.replace("%1", seen.get(text) + 1)
+        out[i] = r
+        seen.set(text, i)
+    }
+    return out
+}
+
+// Counts split renamed, unchanged and invalid over the live rules alone; the backend refuses a name taken outside the batch.
+function counts(oldNames, newNames, reasons) {
+    var renamed = 0, unchanged = 0, invalid = 0
+    for (var i = 0; i < newNames.length; i++) {
+        if (reasons[i] !== "") invalid += 1
+        else if (String(newNames[i]) === String(oldNames[i])) unchanged += 1
+        else renamed += 1
+    }
+    return { renamed: renamed, unchanged: unchanged, invalid: invalid }
+}
+
+// Sample input: 5, 1, 0 names "5 renamed \u00b7 1 unchanged".
+function footer(renamed, unchanged, invalid) {
+    if (invalid > 0)
+        return WORDS.footerInvalid.replace("%1", Format.count(renamed)).replace("%2", Format.count(unchanged)).replace("%3", Format.count(invalid))
+    return WORDS.footerPair.replace("%1", Format.count(renamed)).replace("%2", Format.count(unchanged))
+}
+
+// The Rename button label carries the live renamed count.
+function renameLabel(renamed) {
+    return WORDS.renameButton.replace("%1", Format.count(renamed))
+}
+
+// The card names its count once; it only opens over several rows, so one plural form holds.
+function title(count) {
+    return WORDS.cardTitle.replace("%1", Format.count(count))
+}
+
+// A short newNames reads "" past its end; open()'s two assignments cross for one synchronous turn only, so no frame ever paints it.
+function nameAt(newNames, index) {
+    return index < newNames.length ? String(newNames[index]) : ""
+}
+
+// The card's Tab order, pure so tests/js pins the walk both ways.
+function focusStops(lines) {
+    var stops = ["find", "replace"]
+    for (var i = 0; i < lines; i++) stops.push("line " + (i + 1))
+    return stops.concat(["edit", "cancel", "rename"])
+}
+function nextStop(current, back, lines) {
+    var stops = focusStops(lines)
+    var at = stops.indexOf(current)
+    if (at < 0) return back ? stops[stops.length - 1] : stops[0]
+    return stops[(at + (back ? -1 : 1) + stops.length) % stops.length]
+}

package/ui/js/Buttons.js

@@ -0,0 +1,54 @@
+.pragma library
+
+// Sample input: primaryFor("collide") === "keep", isDestructive("trash", "delete") === true.
+// Variant A: one control for every dialog button, sized by Theme, primary is the safe Enter action.
+
+// The members of a set (the protocols) sit this many hairlines apart, 4 px at base size 14.
+var SET_GAP = 4
+// The segments of a settings chooser sit this many hairlines apart, 2 px at base size 14.
+var SEGMENT_GAP = 2
+// A focused control whose foreground hairline would match its rest draws its own frame this wide, inward.
+var RING = 2
+var DISABLED_OPACITY = 0.55
+// The pointer's wash and the press wash, laid in the control's own ink.
+var WASH_HOVER = 0.08
+var WASH_PRESS = 0.14
+// A primary's resting accent wash, at the press wash's weight.
+var WASH_PRIMARY = WASH_PRESS
+// Chrome marks scale by this factor; dialog buttons inset only their frame and wash by whole pixels.
+var PRESS_SCALE = 0.96
+var PRESS_MS = 150
+
+// One primary per dialog, fixed: it never moves with focus.
+var PRIMARY = {
+    trash: "cancel",
+    collide: "keep",
+    openWith: "open",
+    convert: "convert",
+    newFile: "create",
+    moveTo: "move",
+    copyTo: "copy",
+    network: "action",
+    permissions: "apply",
+    picker: "accept"
+}
+
+// A destructive action rests as the error label in a muted frame, never primary.
+var DESTRUCTIVE = {
+    trash: { "delete": true },
+    collide: { "replace": true },
+    picker: { "replace": true }
+}
+
+// Sample input: focusFrame(true, false, false) === "foreground", focusFrame(true, false, true) === "thick", focusFrame(false, false, true) === "thick", focusFrame(true, true, true) === "accent", focusFrame(false, true, false) === "thick".
+// What a focused control's own frame draws: one foreground hairline, one accent hairline for a set member where the accent has hue, or "thick", RING wide in the foreground, where a hairline would match the rest.
+function focusFrame(accentHasHue, setMember, restIsForeground) { return setMember !== true ? (restIsForeground === true ? "thick" : "foreground") : accentHasHue === true ? "accent" : "thick" }
+
+function primaryFor(dialog) {
+    return PRIMARY[dialog] || ""
+}
+
+function isDestructive(dialog, name) {
+    var set = DESTRUCTIVE[dialog] || {}
+    return set[name] === true
+}

package/ui/js/ChromeKeys.js

@@ -0,0 +1,116 @@
+.pragma library
+
+.import "Tabs.js" as Tabs
+
+// The chrome bar's and tab strip's keys while Tab holds the keyboard there, read raw so no preset shadows them (as ui/js/RailKeys.js).
+
+// The chrome's controls in the order Tab and the arrows walk them, named by glyph as ui/ChromeBar.qml names them.
+// flea-qml: the funnel stands left of the magnifier, so it is reached first.
+var ORDER = ["arrow-left", "arrow-up", "filter", "search", "sort", "list", "columns", "grid", "dual", "sliders"]
+// A press on these hands the keyboard to the surface it opens, as the pointer's press does; the rest keep it on the mark.
+var HANDS_OFF = ["search", "filter", "sliders"]
+var BLOCKING = Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier
+
+// The controls that are drawn and live, in order; a hidden or disabled one is never a stop.
+function controls(bar) {
+    if (!bar || !bar.visible || bar.inputLive === false) return []
+    return ORDER.filter(function (glyph) {
+        var mark = bar.buttonFor(glyph)
+        return mark !== null && mark.visible && mark.enabled
+    })
+}
+
+// How many stops the strip holds: each tab, then New tab; none while one tab leaves the strip closed.
+function tabStops(strip) {
+    return strip && strip.open ? strip.tabCount + 1 : 0
+}
+
+// Which of the ring's stops are drawn, keyed by the view name Focus.js gives each.
+function drawn(root, railAvailable) {
+    return {
+        rail: !!railAvailable,
+        chrome: controls(root.chromeBar).length > 0,
+        strip: tabStops(root.tabStrip) > 0
+    }
+}
+
+// Entering a stop forward lands on its first control (the strip: the current tab), backward on its last.
+function enter(root, view, forward) {
+    if (view === "chrome") {
+        var glyphs = controls(root.chromeBar)
+        root.chromeBar.focusedGlyph = glyphs[forward ? 0 : glyphs.length - 1]
+    } else if (view === "strip") {
+        root.tabStrip.focusedIndex = forward ? root.tabStrip.currentIndex : root.tabStrip.tabCount
+    }
+}
+
+function press(event) {
+    return event.key === Qt.Key_Return || event.key === Qt.Key_Enter || event.key === Qt.Key_Space
+}
+
+// Where an arrow, Home or End lands among count stops from at, without wrapping; -1 when the key is none of those.
+function target(event, at, count) {
+    if (event.key === Qt.Key_Home) return 0
+    if (event.key === Qt.Key_End) return count - 1
+    if (event.key === Qt.Key_Left) return Math.max(0, at - 1)
+    if (event.key === Qt.Key_Right) return Math.min(count - 1, at + 1)
+    return -1
+}
+
+// The live control nearest in ORDER to a glyph that went disabled or hidden; unknown names land on the first stop.
+function nearestLive(glyph, glyphs) {
+    var home = glyphs[0]
+    var want = ORDER.indexOf(glyph)
+    if (want < 0) return home
+    var best = Infinity
+    for (var i = 0; i < glyphs.length; i++) {
+        var dist = Math.abs(ORDER.indexOf(glyphs[i]) - want)
+        if (dist < best) { best = dist; home = glyphs[i] }
+    }
+    return home
+}
+
+function chromeKey(event, root) {
+    var bar = root.chromeBar
+    var glyphs = controls(bar)
+    var at = glyphs.indexOf(bar.focusedGlyph)
+    if (press(event)) {
+        // A stop that went disabled or hidden re-homes to the nearest live control and presses nothing, so Enter never acts on a control the user did not see focused.
+        if (at < 0) {
+            if (glyphs.length > 0) bar.focusedGlyph = nearestLive(bar.focusedGlyph, glyphs)
+            return
+        }
+        bar.buttonFor(glyphs[at]).activated()
+        if (HANDS_OFF.indexOf(glyphs[at]) >= 0) root.focusView = "list"
+        return
+    }
+    var to = target(event, at, glyphs.length)
+    if (to >= 0) bar.focusedGlyph = glyphs[to]
+}
+
+function stripKey(event, root) {
+    var strip = root.tabStrip
+    var at = Math.min(strip.focusedIndex, strip.tabCount)
+    if (press(event)) {
+        root.focusView = "list"
+        if (at < strip.tabCount) Tabs.selectAt(root, at)
+        else Tabs.openNew(root)
+        return
+    }
+    var to = target(event, at, strip.tabCount + 1)
+    if (to >= 0) strip.focusedIndex = to
+}
+
+// Every key a stop holds is answered here and the rest do nothing; a stop that is no longer drawn gives the key back to the list.
+function act(event, root) {
+    var chrome = root.focusView === "chrome"
+    if (chrome ? controls(root.chromeBar).length === 0 : tabStops(root.tabStrip) === 0) {
+        root.focusView = "list"
+        return false
+    }
+    if ((event.modifiers & BLOCKING) !== 0) return true
+    if (event.key === Qt.Key_Escape) root.focusView = "list"
+    else if (chrome) chromeKey(event, root)
+    else stripKey(event, root)
+    return true
+}