flea-qml 0.0.0-stage → 0.1.0

package/ui/BulkOldNames.qml

@@ -0,0 +1,47 @@
+import QtQuick
+import qs.Commons
+
+// The bulk card's old-names column: one still row per selected name.
+Column {
+    id: root
+    required property var oldNames
+    // The dialog's own half-width gap and stack gap, bound by the card so both halves stay equal.
+    required property int columnGap
+    required property int headGap
+    // How far a column's first name sits under its label: the new names box's hairline and 2 px of padding, in this column and in that box alike.
+    readonly property int rowsInset: Theme.spacing.hairline + 2
+    width: (parent.width - columnGap) / 2
+    spacing: headGap
+    Text {
+        text: "OLD NAMES"
+        color: Theme.color.muted
+        font.family: Theme.font.family
+        font.pixelSize: Theme.font.caption
+        textFormat: Text.PlainText
+    }
+    Column {
+        width: parent.width
+        topPadding: root.rowsInset
+        spacing: 0
+        Repeater {
+            model: root.oldNames
+            // The name centres in its row the way the new names' fields do, so both rest on the same pixel rows.
+            delegate: Item {
+                required property var modelData
+                required property int index
+                width: parent.width
+                height: Theme.fileRowHeight
+                Text {
+                    width: parent.width
+                    anchors.verticalCenter: parent.verticalCenter
+                    text: parent.modelData
+                    textFormat: Text.PlainText
+                    elide: Text.ElideRight
+                    color: Theme.color.muted
+                    font.family: Theme.font.family
+                    font.pixelSize: Theme.font.body
+                }
+            }
+        }
+    }
+}

package/ui/BulkRenameDialog.qml

