flea-qml 0.0.0-stage → 0.1.0

package/ui/CodeLines.qml

@@ -0,0 +1,256 @@
+import QtQuick
+import qs.Commons
+import "js/CodeRuns.js" as CodeRuns
+
+// The lines of one file or text, coloured by the backend's code engine, asked a screen-and-margin at a time; a network file's `text` is the caller's.
+Item {
+    id: root
+
+    property var backend: null
+    // The backend's name for this view's job; a newer ask on it ends the older one.
+    property string slot: "column"
+    property string path: ""
+    // true sends the bytes in `text` (null until the caller has read them) instead of the path.
+    property bool fromText: false
+    property var text: null
+    property bool active: false
+    property bool numbered: false
+    property bool wrap: false
+    // Enables wheel and drag scrolling in the line viewport.
+    property bool scrolls: false
+    // Grow from measured delegates only; never scan the entire file to size a lane.
+    property real widestLine: 0
+    function measureLine(width) {
+        if (!root.wrap && isFinite(width) && width > root.widestLine) root.widestLine = width
+    }
+    readonly property alias viewport: view
+    // A Component the list draws above its first line and scrolls with the rows; null for none.
+    property Component header: null
+    property real pixelSize: Theme.font.caption
+    // The most lines drawn, 0 for every line of the file.
+    property int limit: 0
+    // Screens asked past the view on each side.
+    property int margin: 1
+    readonly property int lineCap: 400 // The most lines one ask names (docs/protocol.md "code"); a longer window is asked in parts.
+
+    // A backend that cannot ask (a bare stub) leaves the caller's own text to be drawn plain.
+    readonly property bool engine: root.backend !== null && typeof root.backend.askCode === "function"
+    // "" until the lines in view are answered, then styled, plain, binary, large or failed.
+    property string answer: ""
+    property int total: 0
+    // The lines held, by 1-based number, read through rowAt; stamp counts changes to it.
+    property var held: ({})
+    property int stamp: 0
+    // The token of the ask in flight, 0 when none: an answer for any other token is dropped.
+    property int token: 0
+    property bool retiring: false
+    // The window of that ask, so the same window is not asked for twice while it is in flight.
+    property var asking: null
+    readonly property bool settled: root.answer === "styled" || root.answer === "plain"
+    readonly property int shown: root.limit > 0 ? Math.min(root.total, root.limit) : root.total
+    // True when the lines in view are all held.
+    readonly property bool firstScreen: root.settled && root.covered(root.needed().from, root.needed().to)
+    // The plain text of the lines drawn, for the readers that check what is on screen.
+    readonly property var lines: {
+        var out = []
+        for (var i = 1; i <= root.shown; i++)
+            out.push(root.rowAt(i) ? CodeRuns.plain(root.rowAt(i)) : "")
+        return out
+    }
+    // Indexed by the code reply's role: the foreground, then red, green, yellow, blue, magenta and cyan.
+    readonly property var inks: CodeRuns.inks(Theme.palette, Theme.fallbackColor, String(Theme.color.foreground))
+    readonly property real rowHeight: metrics.height
+    // The gutter is as wide as the widest number it can show, so the text never shifts as it scrolls.
+    readonly property real gutterWidth: (Math.max(2, String(root.shown).length) + 1) * metrics.advanceWidth
+
+    // The runs of line n, undefined until the backend has answered for it; reading it through the stamp makes a binding follow every answer.
+    function rowAt(n) {
+        return root.stamp >= 0 ? root.held[n] : undefined
+    }
+
+    function reset() {
+        root.widestLine = 0
+        view.contentX = 0
+        view.contentY = 0
+        root.held = {}
+        root.stamp += 1
+        root.total = 0
+        root.answer = ""
+        root.token = 0
+        root.asking = null
+    }
+
+    // Starts a view of a new file or text; the first ask waits for the end of the turn so one change of several properties asks once.
+    function fresh() {
+        root.reset()
+        if (!root.active) {
+            askTimer.stop()
+            return
+        }
+        if (!root.engine && root.fromText && root.text !== null)
+            root.answerPlain()
+        else
+            root.schedule()
+    }
+
+    // The owned timer coalesces asks and is destroyed with the reader, including a pending ask during a preview handoff.
+    function schedule() {
+        if (root.active)
+            askTimer.restart()
+    }
+
+    // Sample input: "a\nb\n" holds only lines 1 and 2, as [0, "a"] and [0, "b"], matching the engine's terminal-newline rule.
+    function answerPlain() {
+        var rows = root.text.length > 0 ? root.text.split("\n") : []
+        if (rows.length > 0 && root.text.endsWith("\n"))
+            rows.pop()
+        var held = {}
+        for (var i = 0; i < rows.length && (root.limit <= 0 || i < root.limit); i++)
+            held[i + 1] = [0, rows[i].endsWith("\r") ? rows[i].slice(0, -1) : rows[i]]
+        root.held = held
+        root.stamp += 1
+        root.total = rows.length
+        root.answer = "plain"
+    }
+
+    // The lines the view needs held: those in it plus the margin, never past the file or the limit.
+    function needed() {
+        var rows = Math.max(1, Math.ceil(view.height / Math.max(1, root.rowHeight)))
+        var top = view.contentHeight > 0 ? Math.max(0, view.indexAt(0, view.contentY + 1)) + 1 : 1
+        var to = top + rows * (1 + root.margin) - 1
+        if (root.limit > 0)
+            to = Math.min(to, root.limit)
+        if (root.settled)
+            to = Math.min(to, root.total)
+        return { from: Math.max(1, top - rows * root.margin), to: to }
+    }
+
+    function covered(from, to) {
+        for (var i = from; i <= to; i++)
+            if (!root.rowAt(i))
+                return false
+        return true
+    }
+
+    function ask() {
+        if (root.retiring || !root.active || !root.engine || view.height <= 0)
+            return
+        if (root.answer === "binary" || root.answer === "large" || root.answer === "failed")
+            return
+        if (root.fromText && root.text === null)
+            return
+        if (root.fromText && root.text.length === 0) {
+            root.answerPlain()
+            return
+        }
+        if (!root.fromText && root.path.length === 0)
+            return
+        var want = root.needed()
+        if (want.to < want.from || (root.settled && root.covered(want.from, want.to)))
+            return
+        if (root.token !== 0 && root.asking.from === want.from && root.asking.to === want.to)
+            return
+        root.asking = want
+        var from = want.from
+        while (from < want.to && root.rowAt(from)) from++
+        var source = root.fromText ? { text: root.text, name: root.path.split("/").pop(), lang: "" } : { path: root.path }
+        root.token = root.backend.askCode(root.slot, source, from, Math.min(root.lineCap, want.to - from + 1))
+    }
+
+    function answered(message) {
+        if (root.token === 0 || message.token !== root.token)
+            return
+        root.token = 0
+        root.answer = message.state
+        root.total = message.total || 0
+        var rows = message.lines || []
+        for (var i = 0; i < rows.length; i++)
+            root.held[message.first + i] = rows[i]
+        root.stamp += 1
+        // Binary, large and failed are the file's whole answer: nothing more is asked of it until the view starts a new one.
+        if (root.settled)
+            root.schedule()
+    }
+
+    // A pane handoff keeps the engine capability, but disconnects the old backend's request.
+    function rebind() {
+        root.fresh()
+    }
+
+    onBackendChanged: root.rebind()
+    onPathChanged: root.fresh()
+    onTextChanged: root.fresh()
+    onFromTextChanged: root.fresh()
+    onActiveChanged: root.fresh()
+    Component.onDestruction: root.retiring = true
+    onEngineChanged: root.fresh()
+    onLimitChanged: root.schedule()
+    onWrapChanged: { view.contentX = 0; root.schedule() }
+
+    Timer { id: askTimer; interval: 0; onTriggered: root.ask() }
+
+    Connections {
+        target: root.engine ? root.backend : null
+        function onCodeResult(message) { root.answered(message) }
+    }
+
+    TextMetrics {
+        id: metrics
+        font.family: Theme.font.family
+        font.pixelSize: root.pixelSize
+        text: "0"
+    }
+
+    ListView {
+        id: view
+        anchors.fill: parent
+        clip: true
+        interactive: root.scrolls
+        flickableDirection: root.wrap ? Flickable.VerticalFlick : Flickable.HorizontalAndVerticalFlick
+        contentWidth: root.wrap ? width : Math.max(width, root.widestLine + (root.numbered ? root.gutterWidth : 0))
+        cacheBuffer: 0
+        boundsBehavior: Flickable.StopAtBounds
+        model: root.shown
+        header: root.header
+        onContentYChanged: root.schedule()
+        onHeightChanged: root.schedule()
+
+        delegate: Item {
+            id: line
+            required property int index
+            readonly property var runs: root.rowAt(line.index + 1)
+            width: view.contentWidth
+            height: Math.max(body.implicitHeight, root.rowHeight)
+
+            Text {
+                visible: root.numbered
+                width: root.gutterWidth
+                text: String(line.index + 1)
+                horizontalAlignment: Text.AlignRight
+                color: Theme.color.muted
+                opacity: 0.6
+                font.family: Theme.font.family
+                font.pixelSize: Theme.font.caption
+                textFormat: Text.PlainText
+            }
+
+            // corner: file contents are arbitrary text, so every run is escaped and the string holds only the font tags written here.
+            Text {
+                id: body
+                x: root.numbered ? root.gutterWidth : 0
+                width: line.width - x
+                leftPadding: 2 * metrics.advanceWidth
+                text: line.runs ? CodeRuns.styled(line.runs, root.inks) : ""
+                color: Theme.color.foreground
+                font.family: Theme.font.family
+                font.pixelSize: root.pixelSize
+                textFormat: Text.StyledText
+                wrapMode: root.wrap ? Text.WrapAtWordBoundaryOrAnywhere : Text.NoWrap
+                // Keep the complete line; the viewport clips and pans it instead of eliding.
+                elide: Text.ElideNone
+                onImplicitWidthChanged: root.measureLine(implicitWidth)
+                Component.onCompleted: root.measureLine(implicitWidth)
+            }
+        }
+    }
+}

