flea-qml 0.0.0-stage → 0.1.0

package/ui/MenuActionDialog.qml

@@ -0,0 +1,396 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/Format.js" as Format
+import "js/PropertyFacts.js" as PropertyFacts
+import "js/Tags.js" as Tags
+
+// Menu-only actions share the existing card, field and button language.
+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
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    property bool opened: false
+    property string action: ""
+    property int requestId: 0
+    property string folder: ""
+    property var facts: ({})
+    // A folder's walk as the card knows it, null for anything else; the Size and Contains lines read it as it moves.
+    property var walk: null
+    // A file's codec, bit rate or photo facts as the facts reply sent them, empty until it lands; the pairs between Size and Modified read it.
+    property var extra: ({})
+    property string errorText: ""
+    property bool busy: false
+    property bool committing: false
+    property bool checkPending: false
+    property Item focusHolder: null
+    readonly property bool inputAction: action === "newFile" || action === "moveTo" || action === "copyTo"
+    readonly property bool deletionActive: action === "deletePermanently" && committing
+    readonly property bool canSubmit: !busy && inputAction && field.text.length > 0
+    // The lines that change in place while the folder counts; the model names them and is not rebuilt as the count moves.
+    readonly property var liveLines: facts.ok ? ({size: PropertyFacts.size(facts.bytes, walk), contains: PropertyFacts.contains(walk)}) : ({})
+    // Raw.html and Properties040: a photo's Camera, Lens, Exposure and Taken, the ones its EXIF names, sit before Modified.
+    readonly property var extraPairs: PropertyFacts.extraPairs(Object.assign({ok: root.facts.ok}, root.extra), root.facts.photo)
+    readonly property string title: ({moveTo: "Move to", copyTo: "Copy to", properties: "Properties", newFile: "New file", deletePermanently: "Delete permanently"})[action] || ""
+    // The card and its scrim step aside for the confirmation, and stay aside while it fades out with a closing dialog.
+    readonly property bool cardShown: !confirmation.opened && (root.opened || !confirmation.visible)
+    // Cleanup a closing reply defers until the fade ended, so the card holds still while it fades out.
+    property var settle: null
+    readonly property var cardItem: card
+    readonly property var confirmationItem: confirmation
+    readonly property var closeItem: closeButton
+    readonly property var submitItem: submitButton
+    readonly property var fieldItem: field
+    signal requested(var message)
+    signal approved(var message)
+    signal created(string path)
+    signal deleted(var message)
+    signal closed()
+
+    function open(operation, identity, parentPath, holder) {
+        action = operation
+        requestId = identity
+        folder = parentPath
+        focusHolder = holder
+        walk = null
+        extra = ({})
+        facts = ({})
+        errorText = ""
+        checkPending = false
+        confirmation.close()
+        settle = null
+        field.text = operation === "newFile" ? "New File" : parentPath
+        busy = operation === "properties" || operation === "deletePermanently"
+        committing = false
+        opened = true
+        body.contentY = 0
+        if (inputAction) { field.forceActiveFocus(); field.selectAll() }
+        else closeButton.forceActiveFocus()
+        if (busy) requested({c: "menuaction", op: operation === "deletePermanently" ? "prepareDelete" : "properties", id: requestId})
+    }
+    // Two dialogs share the one request id, so this one answers only for the ops it asked for:
+    // routing an Open with reply in here closed a Properties card that had just opened over it.
+    readonly property var ownedOps: ["properties", "prepareDelete", "refreshDelete", "checkDelete",
+                                     "delete", "validate", "newFile", "contents", "facts", ""]
+    function receive(message) {
+        if ((!opened && !deletionActive) || message.id !== requestId || message.op === "close") return
+        if (root.ownedOps.indexOf(message.op === undefined ? "" : message.op) < 0) return
+        if (deletionActive && message.op !== "delete") return
+        // A late count after the card left Properties changes nothing; a refused one ends as the floor already counted.
+        if (message.op === "contents") { if (walk) walk = PropertyFacts.next(walk, message); return }
+        // A refused or late facts reply adds no pair; the card already says everything else.
+        if (message.op === "facts") { if (message.ok) extra = message; return }
+        // A reply that ends the card keeps its busy look until the fade ended.
+        var ends = message.ok && !message.stale && (message.op === undefined || message.op === "" || message.op === "validate" || message.op === "newFile")
+        if (!ends) { busy = false; committing = false }
+        if (!message.ok) {
+            confirmation.close()
+            opened = true
+            closeButton.forceActiveFocus()
+            errorText = message.error || "That action could not be completed."
+            return
+        }
+        if (message.stale || message.op === "checkDelete" && !message.valid) { refreshDeletion(); return }
+        if (message.op === "prepareDelete" || message.op === "refreshDelete") {
+            facts = message
+            if (checkPending) { checkPending = false; refreshDeletion() }
+            else confirmation.open(message)
+            return
+        }
+        if (message.op === "checkDelete") {
+            if (checkPending) { checkPending = false; refreshDeletion() }
+            return
+        }
+        if (message.op === "delete") { deleted(Object.assign({count: facts.count}, message)); finish(); return }
+        if (message.op === "properties") {
+            walk = message.directory ? PropertyFacts.begin(message) : null
+            facts = message
+            if (walk) requested({c: "menuaction", op: "contents", id: requestId})
+            else if (message.kind === "File") requested({c: "menuaction", op: "facts", id: requestId})
+            return
+        }
+        if (message.op === "validate") { approved(message); closeSettled(); return }
+        if (message.op === "newFile") created(message.path)
+        closeSettled()
+    }
+    // The close of a finished reply: the busy look it left is cleared once the card is gone.
+    function closeSettled() {
+        settle = function () { busy = false; committing = false }
+        finish()
+        settleNow()
+    }
+    function settleNow() {
+        if (opacity !== 0 || settle === null) return
+        var run = settle
+        settle = null
+        run()
+    }
+    onOpacityChanged: root.settleNow()
+    function close() {
+        if (!opened || busy && committing && action === "newFile") return
+        finish()
+    }
+    function finish() {
+        requested({c: "menuaction", op: "close", id: requestId})
+        confirmation.close()
+        opened = false
+        closed()
+        if (focusHolder) focusHolder.forceActiveFocus()
+    }
+    function refreshDeletion() {
+        confirmation.close()
+        opened = true
+        busy = true
+        errorText = ""
+        closeButton.forceActiveFocus()
+        requested({c: "menuaction", op: "refreshDelete", id: requestId})
+    }
+    function checkDeletion() {
+        if (!opened || action !== "deletePermanently" || errorText) return
+        if (busy) { checkPending = true; return }
+        busy = true
+        requested({c: "menuaction", op: "checkDelete", id: requestId, token: facts.token})
+    }
+    function sourceChanged() {
+        if (!opened || action !== "deletePermanently" || errorText) return
+        confirmation.close()
+        if (busy) checkPending = true
+        else refreshDeletion()
+    }
+    function submit() {
+        if (!canSubmit) return
+        if (action !== "newFile" && field.text.charAt(0) !== "/") {
+            errorText = "Enter a full folder path, starting with /."
+            return
+        }
+        if (action === "newFile" && (field.text === "." || field.text === ".." || field.text.indexOf("/") >= 0)) {
+            errorText = "Enter a name without a /."
+            return
+        }
+        if (action === "newFile") body.forceActiveFocus()
+        else closeButton.forceActiveFocus()
+        busy = true
+        committing = true
+        errorText = ""
+        if (action === "newFile") requested({c: "newfile", op: "newFile", id: requestId, path: folder, name: field.text})
+        else requested({c: "menuaction", op: "validate", id: requestId, action: action, dest: field.text})
+    }
+    // Each focusable child routes Tab here before Qt can move focus outside the card.
+    function stepFocus(back) {
+        var items = [field, closeButton, submitButton].filter(function(item) {
+            return item.visible && item.enabled && item.activeFocusOnTab
+        })
+        if (!items.length) return
+        var current = -1
+        for (var i = 0; i < items.length; i++) if (items[i].activeFocus) current = i
+        var next = current < 0 ? (back ? items.length - 1 : 0)
+            : (current + (back ? -1 : 1) + items.length) % items.length
+        items[next].forceActiveFocus()
+    }
+    Keys.onTabPressed: function(event) { root.stepFocus((event.modifiers & Qt.ShiftModifier) !== 0); event.accepted = true }
+    Keys.onBacktabPressed: function(event) { root.stepFocus(true); event.accepted = true }
+    Keys.onEscapePressed: function(event) { root.close(); event.accepted = true }
+    Keys.onPressed: function(event) { event.accepted = true }
+    Rectangle {
+        anchors.fill: parent
+        visible: root.cardShown
+        color: Theme.color.background
+        opacity: 0.5
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onClicked: root.close()
+            onWheel: function(wheel) { wheel.accepted = true }
+        }
+    }
+    Rectangle {
+        id: card
+        visible: root.cardShown
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        width: Theme.cardSpan(Theme.space(420) * Theme.dialogWidthRatio, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + 2 * Theme.spacing.rowPaddingX, 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.margins: Theme.spacing.rowPaddingX - Theme.focusClearance
+            title: Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Flea.DialogTitle {
+                    width: parent.width
+                    text: root.title
+                }
+                Rectangle { width: parent.width; height: Theme.spacing.hairline; color: Theme.color.mutedFrame; opacity: 0.4 }
+            }
+            buttons: Row {
+                anchors.right: parent.right
+                spacing: Theme.spacing.gap
+                Flea.DialogButton {
+                    id: closeButton
+                    label: root.action === "properties" ? "Close" : "Cancel"
+                    available: !(root.busy && root.committing && root.action === "newFile")
+                    tabHandle: true
+                    tabStop: true
+                    onTabbed: function(from, back) { root.stepFocus(back) }
+                    onActivated: root.close()
+                }
+                Flea.DialogButton {
+                    id: submitButton
+                    visible: root.action !== "properties" && root.action !== "deletePermanently"
+                    label: root.action === "newFile" ? "Create" : root.action === "moveTo" ? "Move" : "Copy"
+                    primary: true
+                    available: root.canSubmit
+                    tabHandle: true
+                    tabStop: true
+                    onTabbed: function(from, back) { root.stepFocus(back) }
+                    onActivated: root.submit()
+                }
+            }
+            Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Text {
+                    width: parent.width
+                    visible: root.inputAction
+                    text: root.action === "newFile" ? "Name" : "Destination folder"
+                    textFormat: Text.PlainText
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.body }
+                }
+                Rectangle {
+                    visible: root.inputAction
+                    width: parent.width
+                    height: Theme.rowHeight - Theme.spacing.rowPaddingY
+                    color: Theme.color.background
+                    border.color: field.activeFocus ? Theme.color.accent : Theme.color.mutedFrame
+                    border.width: Theme.spacing.hairline
+                    TextInput {
+                        id: field
+                        anchors.left: parent.left
+                        anchors.right: parent.right
+                        anchors.verticalCenter: parent.verticalCenter
+                        anchors.leftMargin: Theme.spacing.gap
+                        anchors.rightMargin: Theme.spacing.gap
+                        color: Theme.color.foreground
+                        selectionColor: Theme.color.accent
+                        selectedTextColor: Theme.color.background
+                        font { family: Theme.font.family; pixelSize: Theme.font.body }
+                        activeFocusOnTab: root.inputAction
+                        enabled: !root.busy
+                        clip: true
+                        selectByMouse: true
+                        Accessible.name: root.action === "newFile" ? "Filename" : "Destination folder"
+                        Keys.onTabPressed: function(event) { root.stepFocus((event.modifiers & Qt.ShiftModifier) !== 0) }
+                        Keys.onBacktabPressed: root.stepFocus(true)
+                        Keys.onReturnPressed: root.submit()
+                        Keys.onEnterPressed: root.submit()
+                    }
+                }
+                Repeater {
+                    model: root.action === "properties" && root.facts.ok ? [
+                        ["Path", root.facts.path],
+                        ["Type", root.facts.kind],
+                        ["Size", "", "size"],
+                        ...(root.facts.directory ? [["Contains", "", "contains"]] : []),
+                        ...(root.extraPairs || []),
+                        // A foreign word stays untouched and shows here, so a tag another app set is visible.
+                        ...((root.facts.tags || []).length > 0 ? [["Tags", (root.facts.tags || []).join(", ")]] : []),
+                        ["Modified", Format.date(root.facts.modified)],
+                        ["Permissions", root.facts.mode],
+                        ["Owner", (root.facts.owner || "Unknown") + " (uid " + root.facts.uid + ")"],
+                        ["Group", "gid " + root.facts.gid],
+                        ...(root.facts.symlink ? [["Link target", root.facts.target]] : [])
+                    ] : []
+                    Column {
+                        id: pair
+                        required property var modelData
+                        // The Tags value is drawn as swatch and name per tag, so its plain string stays only as the model's text.
+                        readonly property bool tagged: modelData[0] === "Tags"
+                        width: body.holderWidth
+                        Text { width: parent.width; text: parent.modelData[0]; textFormat: Text.PlainText; color: Theme.color.muted; font { family: Theme.font.family; pixelSize: Theme.font.caption } }
+                        Text {
+                            readonly property var line: parent.modelData.length > 2 ? root.liveLines[parent.modelData[2]] : null
+                            visible: !pair.tagged
+                            width: parent.width
+                            text: line ? PropertyFacts.styled(line, Theme.color.muted) : parent.modelData[1]
+                            textFormat: line ? Text.StyledText : Text.PlainText
+                            wrapMode: Text.WrapAnywhere
+                            color: Theme.color.foreground
+                            font { family: Theme.font.family; pixelSize: Theme.font.body }
+                        }
+                        Flow {
+                            visible: pair.tagged
+                            width: parent.width
+                            spacing: Theme.spacing.tagPairGap
+                            Repeater {
+                                model: pair.tagged ? root.facts.tags : []
+                                Row {
+                                    id: tagItem
+                                    required property string modelData
+                                    spacing: Theme.spacing.tagNameGap
+                                    // A name Flea does not know is plain text with no swatch; a digit fallback keeps the 14 px square its digit needs.
+                                    Flea.TagSwatch {
+                                        size: Theme.tag.fallback ? Tags.SWATCH_SIZE : Tags.PAIR_SWATCH_SIZE
+                                        visible: Tags.NAMES.indexOf(tagItem.modelData) >= 0
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        swatch: tagItem.modelData
+                                        fallback: Theme.tag.fallback
+                                        digit: Tags.keyFor(tagItem.modelData)
+                                        tagColors: Theme.tag.menuColors
+                                    }
+                                    Text {
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        text: tagItem.modelData
+                                        textFormat: Text.PlainText
+                                        color: Theme.color.foreground
+                                        font { family: Theme.font.family; pixelSize: Theme.font.body }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                Text {
+                    width: parent.width
+                    visible: text.length > 0
+                    text: root.errorText || (root.busy ? "Working…" : "")
+                    textFormat: Text.PlainText
+                    wrapMode: Text.Wrap
+                    color: root.errorText ? Theme.color.errorOnSurface : Theme.color.muted
+                    font { family: Theme.font.family; pixelSize: Theme.font.caption }
+                }
+            }
+        }
+    }
+    // Match Trash's identity-check cadence only while the destructive strip is visible.
+    Timer { interval: 2500; repeat: true; running: confirmation.opened && !root.busy; onTriggered: root.checkDeletion() }
+    Flea.TrashConfirm {
+        id: confirmation
+        scopeName: "items"
+        onCancelled: root.close()
+        onConfirmed: function(token) {
+            root.busy = true
+            root.committing = true
+            root.opened = false
+            if (root.focusHolder) root.focusHolder.forceActiveFocus()
+            root.requested({c: "menuaction", op: "delete", id: root.requestId, token: token})
+        }
+    }
+}

package/ui/MenuEdgeFade.qml

@@ -0,0 +1,24 @@
+import QtQuick
+
+// One edge of a menu that scrolls, fading the surface out where more rows wait: the Menus board's "Edges fade to say so".
+Rectangle {
+    // The card's own padding between its border and its rows, which the fade crosses before it reaches a cut row.
+    property real inset: 0
+    // How far the fade reaches past that padding into the row the edge cuts.
+    property real reach: Theme.spacing.gap
+    // The frame Rectangle's border width: the fade lies inside it, so the hairline frame stays whole, corners included.
+    readonly property real frameBorder: parent.border.width
+    anchors.left: parent.left
+    anchors.right: parent.right
+    anchors.leftMargin: frameBorder
+    anchors.rightMargin: frameBorder
+    anchors.topMargin: frameBorder
+    anchors.bottomMargin: frameBorder
+    // Measured from the inner edge, so it still ends where the card's padding plus reach ends.
+    height: inset + reach - frameBorder
+    radius: Math.max(0, parent.radius - frameBorder)
+    gradient: Gradient {
+        GradientStop { position: 0; color: Theme.color.surface }
+        GradientStop { position: 1; color: Qt.rgba(Theme.color.surface.r, Theme.color.surface.g, Theme.color.surface.b, 0) }
+    }
+}

package/ui/MenuHost.qml

@@ -0,0 +1,227 @@
+import QtQuick
+import "." as Flea
+import "js/Menu.js" as Menu
+import "js/MenuContext.js" as MenuContext
+
+// Menu state and receivers stay live; the visual warms after the first frame and listing idle.
+Item {
+    id: root
+    required property var pane
+    anchors.fill: parent
+    visible: false
+    readonly property var item: visual.item
+    readonly property int status: visual.status
+    property bool syncing: false
+    property bool firstFrame: false
+    readonly property bool ready: root.item !== null && visual.status === Loader.Ready
+    readonly property bool settled: root.pane.listingState !== "loading" && !root.pane.listInFlight
+    readonly property real inputAt: root.pane.inputAt
+    onInputAtChanged: if (warm.running) warm.restart()
+
+    signal chosen(string action)
+    signal refused(string reason)
+    signal snapshotRequested()
+    signal railChosen(string action, string key)
+    signal lockedChosen(string action, string path)
+
+    property Item focusOwner: null
+    property bool showHidden: false
+    property bool providersRefreshing: false
+    property var taildropPeers: []
+    property bool rowIsFile: false
+    property bool taildropInstalled: false
+    property string taildropReason: ""
+    property string taildropCode: ""
+    property var archiveFormats: []
+    property bool canConvert: false
+    property bool canExtract: false
+    property string archiveName: ""
+    property int rowMode: 0
+    property int selectionCount: 0
+    property bool cursorIsTarget: false
+    property var openWithApps: []
+    property bool openWithLoaded: false
+    property var identitySource: null
+    property bool clipboardAvailable: false
+    property bool clipboardWatchFailed: false
+    property bool rowIsArchive: false
+    property bool rowIsImage: false
+    property string rowName: ""
+    property string flashZipMember: ""
+    property bool rowIsSymlink: false
+    property bool rowHasShebang: false
+    property var selectionModes: []
+    property var compareKinds: []
+    property bool dropboxInstalled: false
+    property var localSend: ({ installed: false, peers: [], checking: false })
+    property string dropboxPath: ""
+    property string dropboxReason: ""
+    property string dropboxCode: ""
+    property bool rowInDropbox: false
+    property bool canTrash: true
+    property bool dirWritable: true
+    property bool canLink: true
+    property var tagSubmenu: null
+    property string storageClass: ""
+    property bool hasFolderSort: false
+    property string tileTarget: ""
+    property int tileMode: 0
+    property rect workArea: Qt.rect(0, 0, root.width, root.height)
+    property bool opened: false
+    property bool preparing: false
+    property bool hasRow: true
+    property bool forHeader: false
+    property string openedIdentity: ""
+    property string lockedPath: ""
+    property int lockedMode: 0
+    property var railEntries: []
+    property string railKey: ""
+    property Item focusHolder: null
+    property int cursor: 0
+    property int openSubmenuRow: -1
+    property int submenuCursor: 0
+    property string loneFlyoutAction: ""
+    property var lastProviderAnswer: null
+
+    readonly property bool forRail: root.railEntries.length > 0
+    readonly property bool forLocked: root.lockedPath.length > 0
+    readonly property bool submenuOpen: root.openSubmenuRow >= 0 || root.loneFlyoutAction.length > 0
+    readonly property var entries: root.item ? root.item.entries : []
+    readonly property var submenuEntries: root.item ? root.item.submenuEntries : []
+    readonly property var frameItem: root.item ? root.item.frameItem : null
+    readonly property var submenuFrameItem: root.item ? root.item.submenuFrameItem : null
+    readonly property bool keyboardFocused: root.item ? root.item.keyboardFocused : false
+    readonly property var inputNames: [
+        "focusOwner", "showHidden", "providersRefreshing", "taildropPeers",
+        "rowIsFile", "taildropInstalled", "taildropReason", "taildropCode",
+        "archiveFormats", "canConvert", "canExtract", "archiveName",
+        "rowMode", "selectionCount", "cursorIsTarget", "openWithApps",
+        "openWithLoaded", "identitySource", "clipboardAvailable", "clipboardWatchFailed",
+        "rowIsArchive", "rowIsImage", "rowName", "flashZipMember",
+        "rowIsSymlink", "rowHasShebang", "selectionModes", "compareKinds", "dropboxInstalled",
+        "localSend", "dropboxPath", "dropboxReason", "dropboxCode",
+        "rowInDropbox", "canTrash", "dirWritable", "canLink",
+        "tagSubmenu", "storageClass", "hasFolderSort", "tileTarget",
+        "tileMode", "workArea"
+    ]
+    readonly property var stateNames: [
+        "opened", "preparing", "hasRow", "forHeader",
+        "openedIdentity", "lockedPath", "lockedMode", "railEntries",
+        "railKey", "focusHolder", "cursor", "openSubmenuRow",
+        "submenuCursor", "loneFlyoutAction", "lastProviderAnswer"
+    ]
+
+    function liveInput(name) { return Qt.binding(function () { return root[name] }) }
+    function copyState(name, from, to) {
+        if (root.syncing || !root.item) return
+        root.syncing = true
+        try { to[name] = from[name] } finally { root.syncing = false }
+    }
+    function watchState(name) {
+        root[name + "Changed"].connect(function () { root.copyState(name, root, root.item) })
+        root.item[name + "Changed"].connect(function () { root.copyState(name, root.item, root) })
+    }
+    function configure() {
+        if (String(visual.source).length > 0) return
+        var values = { parent: root.liveInput("parent") }
+        for (var i = 0; i < root.inputNames.length; i++) values[root.inputNames[i]] = root.liveInput(root.inputNames[i])
+        visual.setSource("ContextMenu.qml", values)
+    }
+    function loaded() {
+        for (var s = 0; s < root.stateNames.length; s++) root.item[root.stateNames[s]] = root[root.stateNames[s]]
+        for (var n = 0; n < root.stateNames.length; n++) root.watchState(root.stateNames[n])
+        root.item.chosen.connect(root.chosen)
+        root.item.refused.connect(root.refused)
+        root.item.snapshotRequested.connect(root.snapshotRequested)
+        root.item.railChosen.connect(root.railChosen)
+        root.item.lockedChosen.connect(root.lockedChosen)
+    }
+    function prewarm() {
+        if (visual.active) return
+        root.configure()
+        visual.active = true
+    }
+    function ensure() {
+        if (root.item) return root.item
+        warm.stop()
+        // Cancelling first preserves inputs from birth when Qt restarts unfinished compilation.
+        visual.active = false
+        visual.source = ""
+        visual.asynchronous = false
+        root.configure()
+        visual.active = true
+        if (!root.item) throw new Error("ContextMenu.qml did not load: Loader status " + visual.status)
+        return root.item
+    }
+
+    Loader {
+        id: visual
+        active: false
+        asynchronous: true
+        onLoaded: root.loaded()
+        onStatusChanged: if (status === Loader.Error) throw new Error("ContextMenu.qml did not load: Loader status " + status)
+    }
+
+    // Match Quick Look's one-second idle hold, after both the first swap and listing readiness.
+    Timer {
+        id: warm
+        interval: 1000
+        running: root.firstFrame && root.settled && !visual.active
+        onTriggered: root.prewarm()
+    }
+    Connections {
+        target: root.firstFrame ? null : root.Window.window
+        function onFrameSwapped() { root.firstFrame = true }
+    }
+
+    function selectionIdentity() { return root.identitySource ? root.identitySource.menuSelectionIdentity() : "" }
+    function listingContext(flyoutAction, includeHidden) {
+        if (root.item) return root.item.listingContext(flyoutAction, includeHidden)
+        return MenuContext.listingContext(root, flyoutAction, includeHidden, {
+            scripts: Flea.Scripts.entries, hiddenActions: ViewState.menuHidden,
+            langMarks: ViewState.langMarks,
+            thumbPreview: ViewState.preview, updateVersion: UpdateCheck.menuVersion
+        })
+    }
+    function buildEntries(flyoutAction, includeHidden) {
+        if (root.item) return root.item.buildEntries(flyoutAction, includeHidden)
+        if (root.forRail) return root.railEntries
+        if (root.forHeader) return Menu.headerEntries(ViewState.hiddenCols, root.showHidden)
+        return Menu.listingEntries(root.listingContext(flyoutAction, includeHidden))
+    }
+    function validateChoice(action, subId, includeHidden) {
+        if (root.item) return root.item.validateChoice(action, subId, includeHidden)
+        return MenuContext.validateChoice(root, action, subId, includeHidden)
+    }
+    function refuseLone(kind) {
+        root.close()
+        root.refused(kind === "moved" ? "Selected items changed; reopen the menu."
+                                     : "That action is no longer available; reopen the menu.")
+    }
+    function providersSettled() {
+        if (root.item) root.item.providersSettled()
+        else root.lastProviderAnswer = MenuContext.settle(MenuContext.live(root))
+    }
+    function refreshProviderRows() { if (root.item) root.item.refreshProviderRows() }
+    function close() {
+        if (root.item) root.item.close()
+        else root.opened = false
+    }
+    function clearRail() {
+        if (root.item) root.item.clearRail()
+        else { root.railEntries = []; root.railKey = ""; root.lockedPath = ""; root.lockedMode = 0 }
+    }
+    function openAt(point) { root.ensure().openAt(point) }
+    function openBackground(point) { root.ensure().openBackground(point) }
+    function openLocked(path, mode, point) { root.ensure().openLocked(path, mode, point) }
+    function openForHeader(point) { root.ensure().openForHeader(point) }
+    function openForRail(key, rows, point) { if (rows && rows.length) root.ensure().openForRail(key, rows, point) }
+    function openSubmenu(index) { if (root.item) root.item.openSubmenu(index) }
+    function openSubmenuFor(action) { return root.ensure().openSubmenuFor(action) }
+    function choose(action) { if (root.item) root.item.choose(action) }
+    function chooseSub(id) { if (root.item) root.item.chooseSub(id) }
+    function setEntries(rows, flyoutRow) { root.ensure().setEntries(rows, flyoutRow) }
+    function itemFor(index) { return root.item ? root.item.itemFor(index) : null }
+    function submenuItemFor(index) { return root.item ? root.item.submenuItemFor(index) : null }
+    function submenuGlyphs() { return root.item ? root.item.submenuGlyphs() : "" }
+}