flea-qml 0.0.0-stage → 0.1.0

package/ui/PaneRail.qml

@@ -0,0 +1,239 @@
+import QtQuick
+import "." as Flea
+import "js/Focus.js" as Focus
+import "js/Drag.js" as DragOps
+import "js/Eject.js" as Eject
+import "js/RailKeys.js" as RailKeys
+import "js/RailMenu.js" as RailMenu
+import "js/Motion.js" as Motion
+
+// The pane's rail, and the two ways it comes and goes. With Auto-hide sidebar off it is part of the
+// pane and Show sidebar governs it, which is 0.2.1's behaviour. Directive 77, the requirement:
+// hovering over the left side shows it, like every other autohide feature in every other file
+// manager. So with the switch on the rail is withdrawn at every width, the pointer at the
+// window's left edge reveals it over the pane rather than reflowing it, and it withdraws a moment
+// after the pointer or the keyboard leaves. It slides in and out on x, and is built once.
+Item {
+    id: root
+
+    property var pane: null
+    // The window-long network host from ui/WindowBody.qml, outliving the Sidebar loader so a late mount answer still lands.
+    property var service: null
+    readonly property bool overlay: ViewState.railAutoHide
+    readonly property bool hidden: root.overlay ? !root.revealed : ViewState.railHidden
+    // An overlay owes the pane no width, so the listing never reflows as the rail comes and goes.
+    // This item is that width, and the rail itself draws past it.
+    readonly property real inset: root.overlay ? 0 : rail.width
+    // Zero whenever the rail is withdrawn, though an auto-hide Sidebar stays built through the slide and after it.
+    readonly property real railWidth: root.hidden ? 0 : rail.width
+    readonly property var item: root.hidden ? null : rail.item
+    // Where the sliding rail stands, which tests and railState read.
+    readonly property real railX: rail.x
+
+    function focusPress(p) {
+        var pane = root.pane
+        if (p.x < 0 || p.y < 0 || p.x >= pane.width || p.y >= pane.height) return
+        // The shown Sidebar can extend past its zero-width overlay host.
+        var sidebar = root.item
+        var r = sidebar ? sidebar.mapFromItem(pane, p.x, p.y) : null
+        if (!root.hidden && r && r.x >= 0 && r.y >= 0 && r.x < sidebar.width && r.y < sidebar.height) {
+            if (root.overlay) pane.railPane.focusView = Focus.RAIL
+        } else { pane.focusView = Focus.LIST; pane.focusRequested() }
+    }
+
+    // Long enough that crossing the edge on the way somewhere else does not flash the rail, and that
+    // leaving it by a pixel on the way to a row does not drop it.
+    readonly property int settleMs: 220
+    property bool revealed: false
+    // The rail's own context menu takes the pointer with it, so without this the rail withdraws out
+    // from under the menu it just opened.
+    readonly property bool menuHere: root.pane !== null && root.pane.contextMenu().opened
+                                     && root.pane.contextMenu().forRail
+    // The rail stays up while the pointer is on it, which is the other half of the reveal.
+    readonly property bool over: railHover.hovered
+    // A release in flight keeps a revealed overlay rail up; the hold below is what keeps the Sidebar when it hides anyway.
+    readonly property bool releasing: rail.item !== null && (rail.item as Flea.Sidebar).releasing === true
+    // Keeps the Sidebar and its gio, undrawn, through a hide mid-release; latched from the release's edges, as a binding through hidden would loop.
+    property bool releaseHold: false
+    readonly property bool held: root.releaseHold && root.hidden
+    function holdRelease(on) {
+        if (on) { root.releaseHold = true; return }
+        // Past the signal that ended it, where the unload the hold was keeping would destroy the sender mid-emission.
+        Qt.callLater(function () { if (!root.releasing) root.releaseHold = false })
+    }
+    // The pointer has rested on the edge for the dwell, and stays so until it leaves the strip.
+    property bool edgeShown: false
+    // The Sidebar is built by the first strip entry or Tab and then kept, so later reveals spawn nothing and keep cursor and scroll.
+    property bool built: false
+    readonly property bool dragHere: dragReveal.containsDrag || root.rowDragOver(rail.item)
+    readonly property bool pointerWanted: root.edgeShown || root.over || root.menuHere || root.releasing || root.dragHere
+    readonly property bool focusWanted: root.pane !== null && root.pane.focusView === Focus.RAIL
+    readonly property bool wanted: root.pointerWanted || root.focusWanted
+    // 0 withdrawn to 1 shown; the rail's x follows it, and a reversal starts from where it stands.
+    property real slide: root.revealed ? 1 : 0
+    Behavior on slide {
+        enabled: !Theme.reducedMotion
+        NumberAnimation { duration: root.revealed ? Motion.durMs.open : Motion.durMs.close; easing.type: Easing.OutCubic }
+    }
+
+    onWantedChanged: {
+        if (root.wanted) { settle.stop(); root.revealed = true }
+        else if (root.revealed) settle.restart()
+    }
+    onRevealedChanged: if (root.revealed) root.built = true
+    // Tab out has no pointer to wait for, so the rail slides away at once; the pointer on the rail keeps it up through pointerWanted.
+    onFocusWantedChanged: if (!root.focusWanted && !root.pointerWanted && root.revealed) { settle.stop(); root.revealed = false }
+    // The switch itself is a fresh start either way: nothing is revealed until the pointer asks.
+    onOverlayChanged: { dwell.stop(); root.edgeShown = false; root.built = false; root.revealed = false }
+
+    anchors { top: parent.top; bottom: parent.bottom }
+    width: root.inset
+
+    Timer {
+        id: settle
+        interval: root.settleMs
+        onTriggered: root.revealed = false
+    }
+    Timer {
+        id: dwell
+        interval: Motion.dwellMs
+        onTriggered: root.edgeShown = true
+    }
+
+    // The strip that answers the pointer, at the window's own left edge and only while the switch is
+    // on. It holds no MouseArea, so a click on the listing under it still lands on the listing.
+    Item {
+        id: strip
+        anchors { left: parent.left; top: parent.top; bottom: parent.bottom }
+        width: Theme.spacing.rowPaddingX
+        enabled: root.overlay
+        HoverHandler {
+            id: edge
+            enabled: root.overlay
+            // Entering also builds the Sidebar, so the dwell covers the build; a rail already up needs no dwell.
+            onHoveredChanged: {
+                if (!edge.hovered) { dwell.stop(); root.edgeShown = false; return }
+                root.built = true
+                if (root.revealed) root.edgeShown = true
+                else dwell.restart()
+            }
+        }
+    }
+
+    // Below the rail so Trash answers first; refusing here keeps an overlay rail drop from falling through to the listing row under it.
+    DropArea {
+        id: dragReveal
+        objectName: "dragReveal"
+        anchors { left: parent.left; top: parent.top; bottom: parent.bottom }
+        width: Math.max(strip.width, rail.width)
+        enabled: root.overlay
+        keys: [DragOps.ROWS_MIME]
+        onDropped: function (drop) { drop.accepted = false }
+    }
+
+    Loader {
+        id: rail
+        anchors { top: parent.top; bottom: parent.bottom }
+        // The slide moves x only, so the rail's width and rows never change with the motion; visible drops when the hide slide ends.
+        x: root.overlay ? (root.slide - 1) * width : 0
+        width: item && !root.held ? item.implicitWidth : 0
+        visible: !root.held && (!root.overlay || root.slide > 0)
+        active: root.pane !== null && !root.pane.listOnly && root.pane.sharedSidebar === null
+                && (root.overlay ? (root.built || root.releaseHold) : (!root.hidden || root.releaseHold))
+        // A Sidebar that went for another reason took its release with it, so there is nothing left to hold.
+        onItemChanged: if (item === null) root.releaseHold = false
+        sourceComponent: Flea.Sidebar {
+            id: sidebar
+            backend: root.pane.backend
+            navigationPane: root.pane.railPane
+            service: root.service
+            polling: !root.overlay || root.revealed
+            focused: root.pane.railPane.focusView === Focus.RAIL
+            trashActive: root.pane.railPane.trash.browsing
+            onOpened: function(path) { RailKeys.openFrom(root.pane.railPane, path, sidebar) }
+            // Sidebar040: the rail's Recent row answers with the history's own paths, which the
+            // pane lists with listpaths; focus follows into the folder the way a mount's open does.
+            onRecentRequested: function (paths, requester, visits) { var target = requester || root.pane.railPane; target.openRecent(paths, visits); RailKeys.landed(target, sidebar) }
+            onTrashRequested: root.pane.railPane.trash.open()
+            onMessage: function(text, isError) { RailKeys.messaged(sidebar, isError); root.pane.message(text, isError) }
+            onOperationResult: function(headline, detail, isError) { RailKeys.messaged(sidebar, isError); root.pane.operationResult(headline, detail, isError) }
+            onForgetMessage: function(text) { root.pane.forgetMessage(text) }
+            menu: root.pane.railPane.contextMenu()
+            onRenameFinished: root.pane.railPane.listArea.forceActiveFocus()
+            // The pane's own PointHandler never sees a press a row grabs, so an overlay rail claims the keyboard itself; a docked rail leaves it.
+            onPressed: if (root.overlay) root.pane.railPane.focusView = Focus.RAIL
+            onReleasingChanged: root.holdRelease(sidebar.releasing)
+        }
+        // Disabled with the Sidebar, so an unload under the pointer clears it; a handler inside the Sidebar dies without reporting.
+        HoverHandler { id: railHover; enabled: rail.active && !root.held }
+    }
+
+    // The rail's Sidebar renders the window-long service below; the service's answers
+    // route once by origin in ui/WindowBody.qml, so this file carries no Connections of its
+    // own and a dual-view open cannot fire twice.
+
+    // Ctrl+E from a listing with the rail hidden. The rail Loader above unloads the Sidebar with
+    // its DeviceMounts poll, eject verdict state and releaseChosen, so the key has nothing to read
+    // and nothing to release through. It spins this transient instead: the same DeviceMounts
+    // component the rail uses, never a second poller, alive only for this flow. Its first listing
+    // resolves the holding volume through the same Mounts.holding and Mounts.railMenu verdict and
+    // releases through the same RailMenu.release and devices.eject path with the same messages;
+    // the verdict lands, the host unloads, and while nothing is pressed nothing here exists.
+    property bool hiddenEjectArmed: false
+    function unloadHiddenEject() {
+        // Past the signal that asked, which a synchronous unload would destroy mid-emission; a release in flight keeps the host, whose end kills its gio.
+        Qt.callLater(function () {
+            if (!hiddenEject.item || !hiddenEject.item.releasing)
+                hiddenEject.active = false
+        })
+    }
+    function ejectHidden() {
+        if (!root.pane)
+            return
+        if (!hiddenEject.active) {
+            hiddenEjectArmed = true
+            hiddenEject.active = true
+            return
+        }
+        // A flow is already waiting on its first listing, or an eject is running: re-resolve
+        // against the freshest entries, where the service refuses a concurrent eject itself.
+        hiddenEjectArmed = true
+        if (hiddenEject.item && hiddenEject.item.firstAnswered)
+            root.hiddenEjectReady()
+    }
+    function hiddenEjectReady() {
+        var device = hiddenEject.item
+        if (!device || !hiddenEjectArmed)
+            return
+        hiddenEjectArmed = false
+        // Sidebar shape with no network entries: only a volume resolves; a share keeps the pane's own answer.
+        var adapter = { entries: device.entries, deviceEntries: device.entries, networkEntries: [] }
+        adapter.releaseChosen = function (action, key) { RailMenu.release(action, key, device, null, adapter) }
+        Eject.release(root.pane, adapter, false)
+        root.unloadHiddenEject()
+    }
+    Loader {
+        id: hiddenEject
+        active: false
+        sourceComponent: Flea.DeviceMounts {
+            showUnmounted: ((ViewState.state.places || {}).showUnmounted !== false)
+            onOpened: function (path) { root.pane.open(path) }
+            onMessage: function (text, isError) { root.pane.message(text, isError) }
+            onOperationResult: function (headline, detail, isError) { root.pane.operationResult(headline, detail, isError) }
+            onReleasingChanged: root.unloadHiddenEject()
+            onForgetMessage: function (text) { root.pane.forgetMessage(text) }
+            onQuiesce: function (path) { root.pane.quiesceVolume(path) }
+            onFirstAnsweredChanged: root.hiddenEjectReady()
+        }
+    }
+
+    // A child row DropArea takes the drag from dragReveal; its live containsDrag binding keeps the rail up.
+    function rowDragOver(item) {
+        if (!item) return false
+        if (item.containsDrag === true) return true
+        for (var i = 0; i < item.children.length; i++) {
+            if (root.rowDragOver(item.children[i])) return true
+        }
+        return false
+    }
+}

