Absolutely, this is totally achievable without disrupting the default close button's behavior—you just need to handle your custom button's click event separately and set up the system tray icon properly. Here's a step-by-step solution tailored to your Qt Designer-generated UI:

Step 1: Set Up the System Tray Icon #

First, create a QSystemTrayIcon instance, add a context menu (for restoring the window or quitting), and connect its signals to handle user interactions.

Step 2: Link Your Custom Button to Minimize Logic #

Connect your button's clicked signal to a function that hides the main window and shows the tray icon—this keeps the default close button untouched.

Step 3: Ensure Proper Close Behavior #

To make sure clicking the window's default close button quits the app (while keeping it running when minimized to tray), we'll adjust the app's quit policy and add a minimal closeEvent override (only to clean up and exit properly).

Full Code Example #

Assuming your Qt Designer UI is saved as mainwindow.ui and has a button named pushButton (adjust the button name to match your actual UI):

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QSystemTrayIcon, 
                             QMenu, QAction)
from PyQt5.QtGui import QIcon
# Import your Qt Designer-generated UI class
from ui_mainwindow import Ui_MainWindow

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        
        # Initialize system tray functionality
        self.init_system_tray()
        
        # Connect custom button to minimize-to-tray function
        self.pushButton.clicked.connect(self.minimize_to_tray)

    def init_system_tray(self):
        # Create tray icon (replace "icon.png" with your own icon path)
        self.tray_icon = QSystemTrayIcon(QIcon("icon.png"), self)
        
        # Build context menu for the tray icon
        tray_menu = QMenu()
        
        # Action to restore the main window
        restore_action = QAction("Restore Window", self)
        restore_action.triggered.connect(self.restore_window)
        
        # Action to quit the application
        quit_action = QAction("Quit", self)
        quit_action.triggered.connect(self.quit_app)
        
        tray_menu.addAction(restore_action)
        tray_menu.addAction(quit_action)
        
        self.tray_icon.setContextMenu(tray_menu)
        
        # Optional: Restore window when tray icon is double-clicked
        self.tray_icon.activated.connect(self.on_tray_activated)

    def minimize_to_tray(self):
        # Hide the main window
        self.hide()
        # Show the tray icon
        self.tray_icon.show()
        # Optional: Show a brief notification
        self.tray_icon.showMessage(
            "Minimized", 
            "Window moved to system tray", 
            QSystemTrayIcon.Information, 
            2000
        )

    def restore_window(self):
        # Show and bring the main window to the front
        self.show()
        self.raise_()
        self.activateWindow()
        # Hide the tray icon once window is restored
        self.tray_icon.hide()

    def on_tray_activated(self, reason):
        # Restore window if tray icon is double-clicked
        if reason == QSystemTrayIcon.DoubleClick:
            self.restore_window()

    def quit_app(self):
        # Clean up tray icon and exit the app properly
        self.tray_icon.hide()
        QApplication.instance().quit()

    def closeEvent(self, event):
        # Ensure clicking the default close button quits the app
        self.quit_app()
        event.accept()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    # Prevent app from quitting automatically when main window is hidden
    app.setQuitOnLastWindowClosed(False)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

Key Details: #

• Unmodified Default Close Button: The closeEvent override only ensures the app exits cleanly when the default close button is pressed—it doesn't change the button's core behavior.
• Isolated Custom Button Logic: The minimize_to_tray function only hides the window and shows the tray icon, leaving the close button's functionality intact.
• User-Friendly Tray Interactions: The context menu and double-click restore make the tray icon intuitive to use.

This setup exactly matches your requirements: clicking the custom button minimizes to tray, while clicking the window's close button closes the app normally.

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