spotlight: fix mouse action menu click (#841)

* spotlight: fix clipping and add context menu keyboard navigation

* prime: also detect nvidia-offload command

* spotlight: fix review nitpicks

core/cmd/dms/commands_greeter.go

@@ -217,6 +217,190 @@ func checkGroupExists(groupName string) bool {
 	return false
 }
 
+func disableDisplayManager(dmName string) (bool, error) {
+	state, err := getSystemdServiceState(dmName)
+	if err != nil {
+		return false, fmt.Errorf("failed to check %s state: %w", dmName, err)
+	}
+
+	if !state.Exists {
+		return false, nil
+	}
+
+	fmt.Printf("\nChecking %s...\n", dmName)
+	fmt.Printf("  Current state: enabled=%s\n", state.EnabledState)
+
+	actionTaken := false
+
+	if state.NeedsDisable {
+		var disableCmd *exec.Cmd
+		var actionVerb string
+
+		if state.EnabledState == "static" {
+			fmt.Printf("  Masking %s (static service cannot be disabled)...\n", dmName)
+			disableCmd = exec.Command("sudo", "systemctl", "mask", dmName)
+			actionVerb = "masked"
+		} else {
+			fmt.Printf("  Disabling %s...\n", dmName)
+			disableCmd = exec.Command("sudo", "systemctl", "disable", dmName)
+			actionVerb = "disabled"
+		}
+
+		disableCmd.Stdout = os.Stdout
+		disableCmd.Stderr = os.Stderr
+		if err := disableCmd.Run(); err != nil {
+			return actionTaken, fmt.Errorf("failed to disable/mask %s: %w", dmName, err)
+		}
+
+		enabledState, shouldDisable, verifyErr := checkSystemdServiceEnabled(dmName)
+		if verifyErr != nil {
+			fmt.Printf("  ⚠ Warning: Could not verify %s was %s: %v\n", dmName, actionVerb, verifyErr)
+		} else if shouldDisable {
+			return actionTaken, fmt.Errorf("%s is still in state '%s' after %s operation", dmName, enabledState, actionVerb)
+		} else {
+			fmt.Printf("  ✓ %s %s (now: %s)\n", strings.Title(actionVerb), dmName, enabledState)
+		}
+
+		actionTaken = true
+	} else {
+		if state.EnabledState == "masked" || state.EnabledState == "masked-runtime" {
+			fmt.Printf("  ✓ %s is already masked\n", dmName)
+		} else {
+			fmt.Printf("  ✓ %s is already disabled\n", dmName)
+		}
+	}
+
+	return actionTaken, nil
+}
+
+func ensureGreetdEnabled() error {
+	fmt.Println("\nChecking greetd service status...")
+
+	state, err := getSystemdServiceState("greetd")
+	if err != nil {
+		return fmt.Errorf("failed to check greetd state: %w", err)
+	}
+
+	if !state.Exists {
+		return fmt.Errorf("greetd service not found. Please install greetd first")
+	}
+
+	fmt.Printf("  Current state: %s\n", state.EnabledState)
+
+	if state.EnabledState == "masked" || state.EnabledState == "masked-runtime" {
+		fmt.Println("  Unmasking greetd...")
+		unmaskCmd := exec.Command("sudo", "systemctl", "unmask", "greetd")
+		unmaskCmd.Stdout = os.Stdout
+		unmaskCmd.Stderr = os.Stderr
+		if err := unmaskCmd.Run(); err != nil {
+			return fmt.Errorf("failed to unmask greetd: %w", err)
+		}
+		fmt.Println("  ✓ Unmasked greetd")
+	}
+
+	if state.EnabledState == "disabled" || state.EnabledState == "masked" || state.EnabledState == "masked-runtime" {
+		fmt.Println("  Enabling greetd service...")
+		enableCmd := exec.Command("sudo", "systemctl", "enable", "greetd")
+		enableCmd.Stdout = os.Stdout
+		enableCmd.Stderr = os.Stderr
+		if err := enableCmd.Run(); err != nil {
+			return fmt.Errorf("failed to enable greetd: %w", err)
+		}
+		fmt.Println("  ✓ Enabled greetd service")
+	} else if state.EnabledState == "enabled" || state.EnabledState == "enabled-runtime" {
+		fmt.Println("  ✓ greetd is already enabled")
+	} else {
+		fmt.Printf("  ℹ greetd is in state '%s' (should work, no action needed)\n", state.EnabledState)
+	}
+
+	return nil
+}
+
+func ensureGraphicalTarget() error {
+	getDefaultCmd := exec.Command("systemctl", "get-default")
+	currentTarget, err := getDefaultCmd.Output()
+	if err != nil {
+		fmt.Println("⚠ Warning: Could not detect current default systemd target")
+		return nil
+	}
+
+	currentTargetStr := strings.TrimSpace(string(currentTarget))
+	if currentTargetStr != "graphical.target" {
+		fmt.Printf("\nSetting graphical.target as default (current: %s)...\n", currentTargetStr)
+		setDefaultCmd := exec.Command("sudo", "systemctl", "set-default", "graphical.target")
+		setDefaultCmd.Stdout = os.Stdout
+		setDefaultCmd.Stderr = os.Stderr
+		if err := setDefaultCmd.Run(); err != nil {
+			fmt.Println("⚠ Warning: Failed to set graphical.target as default")
+			fmt.Println("  Greeter may not start on boot. Run manually:")
+			fmt.Println("  sudo systemctl set-default graphical.target")
+			return nil
+		}
+		fmt.Println("✓ Set graphical.target as default")
+	} else {
+		fmt.Println("✓ Default target already set to graphical.target")
+	}
+
+	return nil
+}
+
+func handleConflictingDisplayManagers() error {
+	fmt.Println("\n=== Checking for Conflicting Display Managers ===")
+
+	conflictingDMs := []string{"gdm", "gdm3", "lightdm", "sddm", "lxdm", "xdm"}
+
+	disabledAny := false
+	var errors []string
+
+	for _, dm := range conflictingDMs {
+		actionTaken, err := disableDisplayManager(dm)
+		if err != nil {
+			errMsg := fmt.Sprintf("Failed to handle %s: %v", dm, err)
+			errors = append(errors, errMsg)
+			fmt.Printf("  ⚠⚠⚠ ERROR: %s\n", errMsg)
+			continue
+		}
+		if actionTaken {
+			disabledAny = true
+		}
+	}
+
+	if len(errors) > 0 {
+		fmt.Println("\n╔════════════════════════════════════════════════════════════╗")
+		fmt.Println("║           ⚠⚠⚠ ERRORS OCCURRED ⚠⚠⚠                      ║")
+		fmt.Println("╚════════════════════════════════════════════════════════════╝")
+		fmt.Println("\nSome display managers could not be disabled:")
+		for _, err := range errors {
+			fmt.Printf("  ✗ %s\n", err)
+		}
+		fmt.Println("\nThis may prevent greetd from starting properly.")
+		fmt.Println("You may need to manually disable them before greetd will work.")
+		fmt.Println("\nManual commands to try:")
+		for _, dm := range conflictingDMs {
+			fmt.Printf("  sudo systemctl disable %s\n", dm)
+			fmt.Printf("  sudo systemctl mask %s\n", dm)
+		}
+		fmt.Print("\nContinue with greeter enablement anyway? (Y/n): ")
+
+		var response string
+		fmt.Scanln(&response)
+		response = strings.ToLower(strings.TrimSpace(response))
+
+		if response == "n" || response == "no" {
+			return fmt.Errorf("aborted due to display manager conflicts")
+		}
+		fmt.Println("\nContinuing despite errors...")
+	}
+
+	if !disabledAny && len(errors) == 0 {
+		fmt.Println("\n✓ No conflicting display managers found")
+	} else if disabledAny && len(errors) == 0 {
+		fmt.Println("\n✓ Successfully handled all conflicting display managers")
+	}
+
+	return nil
+}
+
 func enableGreeter() error {
 	fmt.Println("=== DMS Greeter Enable ===")
 	fmt.Println()
@@ -232,8 +416,29 @@ func enableGreeter() error {
 	}
 
 	configContent := string(data)
-	if strings.Contains(configContent, "dms-greeter") {
+	configAlreadyCorrect := strings.Contains(configContent, "dms-greeter")
+
+	if configAlreadyCorrect {
 		fmt.Println("✓ Greeter is already configured with dms-greeter")
+
+		if err := ensureGraphicalTarget(); err != nil {
+			return err
+		}
+
+		if err := handleConflictingDisplayManagers(); err != nil {
+			return err
+		}
+
+		if err := ensureGreetdEnabled(); err != nil {
+			return err
+		}
+
+		fmt.Println("\n=== Enable Complete ===")
+		fmt.Println("\nGreeter configuration verified and system state corrected.")
+		fmt.Println("To start the greeter now, run:")
+		fmt.Println("  sudo systemctl start greetd")
+		fmt.Println("\nOr reboot to see the greeter at boot time.")
+
 		return nil
 	}
 
@@ -323,67 +528,16 @@ func enableGreeter() error {
 
 	fmt.Printf("✓ Updated greetd configuration to use %s\n", selectedCompositor)
 
-	// Check and set graphical.target as default
-	getDefaultCmd := exec.Command("systemctl", "get-default")
-	currentTarget, err := getDefaultCmd.Output()
-	if err != nil {
-		fmt.Println("⚠ Warning: Could not detect current default systemd target")
-	} else {
-		currentTargetStr := strings.TrimSpace(string(currentTarget))
-		if currentTargetStr != "graphical.target" {
-			fmt.Printf("\nSetting graphical.target as default (current: %s)...\n", currentTargetStr)
-			setDefaultCmd := exec.Command("sudo", "systemctl", "set-default", "graphical.target")
-			setDefaultCmd.Stdout = os.Stdout
-			setDefaultCmd.Stderr = os.Stderr
-			if err := setDefaultCmd.Run(); err != nil {
-				fmt.Println("⚠ Warning: Failed to set graphical.target as default")
-				fmt.Println("  Greeter may not start on boot. Run manually:")
-				fmt.Println("  sudo systemctl set-default graphical.target")
-			} else {
-				fmt.Println("✓ Set graphical.target as default")
-			}
-		} else {
-			fmt.Println("✓ Default target already set to graphical.target")
-		}
+	if err := ensureGraphicalTarget(); err != nil {
+		return err
 	}
 
-	// Check for conflicting display managers and disable them
-	fmt.Println("\nChecking for conflicting display managers...")
-	conflictingDMs := []string{"gdm", "lightdm", "sddm"}
-	disabledAny := false
-
-	for _, dm := range conflictingDMs {
-		checkCmd := exec.Command("systemctl", "is-enabled", dm)
-		output, err := checkCmd.Output()
-		if err == nil && strings.TrimSpace(string(output)) == "enabled" {
-			fmt.Printf("⚠ Found enabled display manager: %s\n", dm)
-			fmt.Printf("  Disabling %s...\n", dm)
-			disableCmd := exec.Command("sudo", "systemctl", "disable", dm)
-			disableCmd.Stdout = os.Stdout
-			disableCmd.Stderr = os.Stderr
-			if err := disableCmd.Run(); err != nil {
-				fmt.Printf("  ⚠ Warning: Failed to disable %s\n", dm)
-			} else {
-				fmt.Printf("  ✓ Disabled %s\n", dm)
-				disabledAny = true
-			}
-		}
+	if err := handleConflictingDisplayManagers(); err != nil {
+		return err
 	}
 
-	if !disabledAny {
-		fmt.Println("✓ No conflicting display managers found")
-	}
-
-	// Enable greetd service
-	fmt.Println("\nEnabling greetd service...")
-	enableCmd := exec.Command("sudo", "systemctl", "enable", "greetd")
-	enableCmd.Stdout = os.Stdout
-	enableCmd.Stderr = os.Stderr
-	if err := enableCmd.Run(); err != nil {
-		fmt.Println("⚠ Warning: Failed to enable greetd service")
-		fmt.Println("  Run manually: sudo systemctl enable greetd")
-	} else {
-		fmt.Println("✓ Enabled greetd service")
+	if err := ensureGreetdEnabled(); err != nil {
+		return err
 	}
 
 	fmt.Println("\n=== Enable Complete ===")

core/cmd/dms/utils.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os/exec"
+	"strings"
 )
 
 func commandExists(cmd string) bool {
@@ -24,3 +25,68 @@ func isArchPackageInstalled(packageName string) bool {
 	err := cmd.Run()
 	return err == nil
 }
+
+type systemdServiceState struct {
+	Name         string
+	EnabledState string
+	NeedsDisable bool
+	Exists       bool
+}
+
+// checkSystemdServiceEnabled returns (state, should_disable, error) for a systemd service
+func checkSystemdServiceEnabled(serviceName string) (string, bool, error) {
+	cmd := exec.Command("systemctl", "is-enabled", serviceName)
+	output, err := cmd.Output()
+
+	stateStr := strings.TrimSpace(string(output))
+
+	if err != nil {
+		knownStates := []string{"disabled", "masked", "masked-runtime", "not-found", "enabled", "enabled-runtime", "static", "indirect", "alias"}
+		isKnownState := false
+		for _, known := range knownStates {
+			if stateStr == known {
+				isKnownState = true
+				break
+			}
+		}
+
+		if !isKnownState {
+			return stateStr, false, fmt.Errorf("systemctl is-enabled failed: %w (output: %s)", err, stateStr)
+		}
+	}
+
+	shouldDisable := false
+	switch stateStr {
+	case "enabled", "enabled-runtime", "static", "indirect", "alias":
+		shouldDisable = true
+	case "disabled", "masked", "masked-runtime", "not-found":
+		shouldDisable = false
+	default:
+		shouldDisable = true
+	}
+
+	return stateStr, shouldDisable, nil
+}
+
+func getSystemdServiceState(serviceName string) (*systemdServiceState, error) {
+	state := &systemdServiceState{
+		Name:   serviceName,
+		Exists: false,
+	}
+
+	enabledState, needsDisable, err := checkSystemdServiceEnabled(serviceName)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check enabled state: %w", err)
+	}
+
+	state.EnabledState = enabledState
+	state.NeedsDisable = needsDisable
+
+	if enabledState == "not-found" {
+		state.Exists = false
+		return state, nil
+	}
+
+	state.Exists = true
+	return state, nil
+}

distro/fedora/dms-greeter.spec

@@ -25,6 +25,7 @@ Requires(post): /usr/sbin/useradd
 Requires(post): /usr/sbin/groupadd
 
 Recommends:     policycoreutils-python-utils
+Recommends:     setfacl
 Suggests:       niri
 Suggests:       hyprland
 Suggests:       sway

flake.nix

@@ -20,9 +20,8 @@
                 system: fn system nixpkgs.legacyPackages.${system}
             );
         buildDmsPkgs = pkgs: {
-            dmsCli = self.packages.${pkgs.stdenv.hostPlatform.system}.dmsCli;
+            inherit (self.packages.${pkgs.stdenv.hostPlatform.system}) dmsCli dankMaterialShell;
             dgop = dgop.packages.${pkgs.stdenv.hostPlatform.system}.dgop;
-            dankMaterialShell = self.packages.${pkgs.stdenv.hostPlatform.system}.dankMaterialShell;
         };
         mkModuleWithDmsPkgs = path: args @ {pkgs, ...}: {
             imports = [
@@ -62,6 +61,15 @@
                         "-X main.Version=${finalAttrs.version}"
                     ];
 
+                    nativeBuildInputs = [pkgs.installShellFiles];
+
+                    postInstall = ''
+                        installShellCompletion --cmd dms \
+                          --bash <($out/bin/dms completion bash) \
+                          --fish <($out/bin/dms completion fish ) \
+                          --zsh <($out/bin/dms completion zsh)
+                    '';
+
                     meta = {
                         description = "DankMaterialShell Command Line Interface";
                         homepage = "https://github.com/AvengeMedia/danklinux";

quickshell/Modals/Spotlight/SpotlightContent.qml

@@ -11,8 +11,10 @@ Item {
     property alias appLauncher: appLauncher
     property alias searchField: searchField
     property alias fileSearchController: fileSearchController
+    property alias resultsView: resultsView
     property var parentModal: null
     property string searchMode: "apps"
+    property bool usePopupContextMenu: false
 
     function resetScroll() {
         if (searchMode === "apps") {
@@ -146,6 +148,18 @@ Item {
                 fileSearchController.openSelected();
             }
             event.accepted = true;
+        } else if (event.key === Qt.Key_Menu) {
+            if (searchMode === "apps" && appLauncher.model.count > 0) {
+                const selectedApp = appLauncher.model.get(appLauncher.selectedIndex);
+                const menu = usePopupContextMenu ? popupContextMenu : layerContextMenuLoader.item;
+                
+                if (selectedApp && menu && resultsView) {
+                    const itemPos = resultsView.getSelectedItemPosition();
+                    const contentPos = resultsView.mapToItem(spotlightKeyHandler, itemPos.x, itemPos.y);
+                    menu.show(contentPos.x, contentPos.y, selectedApp, true);
+                }
+            }
+            event.accepted = true;
         }
     }
 
@@ -178,6 +192,52 @@ Item {
         }
     }
 
+    
+    SpotlightContextMenuPopup {
+        id: popupContextMenu
+        
+        parent: spotlightKeyHandler
+        appLauncher: spotlightKeyHandler.appLauncher
+        parentHandler: spotlightKeyHandler
+        searchField: spotlightKeyHandler.searchField
+        visible: false
+        z: 1000
+    }
+    
+    MouseArea {
+        anchors.fill: parent
+        visible: usePopupContextMenu && popupContextMenu.visible
+        hoverEnabled: true
+        z: 999
+        onClicked: popupContextMenu.hide()
+    }
+    
+    Loader {
+        id: layerContextMenuLoader
+        active: !spotlightKeyHandler.usePopupContextMenu
+        asynchronous: false
+        sourceComponent: Component {
+            SpotlightContextMenu {
+                appLauncher: spotlightKeyHandler.appLauncher
+                parentHandler: spotlightKeyHandler
+                parentModal: spotlightKeyHandler.parentModal
+            }
+        }
+    }
+    
+    Connections {
+        target: parentModal
+        function onSpotlightOpenChanged() {
+            if (parentModal && !parentModal.spotlightOpen) {
+                if (layerContextMenuLoader.item) {
+                    layerContextMenuLoader.item.hide();
+                }
+                popupContextMenu.hide();
+            }
+        }
+        enabled: parentModal !== null
+    }
+
     Column {
         anchors.fill: parent
         anchors.margins: Theme.spacingM
@@ -397,8 +457,22 @@ Item {
                 id: resultsView
                 anchors.fill: parent
                 appLauncher: spotlightKeyHandler.appLauncher
-                contextMenu: contextMenu
                 visible: searchMode === "apps"
+                
+                onItemRightClicked: (index, modelData, mouseX, mouseY) => {
+                    const menu = usePopupContextMenu ? popupContextMenu : layerContextMenuLoader.item;
+                    
+                    if (menu?.show) {
+                        const isPopup = menu.contentItem !== undefined;
+                        
+                        if (isPopup) {
+                            const localPos = popupContextMenu.parent.mapFromItem(null, mouseX, mouseY);
+                            menu.show(localPos.x, localPos.y, modelData, false);
+                        } else {
+                            menu.show(mouseX, mouseY, modelData, false);
+                        }
+                    }
+                }
             }
 
             FileSearchResults {
@@ -410,31 +484,6 @@ Item {
         }
     }
 
-    SpotlightContextMenu {
-        id: contextMenu
-
-        appLauncher: spotlightKeyHandler.appLauncher
-        parentHandler: spotlightKeyHandler
-    }
-
-    MouseArea {
-        anchors.fill: parent
-        visible: contextMenu.visible
-        z: 999
-        onClicked: () => {
-            contextMenu.hide();
-        }
-
-        MouseArea {
-
-            x: contextMenu.x
-            y: contextMenu.y
-            width: contextMenu.width
-            height: contextMenu.height
-            onClicked: () => {}
-        }
-    }
-
     Loader {
         id: filenameTooltipLoader
 

quickshell/Modals/Spotlight/SpotlightContextMenu.qml

@@ -1,338 +1,117 @@
 import QtQuick
-import QtQuick.Controls
 import Quickshell
+import Quickshell.Wayland
 import Quickshell.Widgets
 import qs.Common
-import qs.Services
-import qs.Widgets
+import qs.Modals.Spotlight
 
-Popup {
-    id: contextMenu
+PanelWindow {
+    id: root
+
+    WlrLayershell.namespace: "dms:spotlight-context-menu"
+    WlrLayershell.layer: WlrLayershell.Overlay
+    WlrLayershell.exclusiveZone: -1
+    WlrLayershell.keyboardFocus: WlrKeyboardFocus.Exclusive
 
-    property var currentApp: null
     property var appLauncher: null
     property var parentHandler: null
-    readonly property var desktopEntry: (currentApp && !currentApp.isPlugin && appLauncher && appLauncher._uniqueApps && currentApp.appIndex >= 0 && currentApp.appIndex < appLauncher._uniqueApps.length) ? appLauncher._uniqueApps[currentApp.appIndex] : null
+    property var parentModal: null
+    property real menuPositionX: 0
+    property real menuPositionY: 0
+    
+    readonly property real shadowBuffer: 5
+    
+    screen: parentModal?.effectiveScreen
 
-    function show(x, y, app) {
-        currentApp = app
-        contextMenu.x = x + 4
-        contextMenu.y = y + 4
-        contextMenu.open()
+    function show(x, y, app, fromKeyboard) {
+        fromKeyboard = fromKeyboard || false;
+        menuContent.currentApp = app;
+        
+        let screenX = x;
+        let screenY = y;
+        
+        if (parentModal) {
+            if (fromKeyboard) {
+                screenX = x + parentModal.alignedX;
+                screenY = y + parentModal.alignedY;
+            } else {
+                screenX = x + (parentModal.alignedX - shadowBuffer);
+                screenY = y + (parentModal.alignedY - shadowBuffer);
+            }
+        }
+        
+        menuPositionX = screenX;
+        menuPositionY = screenY;
+        
+        menuContent.selectedMenuIndex = fromKeyboard ? 0 : -1;
+        menuContent.keyboardNavigation = true;
+        visible = true;
+        
+        if (parentHandler) {
+            parentHandler.enabled = false;
+        }
+        Qt.callLater(() => {
+            menuContent.keyboardHandler.forceActiveFocus();
+        });
     }
 
     function hide() {
-        contextMenu.close()
+        if (parentHandler) {
+            parentHandler.enabled = true;
+        }
+        visible = false;
     }
 
-    width: Math.max(180, menuColumn.implicitWidth + Theme.spacingS * 2)
-    height: menuColumn.implicitHeight + Theme.spacingS * 2
-    padding: 0
-    closePolicy: Popup.CloseOnPressOutside
-    modal: false
-    dim: false
+    visible: false
+    color: "transparent"
+    anchors {
+        top: true
+        left: true
+        right: true
+        bottom: true
+    }
 
-    background: Rectangle {
-        radius: Theme.cornerRadius
-        color: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
-        border.color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.08)
-        border.width: 1
-
-        Rectangle {
-            anchors.fill: parent
-            anchors.topMargin: 4
-            anchors.leftMargin: 2
-            anchors.rightMargin: -2
-            anchors.bottomMargin: -4
-            radius: parent.radius
-            color: Qt.rgba(0, 0, 0, 0.15)
-            z: -1
+    onVisibleChanged: {
+        if (!visible && parentHandler) {
+            parentHandler.enabled = true;
         }
     }
 
-    enter: Transition {
-        NumberAnimation {
-            property: "opacity"
-            from: 0
-            to: 1
-            duration: Theme.shortDuration
-            easing.type: Theme.emphasizedEasing
+    SpotlightContextMenuContent {
+        id: menuContent
+
+        x: {
+            const left = 10;
+            const right = root.width - width - 10;
+            const want = menuPositionX;
+            return Math.max(left, Math.min(right, want));
         }
+        y: {
+            const top = 10;
+            const bottom = root.height - height - 10;
+            const want = menuPositionY;
+            return Math.max(top, Math.min(bottom, want));
+        }
+
+        appLauncher: root.appLauncher
+
+        opacity: root.visible ? 1 : 0
+        visible: opacity > 0
+
+        Behavior on opacity {
+            NumberAnimation {
+                duration: Theme.shortDuration
+                easing.type: Theme.emphasizedEasing
+            }
+        }
+
+        onHideRequested: root.hide()
     }
 
-    exit: Transition {
-        NumberAnimation {
-            property: "opacity"
-            from: 1
-            to: 0
-            duration: Theme.shortDuration
-            easing.type: Theme.emphasizedEasing
-        }
-    }
-
-    Column {
-        id: menuColumn
-
+    MouseArea {
         anchors.fill: parent
-        anchors.margins: Theme.spacingS
-        spacing: 1
-
-        Rectangle {
-            width: parent.width
-            height: 32
-            radius: Theme.cornerRadius
-            color: pinMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
-
-            Row {
-                id: pinRow
-                anchors.left: parent.left
-                anchors.leftMargin: Theme.spacingS
-                anchors.verticalCenter: parent.verticalCenter
-                spacing: Theme.spacingS
-
-                DankIcon {
-                    name: {
-                        if (!desktopEntry)
-                            return "push_pin"
-
-                        const appId = desktopEntry.id || desktopEntry.execString || ""
-                        return SessionData.isPinnedApp(appId) ? "keep_off" : "push_pin"
-                    }
-                    size: Theme.iconSize - 2
-                    color: Theme.surfaceText
-                    opacity: 0.7
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-
-                StyledText {
-                    text: {
-                        if (!desktopEntry)
-                            return I18n.tr("Pin to Dock")
-
-                        const appId = desktopEntry.id || desktopEntry.execString || ""
-                        return SessionData.isPinnedApp(appId) ? I18n.tr("Unpin from Dock") : I18n.tr("Pin to Dock")
-                    }
-                    font.pixelSize: Theme.fontSizeSmall
-                    color: Theme.surfaceText
-                    font.weight: Font.Normal
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-            }
-
-            MouseArea {
-                id: pinMouseArea
-
-                anchors.fill: parent
-                hoverEnabled: true
-                cursorShape: Qt.PointingHandCursor
-                onClicked: () => {
-                               if (!desktopEntry)
-                               return
-
-                               const appId = desktopEntry.id || desktopEntry.execString || ""
-                               if (SessionData.isPinnedApp(appId))
-                               SessionData.removePinnedApp(appId)
-                               else
-                               SessionData.addPinnedApp(appId)
-                               contextMenu.hide()
-                           }
-            }
-        }
-
-        Rectangle {
-            width: parent.width - Theme.spacingS * 2
-            height: 5
-            anchors.horizontalCenter: parent.horizontalCenter
-            color: "transparent"
-
-            Rectangle {
-                anchors.centerIn: parent
-                width: parent.width
-                height: 1
-                color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.2)
-            }
-        }
-
-        Repeater {
-            model: desktopEntry && desktopEntry.actions ? desktopEntry.actions : []
-
-            Rectangle {
-                width: parent.width
-                height: 32
-                radius: Theme.cornerRadius
-                color: actionMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
-
-                Row {
-                    id: actionRow
-                    anchors.left: parent.left
-                    anchors.leftMargin: Theme.spacingS
-                    anchors.verticalCenter: parent.verticalCenter
-                    spacing: Theme.spacingS
-
-                    Item {
-                        anchors.verticalCenter: parent.verticalCenter
-                        width: Theme.iconSize - 2
-                        height: Theme.iconSize - 2
-                        visible: modelData.icon && modelData.icon !== ""
-
-                        IconImage {
-                            anchors.fill: parent
-                            source: modelData.icon ? Quickshell.iconPath(modelData.icon, true) : ""
-                            smooth: true
-                            asynchronous: true
-                            visible: status === Image.Ready
-                        }
-                    }
-
-                    StyledText {
-                        text: modelData.name || ""
-                        font.pixelSize: Theme.fontSizeSmall
-                        color: Theme.surfaceText
-                        font.weight: Font.Normal
-                        anchors.verticalCenter: parent.verticalCenter
-                    }
-                }
-
-                MouseArea {
-                    id: actionMouseArea
-                    anchors.fill: parent
-                    hoverEnabled: true
-                    cursorShape: Qt.PointingHandCursor
-                    onClicked: {
-                        if (modelData && desktopEntry) {
-                            SessionService.launchDesktopAction(desktopEntry, modelData)
-                            if (appLauncher && contextMenu.currentApp) {
-                                appLauncher.appLaunched(contextMenu.currentApp)
-                            }
-                        }
-                        contextMenu.hide()
-                    }
-                }
-            }
-        }
-
-        Rectangle {
-            visible: desktopEntry && desktopEntry.actions && desktopEntry.actions.length > 0
-            width: parent.width - Theme.spacingS * 2
-            height: 5
-            anchors.horizontalCenter: parent.horizontalCenter
-            color: "transparent"
-
-            Rectangle {
-                anchors.centerIn: parent
-                width: parent.width
-                height: 1
-                color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.2)
-            }
-        }
-
-        Rectangle {
-            width: parent.width
-            height: 32
-            radius: Theme.cornerRadius
-            color: launchMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
-
-            Row {
-                id: launchRow
-                anchors.left: parent.left
-                anchors.leftMargin: Theme.spacingS
-                anchors.verticalCenter: parent.verticalCenter
-                spacing: Theme.spacingS
-
-                DankIcon {
-                    name: "launch"
-                    size: Theme.iconSize - 2
-                    color: Theme.surfaceText
-                    opacity: 0.7
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-
-                StyledText {
-                    text: I18n.tr("Launch")
-                    font.pixelSize: Theme.fontSizeSmall
-                    color: Theme.surfaceText
-                    font.weight: Font.Normal
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-            }
-
-            MouseArea {
-                id: launchMouseArea
-
-                anchors.fill: parent
-                hoverEnabled: true
-                cursorShape: Qt.PointingHandCursor
-                onClicked: () => {
-                               if (contextMenu.currentApp && appLauncher)
-                               appLauncher.launchApp(contextMenu.currentApp)
-
-                               contextMenu.hide()
-                           }
-            }
-        }
-
-        Rectangle {
-            visible: SessionService.hasPrimeRun
-            width: parent.width - Theme.spacingS * 2
-            height: 5
-            anchors.horizontalCenter: parent.horizontalCenter
-            color: "transparent"
-
-            Rectangle {
-                anchors.centerIn: parent
-                width: parent.width
-                height: 1
-                color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.2)
-            }
-        }
-
-        Rectangle {
-            visible: SessionService.hasPrimeRun
-            width: parent.width
-            height: 32
-            radius: Theme.cornerRadius
-            color: primeRunMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
-
-            Row {
-                id: primeRunRow
-                anchors.left: parent.left
-                anchors.leftMargin: Theme.spacingS
-                anchors.verticalCenter: parent.verticalCenter
-                spacing: Theme.spacingS
-
-                DankIcon {
-                    name: "memory"
-                    size: Theme.iconSize - 2
-                    color: Theme.surfaceText
-                    opacity: 0.7
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-
-                StyledText {
-                    text: I18n.tr("Launch on dGPU")
-                    font.pixelSize: Theme.fontSizeSmall
-                    color: Theme.surfaceText
-                    font.weight: Font.Normal
-                    anchors.verticalCenter: parent.verticalCenter
-                }
-            }
-
-            MouseArea {
-                id: primeRunMouseArea
-
-                anchors.fill: parent
-                hoverEnabled: true
-                cursorShape: Qt.PointingHandCursor
-                onClicked: () => {
-                               if (desktopEntry) {
-                                   SessionService.launchDesktopEntry(desktopEntry, true)
-                                   if (appLauncher && contextMenu.currentApp) {
-                                       appLauncher.appLaunched(contextMenu.currentApp)
-                                   }
-                               }
-                               contextMenu.hide()
-                           }
-            }
-        }
+        z: -1
+        acceptedButtons: Qt.LeftButton | Qt.RightButton
+        onClicked: root.hide()
     }
 }

quickshell/Modals/Spotlight/SpotlightContextMenuContent.qml

@@ -0,0 +1,292 @@
+import QtQuick
+import qs.Common
+import qs.Services
+import qs.Widgets
+
+Item {
+    id: root
+
+    property var currentApp: null
+    property var appLauncher: null
+    property int selectedMenuIndex: 0
+    property bool keyboardNavigation: false
+
+    signal hideRequested()
+
+    readonly property var desktopEntry: (currentApp && !currentApp.isPlugin && appLauncher && appLauncher._uniqueApps && currentApp.appIndex >= 0 && currentApp.appIndex < appLauncher._uniqueApps.length) ? appLauncher._uniqueApps[currentApp.appIndex] : null
+
+    readonly property var menuItems: {
+        const items = [];
+        const appId = desktopEntry ? (desktopEntry.id || desktopEntry.execString || "") : "";
+        const isPinned = SessionData.isPinnedApp(appId);
+
+        items.push({
+            type: "item",
+            icon: isPinned ? "keep_off" : "push_pin",
+            text: isPinned ? I18n.tr("Unpin from Dock") : I18n.tr("Pin to Dock"),
+            action: togglePin
+        });
+
+        if (desktopEntry && desktopEntry.actions) {
+            items.push({
+                type: "separator"
+            });
+            for (let i = 0; i < desktopEntry.actions.length; i++) {
+                const act = desktopEntry.actions[i];
+                items.push({
+                    type: "item",
+                    text: act.name || "",
+                    action: () => launchAction(act)
+                });
+            }
+        }
+
+        items.push({
+            type: "separator",
+            hidden: !desktopEntry || !desktopEntry.actions || desktopEntry.actions.length === 0
+        });
+        items.push({
+            type: "item",
+            icon: "launch",
+            text: I18n.tr("Launch"),
+            action: launchCurrentApp
+        });
+
+        if (SessionService.nvidiaCommand) {
+            items.push({
+                type: "separator"
+            });
+            items.push({
+                type: "item",
+                icon: "memory",
+                text: I18n.tr("Launch on dGPU"),
+                action: launchWithNvidia
+            });
+        }
+
+        return items;
+    }
+
+    readonly property int visibleItemCount: {
+        let count = 0;
+        for (let i = 0; i < menuItems.length; i++) {
+            if (menuItems[i].type === "item" && !menuItems[i].hidden) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    function selectNext() {
+        if (visibleItemCount > 0) {
+            selectedMenuIndex = (selectedMenuIndex + 1) % visibleItemCount;
+        }
+    }
+
+    function selectPrevious() {
+        if (visibleItemCount > 0) {
+            selectedMenuIndex = (selectedMenuIndex - 1 + visibleItemCount) % visibleItemCount;
+        }
+    }
+
+    function togglePin() {
+        if (!desktopEntry)
+            return;
+        const appId = desktopEntry.id || desktopEntry.execString || "";
+        if (SessionData.isPinnedApp(appId))
+            SessionData.removePinnedApp(appId);
+        else
+            SessionData.addPinnedApp(appId);
+        hideRequested();
+    }
+
+    function launchCurrentApp() {
+        if (currentApp && appLauncher)
+            appLauncher.launchApp(currentApp);
+        hideRequested();
+    }
+
+    function launchWithNvidia() {
+        if (desktopEntry) {
+            SessionService.launchDesktopEntry(desktopEntry, true);
+            if (appLauncher && currentApp) {
+                appLauncher.appLaunched(currentApp);
+            }
+        }
+        hideRequested();
+    }
+
+    function launchAction(action) {
+        if (desktopEntry) {
+            SessionService.launchDesktopAction(desktopEntry, action);
+            if (appLauncher && currentApp) {
+                appLauncher.appLaunched(currentApp);
+            }
+        }
+        hideRequested();
+    }
+
+    function activateSelected() {
+        let itemIndex = 0;
+        for (let i = 0; i < menuItems.length; i++) {
+            if (menuItems[i].type === "item" && !menuItems[i].hidden) {
+                if (itemIndex === selectedMenuIndex) {
+                    menuItems[i].action();
+                    return;
+                }
+                itemIndex++;
+            }
+        }
+    }
+
+    property alias keyboardHandler: keyboardHandler
+
+    implicitWidth: Math.max(180, menuColumn.implicitWidth + Theme.spacingS * 2)
+    implicitHeight: menuColumn.implicitHeight + Theme.spacingS * 2
+    
+    width: implicitWidth
+    height: implicitHeight
+
+    Rectangle {
+        id: menuContainer
+        anchors.fill: parent
+        color: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
+        radius: Theme.cornerRadius
+        border.color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.08)
+        border.width: 1
+
+        Rectangle {
+            anchors.fill: parent
+            anchors.topMargin: 4
+            anchors.leftMargin: 2
+            anchors.rightMargin: -2
+            anchors.bottomMargin: -4
+            radius: parent.radius
+            color: Qt.rgba(0, 0, 0, 0.15)
+            z: -1
+        }
+
+        Item {
+            id: keyboardHandler
+            anchors.fill: parent
+            focus: keyboardNavigation
+
+            Keys.onPressed: event => {
+                if (event.key === Qt.Key_Down) {
+                    selectNext();
+                    event.accepted = true;
+                } else if (event.key === Qt.Key_Up) {
+                    selectPrevious();
+                    event.accepted = true;
+                } else if (event.key === Qt.Key_Return || event.key === Qt.Key_Enter) {
+                    activateSelected();
+                    event.accepted = true;
+                } else if (event.key === Qt.Key_Escape) {
+                    hideRequested();
+                    event.accepted = true;
+                }
+            }
+
+            Column {
+                id: menuColumn
+                anchors.fill: parent
+                anchors.margins: Theme.spacingS
+                spacing: 1
+
+                Repeater {
+                    model: menuItems
+
+                    Item {
+                        width: parent.width
+                        height: modelData.type === "separator" ? 5 : 32
+                        visible: !modelData.hidden
+
+                        property int itemIndex: {
+                            let count = 0;
+                            for (let i = 0; i < index; i++) {
+                                if (menuItems[i].type === "item" && !menuItems[i].hidden) {
+                                    count++;
+                                }
+                            }
+                            return count;
+                        }
+
+                        Rectangle {
+                            visible: modelData.type === "separator"
+                            width: parent.width - Theme.spacingS * 2
+                            height: parent.height
+                            anchors.horizontalCenter: parent.horizontalCenter
+                            color: "transparent"
+
+                            Rectangle {
+                                anchors.centerIn: parent
+                                width: parent.width
+                                height: 1
+                                color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.2)
+                            }
+                        }
+
+                        Rectangle {
+                            visible: modelData.type === "item"
+                            width: parent.width
+                            height: parent.height
+                            radius: Theme.cornerRadius
+                            color: {
+                                if (keyboardNavigation && selectedMenuIndex === itemIndex) {
+                                    return Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.2);
+                                }
+                                return mouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent";
+                            }
+
+                            Row {
+                                anchors.left: parent.left
+                                anchors.leftMargin: Theme.spacingS
+                                anchors.right: parent.right
+                                anchors.rightMargin: Theme.spacingS
+                                anchors.verticalCenter: parent.verticalCenter
+                                spacing: Theme.spacingS
+
+                                Item {
+                                    width: Theme.iconSize - 2
+                                    height: Theme.iconSize - 2
+                                    anchors.verticalCenter: parent.verticalCenter
+
+                                    DankIcon {
+                                        visible: modelData.icon !== undefined && modelData.icon !== ""
+                                        name: modelData.icon || ""
+                                        size: Theme.iconSize - 2
+                                        color: Theme.surfaceText
+                                        opacity: 0.7
+                                        anchors.verticalCenter: parent.verticalCenter
+                                    }
+                                }
+
+                                StyledText {
+                                    text: modelData.text || ""
+                                    font.pixelSize: Theme.fontSizeSmall
+                                    color: Theme.surfaceText
+                                    font.weight: Font.Normal
+                                    anchors.verticalCenter: parent.verticalCenter
+                                    elide: Text.ElideRight
+                                    width: parent.width - (Theme.iconSize - 2) - Theme.spacingS
+                                }
+                            }
+
+                            MouseArea {
+                                id: mouseArea
+                                anchors.fill: parent
+                                hoverEnabled: true
+                                cursorShape: Qt.PointingHandCursor
+                                onEntered: {
+                                    keyboardNavigation = false;
+                                    selectedMenuIndex = itemIndex;
+                                }
+                                onClicked: modelData.action()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

quickshell/Modals/Spotlight/SpotlightContextMenuPopup.qml

@@ -0,0 +1,88 @@
+import QtQuick
+import QtQuick.Controls
+import Quickshell
+import qs.Common
+import qs.Modals.Spotlight
+
+Popup {
+    id: root
+
+    property var appLauncher: null
+    property var parentHandler: null
+    property var searchField: null
+
+    function show(x, y, app, fromKeyboard) {
+        fromKeyboard = fromKeyboard || false;
+        menuContent.currentApp = app;
+        
+        root.x = x + 4;
+        root.y = y + 4;
+        
+        menuContent.selectedMenuIndex = fromKeyboard ? 0 : -1;
+        menuContent.keyboardNavigation = true;
+        
+        if (parentHandler) {
+            parentHandler.enabled = false;
+        }
+        
+        open();
+    }
+    
+    onOpened: {
+        Qt.callLater(() => {
+            menuContent.keyboardHandler.forceActiveFocus();
+        });
+    }
+
+    function hide() {
+        if (parentHandler) {
+            parentHandler.enabled = true;
+        }
+        close();
+    }
+
+    width: menuContent.implicitWidth
+    height: menuContent.implicitHeight
+    padding: 0
+    closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutside
+    modal: true
+    dim: false
+    background: Item {}
+
+    onClosed: {
+        if (parentHandler) {
+            parentHandler.enabled = true;
+        }
+        if (searchField) {
+            Qt.callLater(() => {
+                searchField.forceActiveFocus();
+            });
+        }
+    }
+
+    enter: Transition {
+        NumberAnimation {
+            property: "opacity"
+            from: 0
+            to: 1
+            duration: Theme.shortDuration
+            easing.type: Theme.emphasizedEasing
+        }
+    }
+
+    exit: Transition {
+        NumberAnimation {
+            property: "opacity"
+            from: 1
+            to: 0
+            duration: Theme.shortDuration
+            easing.type: Theme.emphasizedEasing
+        }
+    }
+
+    contentItem: SpotlightContextMenuContent {
+        id: menuContent
+        appLauncher: root.appLauncher
+        onHideRequested: root.hide()
+    }
+}

quickshell/Modals/Spotlight/SpotlightResults.qml

@@ -8,7 +8,8 @@ Rectangle {
     id: resultsContainer
 
     property var appLauncher: null
-    property var contextMenu: null
+    
+    signal itemRightClicked(int index, var modelData, real mouseX, real mouseY)
 
     function resetScroll() {
         resultsList.contentY = 0
@@ -17,6 +18,24 @@ Rectangle {
         }
     }
 
+    function getSelectedItemPosition() {
+        if (!appLauncher) return { x: 0, y: 0 };
+        
+        const selectedIndex = appLauncher.selectedIndex;
+        if (appLauncher.viewMode === "list") {
+            const itemY = selectedIndex * (resultsList.itemHeight + resultsList.itemSpacing) - resultsList.contentY;
+            return { x: resultsList.width / 2, y: itemY + resultsList.itemHeight / 2 };
+        } else if (gridLoader.item) {
+            const grid = gridLoader.item;
+            const row = Math.floor(selectedIndex / grid.actualColumns);
+            const col = selectedIndex % grid.actualColumns;
+            const itemX = col * grid.cellWidth + grid.leftMargin + grid.cellWidth / 2;
+            const itemY = row * grid.cellHeight - grid.contentY + grid.cellHeight / 2;
+            return { x: itemX, y: itemY };
+        }
+        return { x: 0, y: 0 };
+    }
+
     radius: Theme.cornerRadius
     color: "transparent"
     clip: true
@@ -67,9 +86,8 @@ Rectangle {
                            appLauncher.launchApp(modelData)
                        }
         onItemRightClicked: (index, modelData, mouseX, mouseY) => {
-                                if (contextMenu)
-                                contextMenu.show(mouseX, mouseY, modelData)
-                            }
+            resultsContainer.itemRightClicked(index, modelData, mouseX, mouseY);
+        }
         onKeyboardNavigationReset: () => {
                                        if (appLauncher)
                                        appLauncher.keyboardNavigationActive = false
@@ -87,8 +105,7 @@ Rectangle {
             iconUnicodeScale: 0.8
             onItemClicked: (idx, modelData) => resultsList.itemClicked(idx, modelData)
             onItemRightClicked: (idx, modelData, mouseX, mouseY) => {
-                const modalPos = resultsContainer.parent.mapFromItem(null, mouseX, mouseY)
-                resultsList.itemRightClicked(idx, modelData, modalPos.x, modalPos.y)
+                resultsList.itemRightClicked(idx, modelData, mouseX, mouseY)
             }
             onKeyboardNavigationReset: resultsList.keyboardNavigationReset
         }
@@ -103,6 +120,14 @@ Rectangle {
         anchors.margins: Theme.spacingS
         visible: appLauncher && appLauncher.viewMode === "grid"
         active: appLauncher && appLauncher.viewMode === "grid"
+        asynchronous: false
+        
+        onLoaded: {
+            if (item) {
+                item.appLauncher = Qt.binding(() => resultsContainer.appLauncher);
+            }
+        }
+        
         onWidthChanged: {
             if (visible && Math.abs(width - _lastWidth) > 1) {
                 _lastWidth = width
@@ -116,6 +141,8 @@ Rectangle {
             DankGridView {
                 id: resultsGrid
 
+                property var appLauncher: null
+
                 property int currentIndex: appLauncher ? appLauncher.selectedIndex : -1
                 property int columns: appLauncher ? appLauncher.gridColumns : 4
                 property bool adaptiveColumns: false
@@ -167,9 +194,8 @@ Rectangle {
                                    appLauncher.launchApp(modelData)
                                }
                 onItemRightClicked: (index, modelData, mouseX, mouseY) => {
-                                        if (contextMenu)
-                                        contextMenu.show(mouseX, mouseY, modelData)
-                                    }
+                    resultsContainer.itemRightClicked(index, modelData, mouseX, mouseY);
+                }
                 onKeyboardNavigationReset: () => {
                                                if (appLauncher)
                                                appLauncher.keyboardNavigationActive = false
@@ -188,8 +214,7 @@ Rectangle {
                     currentIndex: resultsGrid.currentIndex
                     onItemClicked: (idx, modelData) => resultsGrid.itemClicked(idx, modelData)
                     onItemRightClicked: (idx, modelData, mouseX, mouseY) => {
-                        const modalPos = resultsContainer.parent.mapFromItem(null, mouseX, mouseY)
-                        resultsGrid.itemRightClicked(idx, modelData, modalPos.x, modalPos.y)
+                        resultsGrid.itemRightClicked(idx, modelData, mouseX, mouseY)
                     }
                     onKeyboardNavigationReset: resultsGrid.keyboardNavigationReset
                 }

quickshell/Modules/AppDrawer/AppDrawerPopout.qml

@@ -749,7 +749,7 @@ DankPopout {
             }
 
             Rectangle {
-                visible: SessionService.hasPrimeRun
+                visible: SessionService.nvidiaCommand
                 width: parent.width - Theme.spacingS * 2
                 height: 5
                 anchors.horizontalCenter: parent.horizontalCenter
@@ -764,11 +764,11 @@ DankPopout {
             }
 
             Rectangle {
-                visible: SessionService.hasPrimeRun
+                visible: SessionService.nvidiaCommand
                 width: parent.width
                 height: 32
                 radius: Theme.cornerRadius
-                color: primeRunMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
+                color: nvidiaMouseArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
 
                 Row {
                     anchors.left: parent.left
@@ -794,7 +794,7 @@ DankPopout {
                 }
 
                 MouseArea {
-                    id: primeRunMouseArea
+                    id: nvidiaMouseArea
 
                     anchors.fill: parent
                     hoverEnabled: true

quickshell/Modules/Dock/DockContextMenu.qml

@@ -356,7 +356,7 @@ PanelWindow {
                     if (!root.desktopEntry?.actions || root.desktopEntry.actions.length === 0) {
                         return false
                     }
-                    return !root.hidePin || (!root.isDmsWindow && root.desktopEntry && SessionService.hasPrimeRun)
+                    return !root.hidePin || (!root.isDmsWindow && root.desktopEntry && SessionService.nvidiaCommand)
                 }
                 width: parent.width
                 height: 1
@@ -405,10 +405,10 @@ PanelWindow {
 
             Rectangle {
                 visible: {
-                    const hasPrimeRun = !root.isDmsWindow && root.desktopEntry && SessionService.hasPrimeRun
+                    const hasNvidia = !root.isDmsWindow && root.desktopEntry && SessionService.nvidiaCommand
                     const hasWindow = root.appData && (root.appData.type === "window" || (root.appData.type === "grouped" && root.appData.windowCount > 0))
                     const hasPinOption = !root.hidePin
-                    const hasContentAbove = hasPinOption || hasPrimeRun
+                    const hasContentAbove = hasPinOption || hasNvidia
                     return hasContentAbove && hasWindow
                 }
                 width: parent.width
@@ -417,11 +417,11 @@ PanelWindow {
             }
 
             Rectangle {
-                visible: !root.isDmsWindow && root.desktopEntry && SessionService.hasPrimeRun
+                visible: !root.isDmsWindow && root.desktopEntry && SessionService.nvidiaCommand
                 width: parent.width
                 height: 28
                 radius: Theme.cornerRadius
-                color: primeRunArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
+                color: nvidiaArea.containsMouse ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.12) : "transparent"
 
                 StyledText {
                     anchors.left: parent.left
@@ -438,7 +438,7 @@ PanelWindow {
                 }
 
                 MouseArea {
-                    id: primeRunArea
+                    id: nvidiaArea
                     anchors.fill: parent
                     hoverEnabled: true
                     cursorShape: Qt.PointingHandCursor

quickshell/Modules/WorkspaceOverlays/NiriOverviewOverlay.qml

@@ -235,6 +235,7 @@ Scope {
                         id: spotlightContent
                         anchors.fill: parent
                         anchors.margins: 0
+                        usePopupContextMenu: true
 
                         property var fakeParentModal: QtObject {
                             property bool spotlightOpen: spotlightContainer.visible

quickshell/Services/SessionService.qml

@@ -18,7 +18,7 @@ Singleton {
     property bool inhibitorAvailable: true
     property bool idleInhibited: false
     property string inhibitReason: "Keep system awake"
-    property bool hasPrimeRun: false
+    property string nvidiaCommand: ""
 
     readonly property bool nativeInhibitorAvailable: {
         try {
@@ -109,7 +109,23 @@ Singleton {
         command: ["which", "prime-run"]
 
         onExited: function (exitCode) {
-            hasPrimeRun = (exitCode === 0);
+            if (exitCode === 0) {
+                nvidiaCommand = "prime-run"
+            } else {
+                detectNvidiaOffloadProcess.running = true
+            }
+        }
+    }
+
+    Process {
+        id: detectNvidiaOffloadProcess
+        running: false
+        command: ["which", "nvidia-offload"]
+
+        onExited: function (exitCode) {
+            if (exitCode === 0) {
+                nvidiaCommand = "nvidia-offload"
+            }
         }
     }
 
@@ -145,10 +161,10 @@ Singleton {
         return /[;&|<>()$`\\"']/.test(prefix);
     }
 
-    function launchDesktopEntry(desktopEntry, usePrimeRun) {
+    function launchDesktopEntry(desktopEntry, useNvidia) {
         let cmd = desktopEntry.command;
-        if (usePrimeRun && hasPrimeRun) {
-            cmd = ["prime-run"].concat(cmd);
+        if (useNvidia && nvidiaCommand) {
+            cmd = [nvidiaCommand].concat(cmd);
         }
 
         const userPrefix = SettingsData.launchPrefix?.trim() || "";
@@ -176,10 +192,10 @@ Singleton {
         }
     }
 
-    function launchDesktopAction(desktopEntry, action, usePrimeRun) {
+    function launchDesktopAction(desktopEntry, action, useNvidia) {
         let cmd = action.command;
-        if (usePrimeRun && hasPrimeRun) {
-            cmd = ["prime-run"].concat(cmd);
+        if (useNvidia && nvidiaCommand) {
+            cmd = [nvidiaCommand].concat(cmd);
         }
 
         const userPrefix = SettingsData.launchPrefix?.trim() || "";

quickshell/Widgets/AppLauncherGridDelegate.qml

@@ -95,10 +95,20 @@ Rectangle {
         onClicked: mouse => {
             if (mouse.button === Qt.LeftButton) {
                 root.itemClicked(root.index, root.model)
-            } else if (mouse.button === Qt.RightButton && !root.isPlugin) {
+            }
+        }
+        onPressAndHold: mouse => {
+            if (!root.isPlugin) {
                 const globalPos = mapToItem(null, mouse.x, mouse.y)
                 root.itemRightClicked(root.index, root.model, globalPos.x, globalPos.y)
             }
         }
+        onPressed: mouse => {
+            if (mouse.button === Qt.RightButton && !root.isPlugin) {
+                const globalPos = mapToItem(null, mouse.x, mouse.y)
+                root.itemRightClicked(root.index, root.model, globalPos.x, globalPos.y)
+                mouse.accepted = true
+            }
+        }
     }
 }

quickshell/Widgets/AppLauncherListDelegate.qml

@@ -105,10 +105,20 @@ Rectangle {
         onClicked: mouse => {
             if (mouse.button === Qt.LeftButton) {
                 root.itemClicked(root.index, root.model)
-            } else if (mouse.button === Qt.RightButton && !root.isPlugin) {
+            }
+        }
+        onPressAndHold: mouse => {
+            if (!root.isPlugin) {
                 const globalPos = mapToItem(null, mouse.x, mouse.y)
                 root.itemRightClicked(root.index, root.model, globalPos.x, globalPos.y)
             }
         }
+        onPressed: mouse => {
+            if (mouse.button === Qt.RightButton && !root.isPlugin) {
+                const globalPos = mapToItem(null, mouse.x, mouse.y)
+                root.itemRightClicked(root.index, root.model, globalPos.x, globalPos.y)
+                mouse.accepted = true
+            }
+        }
     }
 }