package/ui/PaneStates.qml

@@ -0,0 +1,88 @@
+import QtQuick
+import "." as Flea
+import "js/Swap.js" as Swap
+import "js/Search.js" as Search
+import "js/KeyName.js" as KeyName
+
+// What a pane draws instead of rows: the empty hero, the reading spiral and the failure block. All
+// three sit over the same slot and are gated on the same listing state, so they live together and
+// ui/Pane.qml carries one child rather than three.
+Item {
+    id: root
+
+    required property var pane
+    property bool trashOpen: false
+
+    readonly property alias emptyItem: emptyState
+    readonly property alias messageItem: paneMessage
+
+    // Every Columns hero centres on the pane while it clears the listed columns and their rules, else on the free area right of them.
+    readonly property var columns: root.pane.viewMode === "columns" ? root.pane.columnsArea : null
+    readonly property real heroWidth: emptyState.visible ? emptyState.naturalWidth
+        : loadingState.visible ? loadingState.naturalWidth : paneMessage.naturalWidth
+    readonly property bool overActive: !!root.columns && root.columns.activeX > 0
+        && root.pane.listSlot.width / 2 - root.heroWidth / 2 < root.columns.activeX
+    readonly property real heroX: root.pane.listSlot.x + (root.overActive ? root.columns.activeX : 0)
+    readonly property real heroSpan: root.overActive ? root.pane.listSlot.width - root.columns.activeX : root.pane.listSlot.width
+
+    Flea.EmptyState {
+        id: emptyState
+        x: root.heroX
+        y: root.pane.listSlot.y
+        width: root.heroSpan
+        height: root.pane.listSlot.height
+        visible: !root.trashOpen && root.pane.listingState === "empty"
+        caption: Search.live(root.pane) ? Search.nothingMatches(root.pane.swap.answeredQuery) : ""
+        mark: "search"
+        hint: Search.live(root.pane) ? "Press Escape to clear."
+            : ViewState.keyHints ? KeyName.hinted("Press %1 for a new folder.", "newFolder") : ""
+    }
+
+    Flea.LoadingState {
+        id: loadingState
+        x: root.heroX
+        y: root.pane.listSlot.y
+        width: root.heroSpan
+        height: root.pane.listSlot.height
+        // A listing past its wait is the Error state, so the crawl yields to the sentence.
+        visible: !root.trashOpen && root.pane.listingState === "loading"
+        heldOff: root.pane.swap.fellBack
+        holdOffMs: Swap.markHoldOff(root.pane.searchMode)
+        onShownChanged: root.pane.swap.markShown(shown)
+    }
+
+    // While a listing is out a press or wheel notch over the header, filter or rows lands on nothing; the handlers gate it, not enabled.
+    MouseArea {
+        x: root.pane.listSlot.x
+        y: root.pane.header.y
+        width: root.pane.listSlot.width
+        height: root.pane.listSlot.y + root.pane.listSlot.height - root.pane.header.y
+        enabled: !root.trashOpen
+        acceptedButtons: Qt.AllButtons
+        onPressed: function (mouse) {
+            mouse.accepted = root.pane.listInFlight
+            if (mouse.accepted) root.pane.message(Swap.LOADING, false)
+        }
+        onWheel: function (wheel) { wheel.accepted = root.pane.listInFlight }
+        // Passive, above the rows, so it sees a row's press and its release even after the row is rebuilt; a platform drag takes the release, so ui/FileDrag.qml liftEnded clears the hold.
+        PointHandler {
+            acceptedButtons: Qt.AllButtons
+            onActiveChanged: root.pane.pointerHeld = active
+        }
+    }
+
+    Flea.StateMessage {
+        id: paneMessage
+        active: !root.trashOpen
+        x: root.heroX + Theme.spacing.rowPaddingX
+        y: root.pane.listSlot.y
+        width: root.heroSpan - 2 * Theme.spacing.rowPaddingX
+        height: root.pane.listSlot.height
+        message: root.pane.stateMessage
+        listingState: root.pane.listingState
+        lockedMode: root.pane.lockedMode
+        total: root.pane.total
+        filterQuery: root.pane.filterQuery
+        shown: root.pane.filterQuery.length > 0 ? root.pane.shownTotal : -1
+    }
+}

