PyQt5中是否存在检测鼠标或键盘动作后关闭应用的函数？自定义实现无响应问题求助

Hey there! Let's break down why your current code isn't working and get your app to close automatically when any mouse or keyboard action is detected.

What's Wrong with Your Current Code? #

• You only override keyPressEvent for the main window, but this event only fires when the main window itself has focus. If the focus is on a child widget (like a button, input field, etc.), the main window never gets this event.
• You haven't added any handling for mouse actions at all—clicks, moves, nothing!
• That if event.key() check is redundant too; whenever keyPressEvent is triggered, event.key() will always return a valid key code.

Solution 1: Detect Actions Within Your App #

This fixes the issue by capturing events both on the main window and all its child widgets, so no matter where the user interacts, the app will close.

Here's the updated code:

from PyQt5 import QtWidgets, QtCore
from your_ui_file import Ui_MainWindow  # Swap this with your actual UI file import

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setupUi(self)
        
        # Install an event filter on every child widget to catch their events
        for widget in self.findChildren(QtWidgets.QWidget):
            widget.installEventFilter(self)

    def eventFilter(self, obj, event):
        # Catch any key press
        if event.type() == QtCore.QEvent.KeyPress:
            self.close()
            return True
        # Catch mouse clicks, double-clicks, and movement (tweak these as needed)
        elif event.type() in [QtCore.QEvent.MouseButtonPress, 
                              QtCore.QEvent.MouseButtonDblClick,
                              QtCore.QEvent.MouseMove]:
            self.close()
            return True
        # Pass unhandled events through to their normal handlers
        return super().eventFilter(obj, event)

    # Fallback handlers for the main window itself
    def keyPressEvent(self, event):
        self.close()
        super().keyPressEvent(event)

    def mousePressEvent(self, event):
        self.close()
        super().mousePressEvent(event)

if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    w = MainWindow()
    w.showMaximized()
    sys.exit(app.exec_())

How This Works:

1. Event Filters: By adding an event filter to every child widget, we ensure we catch events that would otherwise be trapped by buttons, inputs, etc., instead of reaching the main window.
2. Event Type Checks: We specify exactly which mouse/keyboard events trigger a close—you can add or remove event types here (e.g., remove MouseMove if you only want clicks/key presses to trigger the close).
3. Fallback Handlers: Just to be safe, we keep the main window's own event handlers to catch any events that might slip through the filter.

Solution 2: Detect Global System-Wide Actions #

If you need the app to close even when the user interacts with other apps (not just your own), Qt doesn't have built-in support for this—but we can use the pynput library to set up global hooks.

First, install pynput via pip:

pip install pynput

Then use this code:

from PyQt5 import QtWidgets
from your_ui_file import Ui_MainWindow
from pynput import mouse, keyboard

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setupUi(self)
        
        # Start listening for global mouse/keyboard actions
        self.start_global_listeners()

    def start_global_listeners(self):
        # Set up mouse listener (triggers on move, click, scroll)
        self.mouse_listener = mouse.Listener(
            on_move=self.on_user_action,
            on_click=self.on_user_action,
            on_scroll=self.on_user_action
        )
        self.mouse_listener.start()
        
        # Set up keyboard listener (triggers on press/release)
        self.keyboard_listener = keyboard.Listener(
            on_press=self.on_user_action,
            on_release=self.on_user_action
        )
        self.keyboard_listener.start()

    def on_user_action(self, *args):
        # Close the app and stop listeners to avoid leftover processes
        self.close()
        self.mouse_listener.stop()
        self.keyboard_listener.stop()

    def closeEvent(self, event):
        # Make sure listeners are stopped when the window closes normally
        if hasattr(self, 'mouse_listener'):
            self.mouse_listener.stop()
        if hasattr(self, 'keyboard_listener'):
            self.keyboard_listener.stop()
        event.accept()

if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    w = MainWindow()
    w.showMaximized()
    sys.exit(app.exec_())

Heads Up:

• Global listeners might trigger system permission prompts (especially on macOS and Windows) to access input monitoring—you'll need to grant these permissions for the code to work.

内容的提问来源于stack exchange，提问作者Fernando