@@ -0,0 +1,380 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import qs.Commons
+import "." as Flea
+import "js/BulkRename.js" as BulkRename
+
+// Bulk rename card: Find/Replace, one editable line per new name, live reasons, one Rename and one undo.
+FocusScope {
+    id: root
+    anchors.fill: parent
+    visible: opened || opacity > 0
+    // Closed means no input, even while the fade-out is still drawn.
+    enabled: opened
+    opacity: 0
+    property bool opened: false
+    property var oldNames: []
+    property var newNames: []
+    property var sourcePaths: []
+    property string folder: ""
+    property string find: ""
+    property string replace: ""
+    property var owner: null
+    // The board's 640 card, so a narrower window clamps it rather than clipping it.
+    readonly property real cardWant: 640
+    // The card's own padding, matching the 16 the buttons row and title already assume.
+    readonly property int cardPadding: 16
+    // 255 name bytes plus one newline per selected name, the TUI batch's own bound.
+    readonly property int nameLineBytes: 256
+    // The two half-width columns share one gap, so both halves measure the same remainder.
+    readonly property int columnGap: 14
+    // The new-names stack breathes less than a column gap, the way the old-names one does.
+    readonly property int stackGap: 4
+    // The names frame's sides, wider than its top and bottom for the caret; those take the old column's rowsInset.
+    readonly property int frameSide: 8
+    // A new name and its reason sit one side-inset apart.
+    readonly property int reasonGap: 8
+    // The mktemp leaf's fixed stem, so the cleanup guard measures the template it cleans.
+    readonly property string scratchStem: "flea-rename-"
+    property string terminalBase: ""
+    property string terminalDir: ""
+    property string terminalFile: ""
+    property bool terminalActive: false
+    property string terminalError: ""
+    readonly property var cardItem: card
+    // The model is a count; edits mutate one element and bump namesVersion, so a keystroke never rebuilds rows or steals the caret.
+    property int namesVersion: 0
+    property int focusedLine: -1
+    readonly property var allReasons: { root.namesVersion; return BulkRename.reasons(root.newNames) }
+    readonly property var counts: BulkRename.counts(root.oldNames, root.newNames, root.allReasons)
+    readonly property string footerText: BulkRename.footer(counts.renamed, counts.unchanged, counts.invalid)
+    readonly property string renameText: BulkRename.renameLabel(counts.renamed)
+    readonly property bool canRename: root.opened && counts.invalid === 0 && counts.renamed > 0
+    // The control holding the keyboard, so the capture case asserts Tab order without OCR.
+    readonly property string focusedControl: editButton.activeFocus ? "Edit in terminal"
+        : cancelButton.activeFocus ? "Cancel" : renameButton.activeFocus ? "Rename"
+        : findField.focused ? "Find" : replaceField.focused ? "Replace"
+        : namesScope.activeFocus && root.focusedLine >= 0 ? "line " + (root.focusedLine + 1) : ""
+    // Every Tab stop routes through the pure order in BulkRename.js, so Shift+Tab walks back the same way.
+    function stepFocus(current, back) {
+        var stop = BulkRename.nextStop(current, back, root.oldNames.length)
+        var why = back ? Qt.BacktabFocusReason : Qt.TabFocusReason
+        if (stop === "find") findField.takeFocus()
+        else if (stop === "replace") replaceField.takeFocus()
+        else if (stop === "edit") editButton.forceActiveFocus(why)
+        else if (stop === "cancel") cancelButton.forceActiveFocus(why)
+        else if (stop === "rename") renameButton.forceActiveFocus(why)
+        else root.focusNameLine(Number(stop.substring(5)) - 1, why)
+    }
+    // Return/Up/Down move the caret between name lines, stopping at the ends, as a text editor's lines do.
+    function focusNameLine(index, why, col) { if (index >= 0 && index < nameLines.count) nameLines.itemAt(index).takeFocus(why, col) }
+    function reasonAt(index) { return index < root.allReasons.length ? root.allReasons[index] : "" }
+    function changedAt(index) { root.namesVersion; return String(root.newNames[index]) !== String(root.oldNames[index]) }
+    function open(paths, holder) {
+        owner = holder
+        sourcePaths = paths.slice()
+        folder = String(paths[0]).substring(0, String(paths[0]).lastIndexOf("/")) || "/"
+        oldNames = paths.map(function (p) { return String(p).substring(String(p).lastIndexOf("/") + 1) })
+        newNames = oldNames.slice()
+        find = ""
+        replace = ""
+        terminalBase = ""
+        terminalDir = ""
+        terminalFile = ""
+        terminalActive = false
+        terminalError = ""
+        opened = true
+        findField.takeFocus()
+    }
+    function close() {
+        if (terminalActive) cleanupTerminal()
+        opened = false
+        if (owner) owner.forceActiveFocus()
+    }
+    function applyFind() {
+        newNames = BulkRename.applyFindReplace(root.oldNames, root.find, root.replace)
+    }
+    function commit() {
+        if (!root.canRename) return
+        var backend = owner.backend
+        var paths = root.sourcePaths.slice()
+        var names = root.newNames.slice()
+        root.close()
+        backend.bulkRename(paths, names)
+    }
+    // Edit in terminal: names go to a private mktemp dir, $EDITOR opens the file, and the card reads it back on exit.
+    function editInTerminal() {
+        root.terminalError = ""
+        if (root.terminalActive) root.cleanupTerminal()
+        root.terminalBase = Quickshell.env("TMPDIR") || "/tmp"
+        mktemp.command = ["mktemp", "-d", root.terminalBase + "/" + root.scratchStem + "XXXXXX"]
+        mktemp.running = true
+    }
+    // $EDITOR over the names file in a terminal through xdg-terminal-exec, the file riding as argv and never in the shell string.
+    function launchEditor() {
+        var editor = Quickshell.env("VISUAL") || Quickshell.env("EDITOR") || ""
+        if (!editor || editChild.running) {
+            root.terminalError = "Bulk rename could not open an editor."
+            return
+        }
+        editChild.command = ["xdg-terminal-exec", "--dir=" + root.folder, "--",
+            "/bin/sh", "-c", "exec " + editor + " \"$1\"", "flea-bulk-rename", root.terminalFile]
+        editChild.running = true
+    }
+    // A scratch dir is the base plus one flea-rename leaf, so a cleanup never walks elsewhere.
+    function isScratchDir(dir) {
+        if (terminalBase.length === 0 || dir.length <= terminalBase.length + root.scratchStem.length + 1) return false
+        if (dir.substring(0, terminalBase.length + 1) !== terminalBase + "/") return false
+        var leaf = dir.substring(terminalBase.length + 1)
+        if (leaf.indexOf("/") >= 0 || leaf.indexOf("..") >= 0) return false
+        return leaf.substring(0, root.scratchStem.length) === root.scratchStem
+    }
+    // Sample input: "first.png\nsecond.png\n", one name per line with a single trailing newline.
+    function reloadTerminal() {
+        terminalFileView.reload()
+        terminalFileView.waitForJob()
+        var text = terminalFileView.text()
+        if (text.length > root.oldNames.length * root.nameLineBytes) {
+            terminalError = "Bulk rename refused: the edited names exceed the filename limits."
+            return
+        }
+        var lines = String(text).split("\n")
+        if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop()
+        if (lines.length !== root.oldNames.length) {
+            terminalError = "Bulk rename refused: the number of names changed."
+            return
+        }
+        terminalError = ""
+        newNames = lines
+    }
+    function cleanupTerminal() {
+        terminalActive = false
+        if (root.terminalDir.length > 0 && isScratchDir(root.terminalDir)) {
+            cleanup.command = ["rm", "-rf", root.terminalDir]
+            cleanup.running = true
+        }
+        terminalDir = ""
+        terminalFile = ""
+    }
+    Keys.onPressed: function (event) {
+        if (event.key === Qt.Key_Escape) { root.close(); event.accepted = true; return }
+        if (event.key === Qt.Key_Tab || event.key === Qt.Key_Backtab) { event.accepted = true; return }
+        if (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) { event.accepted = true; return }
+        event.accepted = true
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    Process {
+        id: mktemp
+        stderr: StdioCollector { waitForEnd: true }
+        stdout: StdioCollector { waitForEnd: true }
+        onExited: function (code) {
+            var dir = String(mktemp.stdout.text).trim()
+            if (!root.opened) {
+                if (code === 0 && root.isScratchDir(dir)) { cleanup.command = ["rm", "-rf", dir]; cleanup.running = true }
+                return
+            }
+            if (code !== 0 || !root.isScratchDir(dir)) { root.terminalError = "Bulk rename could not make its edit directory."; return }
+            root.terminalDir = dir
+            root.terminalFile = dir + "/names"
+            // The file is created at 0600 here, so the editor's own save keeps it private.
+            prime.command = ["install", "-m", "0600", "/dev/null", root.terminalFile]
+            prime.running = true
+        }
+    }
+    // install names the mode at creation, the way the TUI batch's exclusive create does.
+    Process {
+        id: prime
+        onExited: function (code) {
+            if (!root.opened) { root.cleanupTerminal(); return }
+            if (code !== 0) { root.terminalError = "Bulk rename could not make its edit file."; root.cleanupTerminal(); return }
+            terminalFileView.path = root.terminalFile
+            terminalFileView.setText(root.newNames.join("\n") + "\n")
+            terminalFileView.waitForJob()
+            root.terminalActive = true
+            root.launchEditor()
+        }
+    }
+    Process {
+        id: editChild
+        onExited: function (code) {
+            if (!root.terminalActive) return
+            if (code === 0) root.reloadTerminal()
+            else root.terminalError = "Bulk rename could not open an editor."
+        }
+    }
+    Process {
+        id: cleanup
+    }
+    FileView {
+        id: terminalFileView
+        watchChanges: root.terminalActive
+        onFileChanged: if (root.terminalActive) root.reloadTerminal()
+    }
+    Connections {
+        target: findField.input
+        function onTextChanged() { root.find = findField.input.text; root.applyFind() }
+    }
+    Connections {
+        target: replaceField.input
+        function onTextChanged() { root.replace = replaceField.input.text; root.applyFind() }
+    }
+    Flea.DialogScrim {
+        onDismissed: root.close()
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        width: Theme.cardSpan(root.cardWant, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + 2 * root.cardPadding + 2 * Theme.spacing.hairline, root.height - 2 * Theme.spacing.gap)
+        color: Theme.color.surface
+        border.color: Theme.color.mutedFrame
+        border.width: Theme.spacing.hairline
+        radius: Style.cornerRadius
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onWheel: function (wheel) { wheel.accepted = true }
+        }
+        Flea.CardFrame {
+            id: body
+            bleed: Theme.focusClearance
+            anchors.fill: parent
+            anchors.leftMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.rightMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.topMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            anchors.bottomMargin: root.cardPadding + Theme.spacing.hairline - Theme.focusClearance
+            title: Flea.DialogTitle { width: parent.width; text: BulkRename.title(root.oldNames.length) }
+            buttons: Row {
+                anchors.right: parent.right
+                spacing: Theme.spacing.gap
+                // Tab reaches every button, the BulkRename board's callout 6: Qt's chain skips a button without activeFocusOnTab.
+                Flea.DialogButton { id: editButton; label: "Edit in terminal"; activeFocusOnTab: true; tabHandle: true; onTabbed: function (from, back) { root.stepFocus("edit", back) }; onActivated: root.editInTerminal() }
+                Flea.DialogButton { id: cancelButton; label: "Cancel"; activeFocusOnTab: true; tabHandle: true; onTabbed: function (from, back) { root.stepFocus("cancel", back) }; onActivated: root.close() }
+                Flea.DialogButton { id: renameButton; label: root.renameText; primary: true; available: root.canRename; activeFocusOnTab: true; tabHandle: true; onTabbed: function (from, back) { root.stepFocus("rename", back) }; onActivated: root.commit() }
+            }
+            Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Row {
+                    width: parent.width
+                    spacing: root.columnGap
+                    Flea.DialogField {
+                        id: findField
+                        width: (parent.width - root.columnGap) / 2
+                        label: "Find"
+                        onAccepted: root.commit()
+                        // A field reports Tab instead of moving, so the card keeps the keyboard inside itself.
+                        onTabbed: function (from, back) { root.stepFocus("find", back) }
+                    }
+                    Flea.DialogField {
+                        id: replaceField
+                        width: (parent.width - root.columnGap) / 2
+                        label: "Replace"
+                        onAccepted: root.commit()
+                        onTabbed: function (from, back) { root.stepFocus("replace", back) }
+                    }
+                }
+                Row {
+                    width: parent.width
+                    spacing: root.columnGap
+                    Flea.BulkOldNames {
+                        id: oldColumn
+                        oldNames: root.oldNames
+                        columnGap: root.columnGap
+                        headGap: root.stackGap
+                    }
+                    Column {
+                        width: (parent.width - root.columnGap) / 2
+                        spacing: root.stackGap
+                        Text {
+                            text: "NEW NAMES"
+                            color: Theme.color.muted
+                            font.family: Theme.font.family
+                            font.pixelSize: Theme.font.caption
+                            textFormat: Text.PlainText
+                        }
+                        Rectangle {
+                            id: namesBox
+                            width: parent.width
+                            color: Theme.color.background
+                            // One editor, so the frame follows the caret however many lines it holds.
+                            border.color: namesScope.activeFocus ? Theme.color.accent : Theme.color.mutedFrame
+                            border.width: Theme.spacing.hairline
+                            height: root.oldNames.length * Theme.fileRowHeight + 2 * oldColumn.rowsInset
+                            // One focus scope around the name lines, so the frame binds live focus state with no counter to drift.
+                            FocusScope {
+                                id: namesScope
+                                anchors.fill: parent
+                                anchors.topMargin: oldColumn.rowsInset
+                                anchors.bottomMargin: oldColumn.rowsInset
+                                anchors.leftMargin: root.frameSide
+                                anchors.rightMargin: root.frameSide
+                                Column {
+                                    anchors.fill: parent
+                                    spacing: 0
+                                    Repeater {
+                                        id: nameLines
+                                        model: root.oldNames.length
+                                        delegate: Row {
+                                            id: nameRow
+                                            required property int index
+                                            function takeFocus(why, col) { if (col !== undefined) nameField.cursorPosition = Math.min(col, nameField.length); nameField.forceActiveFocus(why) }
+                                            width: parent.width
+                                            height: Theme.fileRowHeight
+                                            spacing: root.reasonGap
+                                            TextInput {
+                                                id: nameField
+                                                width: parent.width - reason.width - parent.spacing
+                                                anchors.verticalCenter: parent.verticalCenter
+                                                text: BulkRename.nameAt(root.newNames, nameRow.index)
+                                                color: root.reasonAt(nameRow.index) ? Theme.color.errorOnSurface
+                                                    : root.changedAt(nameRow.index) ? Theme.color.foreground : Theme.color.muted
+                                                selectionColor: Theme.color.accent
+                                                font.family: Theme.font.family
+                                                font.pixelSize: Theme.font.body
+                                                clip: true
+                                                onActiveFocusChanged: if (activeFocus) root.focusedLine = nameRow.index
+                                                Keys.onTabPressed: function (event) { root.stepFocus("line " + (nameRow.index + 1), false); event.accepted = true }
+                                                Keys.onBacktabPressed: function (event) { root.stepFocus("line " + (nameRow.index + 1), true); event.accepted = true }
+                                                onTextChanged: {
+                                                    if (root.newNames[nameRow.index] === nameField.text) return
+                                                    root.newNames[nameRow.index] = nameField.text
+                                                    root.namesVersion++
+                                                }
+                                                Keys.onReturnPressed: function (event) { root.focusNameLine(nameRow.index + 1, Qt.OtherFocusReason); event.accepted = true }
+                                                Keys.onEnterPressed: function (event) { root.focusNameLine(nameRow.index + 1, Qt.OtherFocusReason); event.accepted = true }
+                                                Keys.onUpPressed: function (event) { root.focusNameLine(nameRow.index - 1, Qt.OtherFocusReason, nameField.cursorPosition); event.accepted = true }
+                                                Keys.onDownPressed: function (event) { root.focusNameLine(nameRow.index + 1, Qt.OtherFocusReason, nameField.cursorPosition); event.accepted = true }
+                                            }
+                                            Text {
+                                                id: reason
+                                                anchors.verticalCenter: parent.verticalCenter
+                                                text: root.reasonAt(nameRow.index)
+                                                textFormat: Text.PlainText
+                                                color: Theme.color.errorOnSurface
+                                                font.family: Theme.font.family
+                                                font.pixelSize: Theme.font.caption
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                Text {
+                    width: parent.width
+                    text: root.terminalError.length > 0 ? root.terminalError : root.footerText
+                    textFormat: Text.PlainText
+                    elide: Text.ElideRight
+                    color: root.terminalError.length > 0 ? Theme.color.errorOnSurface : Theme.color.foreground
+                    font.family: Theme.font.family
+                    font.pixelSize: Theme.font.caption
+                }
+            }
+        }
+    }
+}

package/ui/CardFrame.qml

@@ -0,0 +1,67 @@
+import QtQuick
+import "." as Flea
+
+// A dialog card's inner layout: the title and the button row stay pinned, and only the body between them scrolls (ui/CardScroll.qml).
+Item {
+    id: root
+
+    // The body is the default slot; the title and the button row stand outside the scroll.
+    default property alias content: scroll.content
+    property alias title: titleHolder.data
+    property alias buttons: buttonHolder.data
+    // The gap between the parts, the gap the single column kept between its children.
+    property real spacing: Theme.spacing.gap
+    // Room kept inside the clip, past each control's own frame, as CardScroll keeps it.
+    property int bleed: 0
+    property int bleedX: bleed
+    property int bleedY: bleed
+    property real revealClearY: 0
+
+    // What the three parts want together, for the card to clamp against the window.
+    readonly property real wanted: root.titleHeight + root.gapAfterTitle + scroll.wanted + root.gapBeforeButtons + root.buttonsHeight
+    readonly property real holderWidth: root.width - 2 * root.bleedX
+    property alias contentY: scroll.contentY
+    readonly property alias contentHeight: scroll.contentHeight
+    readonly property alias scrollItem: scroll
+    readonly property real titleHeight: titleHolder.childrenRect.height
+    readonly property real buttonsHeight: buttonHolder.childrenRect.height
+    // A part with no height takes no gap, as an invisible child of the column did.
+    readonly property real gapAfterTitle: root.titleHeight > 0 && (scroll.wanted > 0 || root.buttonsHeight > 0) ? root.spacing : 0
+    readonly property real gapBeforeButtons: root.buttonsHeight > 0 && scroll.wanted > 0 ? root.spacing : 0
+    // The body's room: what the card leaves between the pinned parts, never more than the body wants.
+    readonly property real bodyHeight: Math.max(0, Math.min(scroll.wanted,
+        root.height - 2 * root.bleedY - root.titleHeight - root.gapAfterTitle - root.gapBeforeButtons - root.buttonsHeight))
+
+    function reveal(item) { scroll.reveal(item) }
+    function holds(item) { return scroll.holds(item) }
+    function resetSteps() { scroll.resetSteps() }
+
+    Item {
+        id: titleHolder
+        objectName: "cardTitle"
+        x: root.bleedX
+        y: root.bleedY
+        width: root.holderWidth
+        height: root.titleHeight
+    }
+
+    Flea.CardScroll {
+        id: scroll
+        x: 0
+        y: root.titleHeight + root.gapAfterTitle
+        width: root.width
+        height: root.bodyHeight + 2 * root.bleedY
+        bleedX: root.bleedX
+        bleedY: root.bleedY
+        revealClearY: root.revealClearY
+    }
+
+    Item {
+        id: buttonHolder
+        objectName: "cardButtons"
+        x: root.bleedX
+        y: root.bleedY + root.titleHeight + root.gapAfterTitle + root.bodyHeight + root.gapBeforeButtons
+        width: root.holderWidth
+        height: root.buttonsHeight
+    }
+}

package/ui/CardScroll.qml

@@ -0,0 +1,79 @@
+import QtQuick
+import "." as Flea
+
+// A card body taller than the window: this viewport clamps to the card and scrolls the rest by wheel,
+// touchpad, keys and focus moves, with no bar and no lane, since a card never lists files.
+Flickable {
+    id: root
+
+    default property alias content: holder.data
+    // What the content wants, for the card to clamp against the window.
+    readonly property real wanted: holder.childrenRect.height
+    // Menus step the highlight instead of pixel scrolling: one row a notch through stepBy, one
+    // row per stepRowHeight of gained touchpad travel, with no tail. See FastScrollHandler.
+    property bool highlightSteps: false
+    property real stepRowHeight: Theme.rowHeight
+    property var stepBy: null
+    // Room kept inside the clip on every side, past each control's own frame; callers grow their margins by the same, so nothing moves.
+    property int bleed: 0
+    // The two axes apart, for a body whose rows already run to the card's side edges.
+    property int bleedX: bleed
+    property int bleedY: bleed
+    // Room reveal() keeps between the row and a clip edge an overlay fade covers while more content lies past it; the content's own ends clamp it away.
+    property real revealClearY: 0
+    // The holder's drawn width, so a probe reads it without walking children.
+    readonly property real holderWidth: holder.width
+
+    clip: true
+    contentWidth: width
+    contentHeight: root.wanted + 2 * root.bleedY
+    boundsBehavior: Flickable.StopAtBounds
+    // A highlight-stepped menu follows through reveal(); the Flickable takes no wheel itself.
+    interactive: !root.highlightSteps
+
+    // Tab into a field below the fold scrolls it into view with bleedY of clearance, so a form is never typed into blind and a focus frame is never cut; the ends clamp to the content.
+    function reveal(item) {
+        if (!item || root.contentHeight <= root.height || !root.holds(item))
+            return
+        var y = item.mapToItem(root.contentItem, 0, 0).y
+        var top = y - root.bleedY - root.revealClearY
+        var bottom = y + item.height + root.bleedY + root.revealClearY
+        if (top < root.contentY)
+            root.contentY = Math.max(0, top)
+        else if (bottom > root.contentY + root.height)
+            root.contentY = Math.min(root.contentHeight - root.height, bottom - root.height)
+    }
+
+    function holds(item) {
+        for (var it = item; it; it = it.parent) {
+            if (it === holder)
+                return true
+        }
+        return false
+    }
+
+    Connections {
+        target: root.Window.window
+        function onActiveFocusItemChanged() { root.reveal(root.Window.window.activeFocusItem) }
+    }
+
+    Flea.FastScrollHandler {
+        id: wheel
+        parent: root
+        flickable: root
+        stepMode: root.highlightSteps
+        stepRowHeight: root.stepRowHeight
+        stepBy: root.stepBy
+    }
+
+    // Drops every wheel remainder, so a menu opening never spends the last one's travel.
+    function resetSteps() { wheel.resetSteps() }
+
+    Item {
+        id: holder
+        // No lane: rows fill to the frame's padding on every surface using this.
+        x: root.bleedX
+        y: root.bleedY
+        width: Math.max(0, root.width - 2 * root.bleedX)
+    }
+}

package/ui/CheckBox.qml

@@ -0,0 +1,73 @@
+import QtQuick
+import "." as Flea
+
+// The one checkbox every surface draws, Containers rule 14. The box is the control and every member
+// wears it; state is filled against empty, so no palette has to separate accent from foreground.
+Item {
+    id: root
+
+    // "off", "on", or "some", which is a group heading's state and never a row's.
+    property string value: "off"
+    // Availability is not an off value: an unavailable box keeps whatever it holds and dims.
+    property bool available: true
+    // The keyboard turns an empty box's own frame foreground; a filled box, whose frame is already foreground, gains the keyline below.
+    property bool focused: false
+
+    readonly property bool filled: root.value !== "off"
+    // The board's mixed bar is 8 x 2 in an 18 px box, and the box scales from bodySmall 13 as its check does.
+    readonly property int barBaseWidth: 8
+    readonly property int barBaseHeight: 2
+    readonly property real boxScale: Theme.font.bodySmall / 13
+    readonly property Item barItem: bar
+    readonly property Item frameItem: frame
+    readonly property int borderWidth: 2 * Theme.spacing.hairline
+
+    // A 14px interior inside two 2px borders, so 18px outer at bodySmall 13.
+    implicitHeight: Math.round(14 * Theme.font.bodySmall / 13) + 2 * root.borderWidth
+    implicitWidth: root.implicitHeight
+    opacity: root.available ? 1 : Theme.disabledOpacity
+
+    Accessible.role: Accessible.CheckBox
+    Accessible.checked: root.value === "on"
+
+    Rectangle {
+        id: frame
+        anchors.fill: parent
+        color: root.filled ? Theme.color.foreground : "transparent"
+        border.width: root.borderWidth
+        border.color: root.filled || root.focused ? Theme.color.foreground : Theme.color.mutedFrame
+
+        // The mark is the fill cut away, so the control needs no third colour and no accent at all.
+        Flea.Glyph {
+            anchors.centerIn: parent
+            width: Theme.font.bodySmall * 10 / 13
+            height: width
+            strokeWidth: 3
+            visible: root.value === "on"
+            name: "check"
+            color: Theme.color.background
+        }
+
+        // A mixed box cuts the board's bar, a rectangle on whole pixels and not a glyph stroke spread over two rows.
+        Rectangle {
+            id: bar
+            width: Math.round(root.barBaseWidth * root.boxScale)
+            height: Math.max(1, Math.round(root.barBaseHeight * root.boxScale))
+            x: Math.round((parent.width - width) / 2)
+            y: Math.round((parent.height - height) / 2)
+            visible: root.value === "some"
+            color: Theme.color.background
+        }
+    }
+
+    // A focused filled box shows a foreground hairline past a one-hairline gap outside its frame; an empty box draws focus in its frame.
+    Rectangle {
+        objectName: "checkRing"
+        anchors.fill: parent
+        anchors.margins: -2 * Theme.spacing.hairline
+        color: "transparent"
+        border.width: Theme.spacing.hairline
+        border.color: Theme.color.foreground
+        visible: root.focused && root.filled
+    }
+}