package/ui/PaneSwap.qml

@@ -0,0 +1,339 @@
+import QtQuick
+import "js/RecentMode.js" as RecentMode
+import "js/Anchor.js" as Anchor
+import "js/BackReturn.js" as BackReturn
+import "js/DirSizes.js" as DirSizes
+import "js/Nav.js" as Nav
+import "js/Reload.js" as Reload
+import "js/Search.js" as Search
+import "js/Startup.js" as Startup
+import "js/Swap.js" as Swap
+import "js/Tabs.js" as Tabs
+import "js/Thumbs.js" as Thumbs
+
+// Where a listing's listed and rows replies land, holding the old rows until they do; see AGENTS.md "The listing swap".
+Item {
+    id: root
+
+    property var pane: null
+    // ui/PaneWire.qml, which owns the anchor, the retry and the rename a landing listing settles.
+    property var wire: null
+    // The cursor a Back or Forward owes the asked listing, or null; hold() arms each listing's own.
+    property var restore: null
+    // The first window a landing set aside while its locate is out, or null.
+    property var parked: null
+    // A locate that never answers is a listing that never answers, so past Startup's listing wait the parked rows land at the top.
+    property int parkedWaitMs: Startup.LISTING_WAIT_MS
+    // Built on the first park, so a window that never parks a Back starts no object for it.
+    property var parkedWait: null
+    onParkedChanged: {
+        if (!root.parked) {
+            if (root.parkedWait !== null) root.parkedWait.stop()
+            return
+        }
+        if (root.parkedWait === null) {
+            var made = Qt.createComponent("ParkedWait.qml")
+            if (made.status !== Component.Ready) throw new Error("ParkedWait.qml did not load: " + made.errorString())
+            root.parkedWait = made.createObject(root, { swap: root })
+        }
+        root.parkedWait.restart()
+    }
+    property var phase: Swap.idle()
+    readonly property bool holding: root.phase.holding
+    readonly property bool fellBack: root.phase.fellBack
+
+    // What tests/ui.sh noblank reads through ui/Ipc.qml swapState: how each hold ended and every empty frame.
+    property int holds: 0
+    property int fallbacks: 0
+    // Rows lines that waited out the loading mark's minimum, which a rows line landing late does not count.
+    property int waits: 0
+    property int blankFrames: 0
+    // The gen whose rows last landed: a new gen parks the cursor on its best match, a re-answer keeps the file.
+    property int landedGen: 0
+    // The query the drawn rows answered, set in the turn they land; rows read it, never the live text.
+    property string answeredQuery: ""
+    property int loadingFrames: 0
+    property var last: ({ ms: 0, end: "" })
+    // When ui/PaneStates.qml drew the loading mark, 0 while none is drawn, and how long the last one stood.
+    property double markSince: 0
+    property int shownMs: 0
+    // Rows lines that came while the mark still owed time, landed in arrival order once it has stood its minimum.
+    property var waiting: []
+    // True from the turn after the search strip's first frame until the session closes: the views build what an answer draws then, unseen.
+    property bool searchWarm: false
+
+    // ui/js/Nav.js asks for every listing here; false means nothing is held, and one after a live answer holds the walk's state unless clearAtOnce.
+    function hold(ask) {
+        root.restore = ask.restore ? Object.assign({}, ask.restore) : null
+        root.parked = null
+        var now = Date.now()
+        root.phase = Swap.begin(root.phase, root.pane.listingState, root.pane.searchMode, ask, now)
+        if (!root.holding)
+            return false
+        root.holds += 1
+        cap.interval = Swap.capLeft(root.phase, now)
+        cap.restart()
+        return true
+    }
+
+    function markShown(shown) {
+        if (!shown && root.markSince > 0)
+            root.shownMs = Date.now() - root.markSince
+        root.markSince = shown ? Date.now() : 0
+    }
+
+    // The listed line held or fallen-back rows, or a drawn mark, wait for is kept for them, an earlier request's is dropped, any other applied.
+    function takeListed(total, readMs, sortMs, path, changed, gen) {
+        if (Swap.dropSessionLine(root.pane.searchMode, gen, root.pane.searchGen, root.pane.searchLeaving === true, root.pane.searchOpenedGen)) {
+            return
+        }
+        var marked = Swap.marked(root.markSince, root.pane.listInFlight, root.pane.searchMode, root.phase.walk)
+        var action = Swap.onListed(root.phase, root.pane.listInFlight, path, root.pane.listingPath, marked)
+        if (action === Swap.DROP) {
+            return
+        }
+        if (Swap.keepLive(root.pane.searchMode, root.pane.listInFlight) || action === Swap.KEEP) {
+            root.phase = Swap.kept(root.phase, { total: total, readMs: readMs, sortMs: sortMs, path: path, changed: changed })
+            root.pane.listedSeen = true
+            return
+        }
+        root.phase = Swap.heard(root.phase, root.pane.searchMode === Search.RESULTS)
+        root.applyListed(total, readMs, sortMs, path, changed)
+    }
+
+    // A rows line lands with the listed line kept for it, or alone; one ahead of its listed line is dropped as it always was.
+    function takeRows(start, items, kinds, listing, gen) {
+        if (Swap.dropSessionLine(root.pane.searchMode, gen, root.pane.searchGen, root.pane.searchLeaving === true, root.pane.searchOpenedGen)) {
+            return
+        }
+        var marked = Swap.marked(root.markSince, root.pane.listInFlight, root.pane.searchMode, root.phase.walk)
+        var left = marked ? Swap.showLeft(root.markSince, Date.now()) : 0
+        var action = Swap.onRows(root.phase, root.pane.listInFlight, root.pane.listedSeen, left)
+        if (action === Swap.DROP) {
+            return
+        }
+        if (action === Swap.WAIT) {
+            root.waiting.push({ start: start, items: items, kinds: kinds, listing: listing, gen: gen })
+            root.waits += 1
+            minShow.interval = left
+            minShow.restart()
+            return
+        }
+        if (gen > 0 && gen === root.pane.searchGen && root.pane.searchFirstRowsAt === 0) {
+            root.pane.searchFirstRowsAt = Date.now()
+        }
+        // A re-sort renumbers every row, so a selection made while it was in flight names other files under the new numbering.
+        if (Swap.clearsSelection(root.pane.backend.heldListing, listing) && root.pane.selectionCount() > 0)
+            root.pane.clearSelection()
+        root.pane.backend.heldListing = listing
+        root.stampTags(items, action === Swap.LAND || root.pane.listInFlight)
+        // Only a live answer names its query; a plain window reply answers none, so a scroll keeps the marks.
+        if (gen > 0)
+            root.answeredQuery = root.pane.searchQuery
+        if (action === Swap.LAND) {
+            // The owed name sits outside this window, so these rows wait for the window its locate names.
+            if (BackReturn.deferForLocate(root.pane, root.restore, items, root.phase.listed)) {
+                root.parked = { start: start, items: items, kinds: kinds }
+                return
+            }
+            root.parked = null
+            root.land(start, items, kinds, gen > 0 && gen !== root.landedGen && (root.pane.searchQuery || "").length > 0)
+            root.landedGen = gen
+            return
+        }
+        root.pane.held = start
+        root.pane.rows = RecentMode.stampRows(root.pane, items)
+        root.pane.kindNames = kinds
+        root.rowsLanded()
+    }
+
+    // A rows reply is the held window: a tagged row builds the tag state, which stamps each row with its folder's slot.
+    function stampTags(items, fresh) {
+        if (root.pane.tagState === null && !items.some(function (row) { return row.tg !== undefined }))
+            return
+        root.pane.tags().take(items, fresh)
+    }
+
+    // Reset, path and rows land in one turn (past the cap the reset already ran); a re-answer keeps the cursor's file, a new query takes row 0.
+    function land(start, items, kinds, fresh) {
+        var reply = root.phase.listed
+        var keep = root.pane.searchMode.length > 0 && start === 0 && !fresh && root.pane.rowFor(root.pane.cursorIndex)
+        // A live answer on the base the rows already stand on keeps the folder sizes and thumbnails it lists again; the first answer and an exit start clean.
+        var again = root.pane.searchLeaving !== true && root.pane.searchBase === reply.path
+            && (root.pane.searchMode === Search.TYPING || root.pane.searchMode === Search.RESULTS)
+        var sizes = DirSizes.inlined(again ? DirSizes.carried(root.pane.dirSizeState, root.pane.rows, root.pane.held, items, start) : null, items, start)
+        var thumbs = again ? Thumbs.carried(root.pane.thumbState, root.pane.rows, root.pane.held, items, start) : null
+        if (root.holding)
+            root.release(Swap.landed(root.phase), "landed")
+        else
+            root.phase = Swap.landed(root.phase)
+        // The rows go in before the count, so each delegate the count builds is built on its own row.
+        root.pane.held = start
+        root.pane.rows = RecentMode.stampRows(root.pane, items)
+        root.pane.kindNames = kinds
+        root.applyListed(reply.total, reply.readMs, reply.sortMs, reply.path, reply.changed)
+        if (sizes)
+            root.pane.dirSizeState = sizes
+        if (thumbs)
+            root.pane.thumbState = thumbs
+        if (keep) {
+            root.pane.setCursor(Search.keptIndex(keep.n, items, start))
+        } else if (fresh) {
+            root.pane.setCursor(start)
+        }
+        root.rowsLanded()
+    }
+
+    // A refused located window, any other failure or the wait running out lands the rows set aside, at the top, so the listing still ends.
+    function landParked() {
+        var parked = root.parked
+        if (!parked || root.phase.listed === null)
+            return false
+        root.parked = null
+        root.restore = null
+        root.land(parked.start, parked.items, parked.kinds, false)
+        return true
+    }
+
+    // A failed or refused listing, or a kept live answer, lets the held rows go at once; the failure draws what it always did.
+    function drop() {
+        if (root.holding)
+            root.release(Swap.dropped(root.phase), "dropped")
+        else
+            root.phase = Swap.dropped(root.phase)
+    }
+
+    function release(next, end) {
+        var query = root.phase.query
+        root.last = { ms: Date.now() - root.phase.since, end: end }
+        cap.stop()
+        root.phase = next
+        Nav.forget(root.pane, query)
+    }
+
+    function stopWaiting() {
+        minShow.stop()
+        root.waiting = []
+    }
+
+    function applyListed(total, readMs, sortMs, path, changed) {
+        var pane = root.pane
+        pane.thumbState = Thumbs.empty()
+        pane.dirSizeState = DirSizes.empty()
+        pane.reloadChanged = (changed === undefined || changed === null) ? -1 : changed
+        if (!pane.dualMode && !pane.listInFlight && pane.searchMode.length === 0) {
+            // With remember on each folder keeps its own order, so the fallback every other folder opens with stays untouched.
+            if (ViewState.state.rememberSort === false)
+                ViewState.changeLeaf("sort", { key: pane.backend.sortBy === "mtime" ? "date" : pane.backend.sortBy,
+                                             reverse: pane.backend.sortDesc })
+            pane.appliedListingPreferences = pane.listingPreferences
+        }
+        if (pane.listInFlight) {
+            pane.listedSeen = true
+        }
+        pane.total = total
+        // A live answer replaces rows in place with listed.path as the base in the same turn.
+        if (pane.searchMode === Search.TYPING || pane.searchMode === Search.RESULTS) {
+            pane.searchBase = path
+            pane.listingState = Search.listingState(pane, total)
+            pane.stateMessage = ""
+            return
+        }
+        if (path.length > 0) pane.path = path  // the listing landed, so this is where the pane moves
+        pane.listingState = total === 0 ? "empty" : "ready"
+        pane.stateMessage = total === 0 ? "This folder is empty." : ""
+        pane.opened(pane.path)
+    }
+
+    // Everything a rows reply does once its rows are in the pane, whether they came alone or with a swap.
+    function rowsLanded() {
+        // A landed live answer marks the phase a search, so an exit re-list forgets at once.
+        if (root.pane.searchMode.length > 0) {
+            root.phase = Swap.heard(root.phase, true)
+        }
+        var pane = root.pane
+        if (pane.rowsAt === 0 && pane.inputAt > 0 && pane.rowFor(pane.cursorIndex))
+            pane.rowsAt = Date.now()
+        pane.applyPendingSelect()
+        root.wire.anchor = Anchor.apply(pane, root.wire.anchor, Theme.fileRowHeight)
+        if (pane.preferenceAnchor)
+            pane.preferenceAnchor = Anchor.applyPreference(pane, pane.preferenceAnchor)
+        // A manual reload's notice, said only when rows changed; every other listing owes none.
+        Reload.landed(pane)
+        Tabs.applyPending(pane)
+        // The Back or Forward cursor lands with the rows, in this same turn, or not at all.
+        BackReturn.landRestore(pane, root.restore)
+        root.restore = null
+        pane.listArea.restartSettle()
+        if (pane.listInFlight) {
+            pane.listInFlight = false
+            pane.listedSeen = false
+        }
+        root.wire.locateRetry()
+        root.wire.openRenameOnArrival()
+    }
+
+    function describe() {
+        return { holding: root.holding, fellBack: root.fellBack, holds: root.holds, fallbacks: root.fallbacks, waits: root.waits,
+                 blankFrames: root.blankFrames, loadingFrames: root.loadingFrames, last: root.last, shownMs: root.shownMs }
+    }
+
+    // A slow listing falls back to the loading state, which stands until its rows land with their listed line.
+    Timer {
+        id: cap
+        repeat: false
+        onTriggered: {
+            if (!root.holding)
+                return
+            root.fallbacks += 1
+            root.release(Swap.expired(root.phase), "expired")
+        }
+    }
+
+    // The mark has stood its minimum, so the rows that came meanwhile land now.
+    Timer {
+        id: minShow
+        repeat: false
+        onTriggered: {
+            var rows = root.waiting
+            root.waiting = []
+            // Every line that arrived inside the minimum lands now, in the order it arrived.
+            for (var i = 0; i < rows.length; i++)
+                root.takeRows(rows[i].start, rows[i].items, rows[i].kinds, rows[i].listing, rows[i].gen)
+        }
+    }
+
+    Connections {
+        target: root.pane
+        function onListInFlightChanged() {
+            if (root.pane.listInFlight)
+                return
+            cap.stop()
+            root.stopWaiting()
+            root.restore = null
+            root.parked = null
+            root.phase = Swap.ended(root.phase)
+        }
+        function onSearchModeChanged() { if (root.pane.searchMode.length === 0) root.searchWarm = false }
+    }
+
+    // Runs one turn after the frame that drew the strip, so the strip never waits for what it builds.
+    function warmSearch() { root.searchWarm = root.pane.searchMode.length > 0 }
+
+    // afterAnimating runs on this thread just before each frame is synchronised, so it sees what that frame draws.
+    Connections {
+        target: root.Window.window
+        function onAfterAnimating() {
+            // Search and "/" never put a list in flight, so their blank is no row drawn while the count still names rows.
+            var live = Search.live(root.pane) || root.pane.filterQuery.length > 0
+            var kind = Swap.frameKind(root.pane.listInFlight, root.pane.listingState, root.fellBack,
+                root.pane.rows.length, root.pane.total, live)
+            if (kind === "blank")
+                root.blankFrames += 1
+            else if (kind === "loading")
+                root.loadingFrames += 1
+            if (root.pane.searchMode.length > 0 && !root.searchWarm)
+                Qt.callLater(root.warmSearch)
+        }
+    }
+}