package/ui/CodeRefusal.qml

@@ -0,0 +1,52 @@
+import QtQuick
+import "." as Flea
+
+// The code preview's refusal frame, shared by Quick Look's text pane and Markdown Source.
+Item {
+    id: root
+
+    property bool binary: false
+    property bool tooLarge: false
+    property bool failed: false
+    property string markName: "file"
+    // Quick Look places the frame below its bar; Source's host has already set that inset.
+    property int topInset: 0
+    readonly property string status: root.tooLarge ? "This file is too large to preview." : root.failed ? "This file could not be read." : "ready"
+
+    Column {
+        anchors.horizontalCenter: parent.horizontalCenter
+        y: root.topInset + Math.round((parent.height - root.topInset - height) / 2)
+        spacing: Theme.spacing.gap
+        visible: root.binary || (root.tooLarge && !root.failed)
+
+        Flea.Glyph {
+            anchors.horizontalCenter: parent.horizontalCenter
+            maxSize: Theme.stateMarkSize
+            width: Theme.stateMarkSize
+            height: Theme.stateMarkSize
+            name: root.markName
+            color: Theme.color.muted
+            opacity: 0.7
+        }
+
+        Text {
+            anchors.horizontalCenter: parent.horizontalCenter
+            text: root.binary ? "binary file" : "too large to preview"
+            color: Theme.color.muted
+            font.family: Theme.font.family
+            font.pixelSize: Theme.font.caption
+            textFormat: Text.PlainText
+        }
+    }
+
+    Text {
+        anchors.horizontalCenter: parent.horizontalCenter
+        y: root.topInset + Math.round((parent.height - root.topInset - height) / 2)
+        visible: false // A failed preview remains blank.
+        text: root.status
+        color: Theme.color.muted
+        font.family: Theme.font.family
+        font.pixelSize: Theme.font.body
+        textFormat: Text.PlainText
+    }
+}

