plasma-virtual-desktop-switcher/contents/ui/main.qml

import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQuick.Controls 2.15
import org.kde.plasma.plasmoid 2.0
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 3.0 as PlasmaComponents
import org.kde.plasma.private.pager 2.0
import "DesktopLogic.js" as Logic

Item {
    id: root
    Plasmoid.preferredRepresentation: Plasmoid.compactRepresentation

    readonly property bool showPreviews: plasmoid.configuration.showWindowPreviews
    readonly property bool showIcons: plasmoid.configuration.showWindowIcons
    property int previewSize: plasmoid.configuration.previewSize || 130

    property bool hoverCompact: false
    property bool hoverPopup: false

    Timer { id: openTimer; interval: 80; onTriggered: plasmoid.expanded = true }
    Timer { id: closeTimer; interval: 400; onTriggered: if (!hoverCompact && !hoverPopup) plasmoid.expanded = false }

    PagerModel {
        id: pagerModel
        enabled: true
        showDesktop: false
        pagerType: PagerModel.VirtualDesktops
    }

    // Store desktop IDs fetched from D-Bus
    property var desktopIds: ({})

    PlasmaCore.DataSource {
        id: executable
        engine: "executable"
        onNewData: {
            var stdout = data["stdout"] || ""
            // Parse desktop IDs from qdbus output
            if (sourceName.indexOf("desktops") > -1) {
                parseDesktopIds(stdout)
            }
            disconnectSource(sourceName)
        }

        Component.onCompleted: refreshDesktopIds()
    }

    function refreshDesktopIds() {
        executable.connectSource("qdbus --literal org.kde.KWin /VirtualDesktopManager org.kde.KWin.VirtualDesktopManager.desktops")
    }

    function parseDesktopIds(output) {
        // Parse: [Argument: (uss) 0, "uuid", "name"], ...
        var regex = /\[Argument: \(uss\) (\d+), "([^"]+)", "([^"]+)"\]/g
        var match
        var ids = {}
        while ((match = regex.exec(output)) !== null) {
            var idx = parseInt(match[1])
            ids[idx] = match[2]
        }
        desktopIds = ids
    }

    // Refresh IDs when desktop count changes
    Connections {
        target: pagerModel
        function onCountChanged() {
            refreshDesktopIds()
        }
    }

    function run(cmd) {
        if (cmd) {
            executable.connectSource(cmd)
        }
    }

    function getDesktopId(index) {
        if (index < 0 || index >= pagerModel.count) return ""
        return desktopIds[index] || ""
    }

    function getDesktopName(index) {
        return pagerModel.data(pagerModel.index(index, 0), Qt.DisplayRole) || ("Desktop " + (index + 1))
    }

    function currentDesktopName() {
        if (pagerModel.count > 0 && pagerModel.currentPage >= 0)
            return getDesktopName(pagerModel.currentPage)
        return "Desktop"
    }

    Plasmoid.compactRepresentation: MouseArea {
        Layout.minimumWidth: compactLabel.implicitWidth + 16
        hoverEnabled: true

        Rectangle {
            anchors.fill: parent
            color: parent.containsMouse ? PlasmaCore.Theme.highlightColor : "transparent"
            opacity: 0.2; radius: 3
        }

        PlasmaComponents.Label {
            id: compactLabel
            anchors.centerIn: parent
            text: currentDesktopName()
            font.bold: true
        }

        onEntered: { hoverCompact = true; closeTimer.stop(); openTimer.start() }
        onExited: { hoverCompact = false; openTimer.stop(); if (!hoverPopup) closeTimer.start() }
        onClicked: { openTimer.stop(); closeTimer.stop(); plasmoid.expanded = !plasmoid.expanded }
        onWheel: function(wheel) {
            pagerModel.changePage(Logic.nextDesktop(pagerModel.currentPage, pagerModel.count, wheel.angleDelta.y > 0 ? -1 : 1))
        }
    }

    Plasmoid.fullRepresentation: Item {
        id: popup

        readonly property var gridDims: Logic.calculateGrid(pagerModel.count)
        readonly property real deskW: previewSize
        readonly property real deskH: Logic.calculatePreviewHeight(previewSize, pagerModel.pagerItemSize.width, pagerModel.pagerItemSize.height)
        readonly property real scaleX: deskW / Math.max(1, pagerModel.pagerItemSize.width)
        readonly property real scaleY: deskH / Math.max(1, pagerModel.pagerItemSize.height)

        Layout.preferredWidth: gridDims.cols * (deskW + 8) + 32
        Layout.preferredHeight: gridDims.rows * (deskH + 8) + 70
        Layout.minimumWidth: 200
        Layout.minimumHeight: 120

        property int dragSource: -1
        property int dropTarget: -1

        Timer {
            id: refreshTimer
            interval: 300
            onTriggered: pagerModel.refresh()
        }

        PlasmaComponents.Menu {
            id: contextMenu
            property int desktopIndex: -1
            property string desktopName: ""
            property string desktopId: ""

            PlasmaComponents.MenuItem {
                text: "Switch to"
                icon.name: "go-jump"
                onClicked: {
                    pagerModel.changePage(contextMenu.desktopIndex)
                    plasmoid.expanded = false
                }
            }
            PlasmaComponents.MenuItem {
                text: "Rename..."
                icon.name: "edit-rename"
                onClicked: {
                    renameDialog.desktopId = contextMenu.desktopId
                    renameDialog.desktopName = contextMenu.desktopName
                    renameDialog.open()
                }
            }
            PlasmaComponents.MenuSeparator {}
            PlasmaComponents.MenuItem {
                text: "Delete"
                icon.name: "edit-delete"
                enabled: pagerModel.count > 1
                onClicked: run(Logic.buildRemoveCommand(contextMenu.desktopId))
            }
            PlasmaComponents.MenuSeparator {}
            PlasmaComponents.MenuItem {
                text: "New Desktop"
                icon.name: "list-add"
                onClicked: run(Logic.buildCreateCommand(pagerModel.count, "Desktop " + (pagerModel.count + 1)))
            }
        }

        Dialog {
            id: renameDialog
            title: "Rename Desktop"
            anchors.centerIn: parent
            modal: true
            standardButtons: Dialog.Ok | Dialog.Cancel

            property string desktopId: ""
            property string desktopName: ""

            onOpened: {
                renameField.text = desktopName
                renameField.selectAll()
                renameField.forceActiveFocus()
            }

            onAccepted: {
                if (renameField.text.trim()) {
                    run(Logic.buildRenameCommand(desktopId, renameField.text.trim()))
                    refreshTimer.start()
                }
            }

            contentItem: ColumnLayout {
                spacing: 10
                PlasmaComponents.Label {
                    text: "Enter new name:"
                }
                PlasmaComponents.TextField {
                    id: renameField
                    Layout.fillWidth: true
                    Layout.preferredWidth: 250
                    onAccepted: renameDialog.accept()
                }
            }
        }

        // Track hover state for entire popup
        HoverHandler {
            id: popupHover
            onHoveredChanged: {
                if (hovered) {
                    hoverPopup = true
                    closeTimer.stop()
                } else {
                    hoverPopup = false
                    if (!hoverCompact) closeTimer.start()
                }
            }
        }

        // Cleanup drag on release anywhere
        TapHandler {
            acceptedButtons: Qt.LeftButton
            onCanceled: { popup.dragSource = -1; popup.dropTarget = -1 }
        }

        ColumnLayout {
            anchors.fill: parent
            anchors.margins: 10
            spacing: 8

            Grid {
                id: grid
                Layout.fillWidth: true
                Layout.fillHeight: true
                Layout.alignment: Qt.AlignHCenter
                columns: popup.gridDims.cols
                spacing: 6

                Repeater {
                    id: repeater
                    model: pagerModel

                    Rectangle {
                        id: desktopItem
                        width: popup.deskW
                        height: popup.deskH
                        color: index === pagerModel.currentPage
                            ? Qt.darker(PlasmaCore.Theme.highlightColor, 1.3)
                            : PlasmaCore.Theme.backgroundColor
                        border.width: popup.dropTarget === index && popup.dragSource !== index ? 3 : (index === pagerModel.currentPage ? 2 : 1)
                        border.color: popup.dropTarget === index && popup.dragSource !== index
                            ? "#3498db"
                            : (index === pagerModel.currentPage ? PlasmaCore.Theme.highlightColor : PlasmaCore.Theme.disabledTextColor)
                        radius: 4
                        clip: true
                        opacity: popup.dragSource === index ? 0.5 : (desktopMA.containsMouse || deleteMA.containsMouse ? 1 : 0.92)

                        property string desktopName: model.display || ("Desktop " + (index + 1))
                        property bool isHovered: desktopMA.containsMouse || deleteMA.containsMouse

                        // Windows
                        Item {
                            anchors.fill: parent
                            anchors.margins: 2
                            clip: true
                            visible: showPreviews

                            Repeater {
                                model: TasksModel
                                Rectangle {
                                    property rect geo: model.Geometry
                                    x: Math.round(geo.x * popup.scaleX)
                                    y: Math.round(geo.y * popup.scaleY)
                                    width: Math.max(8, Math.round(geo.width * popup.scaleX))
                                    height: Math.max(6, Math.round(geo.height * popup.scaleY))
                                    visible: model.IsMinimized !== true
                                    color: model.IsActive ? Qt.rgba(1,1,1,0.4) : Qt.rgba(1,1,1,0.2)
                                    border.width: 1
                                    border.color: model.IsActive ? PlasmaCore.Theme.highlightColor : PlasmaCore.Theme.textColor
                                    radius: 2

                                    PlasmaCore.IconItem {
                                        visible: showIcons && parent.width > 16 && parent.height > 12
                                        anchors.centerIn: parent
                                        width: Math.min(parent.width - 4, parent.height - 4, 20)
                                        height: width
                                        source: model.decoration || "application-x-executable"
                                        usesPlasmaTheme: false
                                    }
                                }
                            }
                        }

                        // Badge
                        Rectangle {
                            anchors.bottom: parent.bottom
                            anchors.horizontalCenter: parent.horizontalCenter
                            anchors.bottomMargin: 3
                            width: badgeLabel.implicitWidth + 12
                            height: badgeLabel.implicitHeight + 4
                            color: Qt.rgba(0,0,0,0.7)
                            radius: 3

                            PlasmaComponents.Label {
                                id: badgeLabel
                                anchors.centerIn: parent
                                text: (index + 1) + " " + desktopItem.desktopName
                                font.pixelSize: 11
                                font.bold: true
                                color: "white"
                            }
                        }

                        MouseArea {
                            id: desktopMA
                            anchors.fill: parent
                            hoverEnabled: true
                            acceptedButtons: Qt.LeftButton | Qt.RightButton

                            property real startX: 0
                            property real startY: 0
                            property bool dragging: false

                            onPressed: function(mouse) {
                                if (mouse.button === Qt.LeftButton) {
                                    startX = mouse.x
                                    startY = mouse.y
                                    dragging = false
                                }
                            }

                            onPositionChanged: function(mouse) {
                                if (!(mouse.buttons & Qt.LeftButton)) return
                                var dist = Math.sqrt(Math.pow(mouse.x - startX, 2) + Math.pow(mouse.y - startY, 2))
                                if (!dragging && dist > 10) {
                                    dragging = true
                                    popup.dragSource = index
                                    dragRect.dragName = desktopItem.desktopName
                                }
                                if (dragging) {
                                    var pos = mapToItem(popup, mouse.x, mouse.y)
                                    dragRect.x = pos.x - dragRect.width / 2
                                    dragRect.y = pos.y - dragRect.height / 2

                                    var gpos = mapToItem(grid, mouse.x, mouse.y)
                                    popup.dropTarget = Logic.findDropTarget(repeater, grid, gpos.x, gpos.y)
                                }
                            }

                            onReleased: function(mouse) {
                                if (mouse.button === Qt.LeftButton && dragging && Logic.canSwap(popup.dragSource, popup.dropTarget, pagerModel.count)) {
                                    var idxA = popup.dragSource
                                    var idxB = popup.dropTarget
                                    var nameA = getDesktopName(idxA)
                                    var nameB = getDesktopName(idxB)
                                    var idA = getDesktopId(idxA)
                                    var idB = getDesktopId(idxB)

                                    if (idA && idB) {
                                        run(Logic.buildSwapWindowsCommand(idxA, idxB))
                                        run(Logic.buildRenameCommand(idA, nameB))
                                        run(Logic.buildRenameCommand(idB, nameA))
                                        refreshTimer.start()
                                    }
                                }
                                dragging = false
                                popup.dragSource = -1
                                popup.dropTarget = -1
                            }

                            onClicked: function(mouse) {
                                if (mouse.button === Qt.RightButton) {
                                    contextMenu.desktopIndex = index
                                    contextMenu.desktopName = desktopItem.desktopName
                                    contextMenu.desktopId = getDesktopId(index)
                                    contextMenu.popup()
                                } else if (!dragging) {
                                    pagerModel.changePage(index)
                                    plasmoid.expanded = false
                                }
                            }
                        }

                        // Delete button - declared AFTER desktopMA to receive events first
                        Rectangle {
                            id: deleteBtn
                            visible: desktopItem.isHovered && pagerModel.count > 1 && popup.dragSource < 0
                            anchors.top: parent.top
                            anchors.right: parent.right
                            anchors.margins: 4
                            width: Math.min(parent.width * 0.25, 36)
                            height: width
                            radius: width / 2
                            color: deleteMA.containsMouse ? "#e74c3c" : Qt.rgba(0,0,0,0.7)

                            PlasmaCore.IconItem {
                                anchors.centerIn: parent
                                width: parent.width * 0.6
                                height: width
                                source: "edit-delete"
                            }

                            MouseArea {
                                id: deleteMA
                                anchors.fill: parent
                                hoverEnabled: true
                                onClicked: {
                                    var id = getDesktopId(index)
                                    if (id) run(Logic.buildRemoveCommand(id))
                                }
                            }
                        }
                    }
                }
            }

            RowLayout {
                Layout.fillWidth: true
                Layout.preferredHeight: 36
                spacing: 8

                PlasmaComponents.Button {
                    icon.name: "list-add"
                    text: "Add"
                    onClicked: run(Logic.buildCreateCommand(pagerModel.count, "Desktop " + (pagerModel.count + 1)))
                }

                Item { Layout.fillWidth: true }

                PlasmaComponents.Label {
                    text: pagerModel.count + " desktops"
                    opacity: 0.6
                    font.pixelSize: 11
                }
            }
        }

        // Drag rectangle
        Rectangle {
            id: dragRect
            visible: popup.dragSource >= 0
            width: popup.deskW - 4
            height: popup.deskH - 4
            color: PlasmaCore.Theme.highlightColor
            opacity: 0.9
            radius: 4
            z: 1000

            property string dragName: ""

            PlasmaComponents.Label {
                anchors.centerIn: parent
                text: dragRect.dragName
                font.bold: true
                color: PlasmaCore.Theme.highlightedTextColor
            }
        }
    }
}