package/ui/CollideConfirm.qml

@@ -0,0 +1,147 @@
+import QtQuick
+import qs.Commons
+import "." as Flea
+import "js/Collide.js" as Collide
+import "js/Icons.js" as Icons
+
+// One choice for every name a paste or a drop would land on, on ui/TrashConfirm.qml's card, keys and look.
+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 string titleText: ""
+    property var names: []
+    property string moreText: ""
+    property string focusName: Collide.START
+    // Merge is present only when a folder lands on a folder; the second card never offers it.
+    property bool showMerge: false
+    readonly property string explainText: Collide.EXPLAIN
+    readonly property real referenceScale: Collide.cardReferenceScale(Theme.font.bodySmall)
+    readonly property real cardPadding: Collide.cardPadding(referenceScale)
+    readonly property real cardBottomPadding: Math.round(12 * referenceScale)
+    // MergeFolders: the buttons keep 6 px of air over the gap.
+    readonly property real buttonsAir: Math.round(6 * referenceScale)
+    // The card grows with the labels rather than wrapping one, and Keep both stays the default with the ring.
+    readonly property real contentWidth: Collide.cardContentWidth(referenceScale, Theme.dialogWidthRatio, buttons.implicitWidth)
+    signal chosen(string choice)
+    readonly property var cardItem: card
+    readonly property bool titleTruncated: title.truncated
+    readonly property bool buttonsFit: buttons.width <= body.holderWidth
+    readonly property int explainLines: explain.lineCount
+    function buttonItem(name) { return ({cancel: cancelButton, skip: skipButton, keep: keepButton, merge: mergeButton, replace: replaceButton})[name] || null }
+    function open(heading, list, more, merge) {
+        titleText = heading
+        names = list
+        moreText = more
+        showMerge = merge === true
+        // A hidden Merge never holds the ring: the card opens on Keep both either way.
+        focusName = Collide.START
+        body.contentY = 0
+        opened = true
+        forceActiveFocus()
+    }
+    function choose(choice) {
+        opened = false
+        chosen(choice)
+    }
+    Flea.Reveal { target: root; shown: root.opened; lift: card }
+    // A press lands on its own button first, so the accent never shows one choice while another is taken.
+    function press(choice) {
+        focusName = choice
+        choose(choice)
+    }
+    Keys.onPressed: function(event) {
+        if (event.key === Qt.Key_Escape) root.choose("cancel")
+        else if (event.modifiers & (Qt.ControlModifier | Qt.AltModifier | Qt.MetaModifier)) { event.accepted = true; return }
+        else if (Collide.activates(event.key)) root.choose(root.focusName)
+        else root.focusName = Collide.moved(root.focusName, event.key, root.showMerge, event.modifiers)
+        if (root.opened) body.reveal(root.buttonItem(root.focusName))
+        event.accepted = true
+    }
+    Flea.DialogScrim {
+        onDismissed: root.choose("cancel")
+    }
+    Rectangle {
+        id: card
+        x: Theme.cardOrigin(root.width, width)
+        y: Theme.cardOrigin(root.height, height)
+        width: Theme.cardSpan(root.contentWidth + 2 * root.cardPadding + 2 * Theme.spacing.hairline, root.width - 2 * Theme.spacing.gap)
+        height: Theme.cardSpan(body.wanted + root.cardPadding + root.cardBottomPadding + 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.cardBottomPadding + Theme.spacing.hairline - Theme.focusClearance
+            title: Flea.DialogHeader {
+                id: title
+                width: parent.width
+                text: root.titleText
+            }
+            buttons: Row {
+                id: buttons
+                anchors.right: parent.right
+                topPadding: root.buttonsAir
+                spacing: Theme.spacing.gap
+                Flea.DialogButton { id: cancelButton; label: Collide.LABELS.cancel; focused: root.focusName === "cancel"; onActivated: root.press("cancel") }
+                Flea.DialogButton { id: skipButton; label: Collide.LABELS.skip; focused: root.focusName === "skip"; onActivated: root.press("skip") }
+                Flea.DialogButton { id: keepButton; label: Collide.LABELS.keep; primary: true; focused: root.focusName === "keep"; onActivated: root.press("keep") }
+                Flea.DialogButton { id: mergeButton; visible: root.showMerge; label: Collide.LABELS.merge; focused: root.focusName === "merge"; onActivated: root.press("merge") }
+                Flea.DialogButton { id: replaceButton; label: Collide.LABELS.replace; destructive: true; focused: root.focusName === "replace"; onActivated: root.press("replace") }
+            }
+            Column {
+                width: parent.width
+                spacing: Theme.spacing.gap
+                Column {
+                    width: parent.width
+                    Repeater {
+                        model: root.names
+                        delegate: Row {
+                            id: nameRow
+                            required property var modelData
+                            width: parent.width
+                            height: Theme.fileRowHeight
+                            spacing: Theme.spacing.gap
+                            Flea.Glyph { width: Theme.markSize; height: parent.height; name: nameRow.modelData.d ? "folder" : Icons.glyphFor(nameRow.modelData.i); color: Theme.color.foreground }
+                            Text { width: Math.max(0, parent.width - Theme.markSize - parent.spacing); anchors.verticalCenter: parent.verticalCenter; text: nameRow.modelData.n; textFormat: Text.PlainText; elide: Text.ElideRight; color: Theme.color.foreground; font { family: Theme.font.family; pixelSize: Theme.font.body } }
+                        }
+                    }
+                    Text {
+                        width: parent.width
+                        visible: root.moreText.length > 0
+                        text: root.moreText
+                        textFormat: Text.PlainText
+                        elide: Text.ElideRight
+                        color: Theme.color.foreground
+                        font { family: Theme.font.family; pixelSize: Theme.font.caption }
+                    }
+                }
+                Text {
+                    id: explain
+                    width: parent.width
+                    text: root.explainText
+                    textFormat: Text.PlainText
+                    wrapMode: Text.Wrap
+                    color: Theme.color.foreground
+                    font { family: Theme.font.family; pixelSize: Theme.font.caption }
+                }
+            }
+        }
+    }
+}

package/ui/CollideHost.qml

@@ -0,0 +1,167 @@
+import QtQuick
+import "js/Clipboard.js" as Clipboard
+import "js/Collide.js" as Collide
+
+// A pane's question before a transfer lands on names that exist: the transfer waits here, so Cancel sends nothing.
+Loader {
+    id: root
+    required property var pane
+    anchors.fill: parent
+    z: 2
+    // Built by the first question that collides, see AGENTS.md rule 6: a hidden card is not a free one.
+    active: false
+    source: "CollideConfirm.qml"
+    readonly property bool opened: item !== null && item.opened
+    // The transfer waiting on the answer, or null, and whether sending it spends a cut clipboard.
+    property var pending: null
+    property bool spendsCut: false
+    property var cutClipboard: null
+    property int askId: 0
+    // A merge holds its transfer across two cards: the walk's answer lands on the second.
+    property bool merging: false
+    property var outerNames: []
+    // How many names the first card counted, of which outerNames shows at most three.
+    property int outerTotal: 0
+    property var probe: null
+    // Built by the first FAT answer, with no placeholder: a Loader here would stand at startup for a card most windows never open.
+    property var fatCard: null
+
+    // A cut is spent when its transfer goes out, so a Cancel leaves it on the clipboard to paste elsewhere.
+    function ask(request, probe, cut) {
+        var refused = Collide.refusal(root.opened, root.pending)
+        if (refused.length > 0) {
+            root.pane.message(refused, false)
+            return false
+        }
+        root.askId += 1
+        // Its rows keep the numbering they were read in, so a listing landing before the answer gets the transfer refused, not resolved anew.
+        root.pending = Collide.waiting(request, root.pane.backend.heldListing)
+        root.spendsCut = cut === true
+        root.cutClipboard = cut === true ? root.pane.clipboard : null
+        root.merging = false
+        root.outerNames = []
+        root.probe = probe || null
+        root.pane.backend.send(Collide.question(root.pending, probe, root.askId))
+        return true
+    }
+
+    // A merge's terminal line; only a merge this card asked carries into, so every other line is the pane's own.
+    function doneLine(transfer, result) {
+        return Collide.doneLine(transfer, result)
+    }
+
+    // Nothing collided: the transfer goes out as it would have, carrying the refusal for any late name.
+    function answered(id, total, names, mergeable) {
+        if (id !== root.askId || root.pending === null)
+            return
+        if (total === 0) {
+            root.decide(Collide.NONE)
+            return
+        }
+        root.outerNames = names
+        root.outerTotal = total
+        root.active = true
+        // Paste as links never merges: the Merge card is the transfer's own second card.
+        root.item.open(Collide.title(names, total, root.pending.dest), names, Collide.more(total, names.length),
+                       mergeable === true && root.pending.c !== "link")
+    }
+
+    // The destination cannot hold some names: Rename and copy or Skip them rides the question again, before any collision is asked.
+    function answeredFat(id, renames, fstype, volume) {
+        if (id !== root.askId || root.pending === null)
+            return
+        if (root.fatCard === null) {
+            root.fatCard = Qt.createComponent("FatNamesConfirm.qml").createObject(root.parent, { z: root.z })
+            root.fatCard.chosen.connect(root.decideFat)
+        }
+        root.fatCard.open(Collide.cardTitle(renames.length, volume, fstype), renames, Collide.cardNote(fstype))
+    }
+
+    function decideFat(choice) {
+        if (choice === "cancel" || root.pending === null) {
+            root.decide("cancel")
+        } else {
+            root.pending.fat = choice
+            root.pane.backend.send(Collide.question(root.pending, root.probe, root.askId))
+        }
+        root.pane.listArea.forceActiveFocus()
+    }
+
+    // The second card: what files inside the merging folders already exist, asked by one walk before anything is written.
+    function answeredMerge(id, total, names) {
+        if (id !== root.askId || root.pending === null || !root.merging)
+            return
+        if (total === 0) {
+            root.decideMerge("refuse")
+            return
+        }
+        var into = Collide.mergeDest(root.pending, root.outerNames, root.outerTotal)
+        root.item.open(Collide.title(names, total, into), names, Collide.more(total, names.length), false)
+    }
+
+    // Merge leaves the first card for the walk: the transfer waits on the second answer, not this one.
+    function decide(choice) {
+        if (choice === "merge") {
+            root.merging = true
+            root.pane.backend.send(Collide.mergeQuestion(root.pending, root.probe, root.askId))
+            return
+        }
+        var request = root.pending
+        if (request && choice !== "cancel") {
+            // MenuAdditions040: Paste as links asks through this same card.
+            root.pane.backend.send(request.c === "link" ? Collide.link(request, choice, root.askId)
+                                                        : Collide.transfer(request, choice, root.askId))
+            Clipboard.spent(root.pane, root.cutClipboard, root.spendsCut)
+        }
+        root.pending = null
+        root.cutClipboard = null
+        root.merging = false
+        root.outerNames = []
+        root.probe = null
+    }
+
+    // The second card's answer rides the merge transfer; Cancel sends nothing and keeps the cut.
+    function decideMerge(choice) {
+        var request = root.pending
+        if (request && choice !== "cancel") {
+            root.pane.backend.send(Collide.mergeTransfer(request, choice, root.askId))
+            Clipboard.spent(root.pane, root.cutClipboard, root.spendsCut)
+        }
+        root.pending = null
+        root.cutClipboard = null
+        root.merging = false
+        root.outerNames = []
+        root.probe = null
+    }
+
+    Connections {
+        target: root.pane.backend
+        function onCollisions(id, total, names, mergeable) { root.answered(id, total, names, mergeable) }
+        function onMergeCollisions(id, total, names) { root.answeredMerge(id, total, names) }
+        function onFatnames(id, renames, fstype, volume) { root.answeredFat(id, renames, fstype, volume) }
+        // A dead backend or a refused question ends the wait here and closes the card.
+        function onFailed(where, input) {
+            if (where === "backend" || Collide.droppedPending(where, input)) {
+                root.pending = null
+                root.cutClipboard = null
+                root.merging = false
+                root.outerNames = []
+                root.probe = null
+                if (root.item)
+                    root.item.opened = false
+                if (root.fatCard !== null)
+                    root.fatCard.opened = false
+            }
+        }
+    }
+    Connections {
+        target: root.item
+        function onChosen(choice) {
+            if (root.merging)
+                root.decideMerge(choice)
+            else
+                root.decide(choice)
+            root.pane.listArea.forceActiveFocus()
+        }
+    }
+}