Exemple d'icône dans la barre d'état système

Capture d'écran de l'icône de la barre d'état système

Les systèmes d'exploitation modernes disposent généralement d'une zone spéciale sur le bureau, appelée « barre d'état système » ou « zone de notification », où les applications s'exécutant en arrière-plan peuvent afficher des icônes et de courts messages.

Cet exemple se compose d’une seule classe, ` Window`, qui fournit la fenêtre principale de l’application (c’est-à-dire un éditeur pour l’icône de la barre d’état) et l’icône associée.

L'éditeur permet à l'utilisateur de choisir l'icône de son choix ainsi que de définir le type et la durée du message contextuel. L'utilisateur peut également modifier le titre et le corps du message. Enfin, l'éditeur propose une case à cocher permettant de déterminer si l'icône doit effectivement s'afficher dans la barre d'état système ou non.

Définition de la classe de fenêtre

La classe ` Window ` hérite de ` QWidget` :

class Window : public QDialog
{
    Q_OBJECT

public:
    Window();

    void setVisible(bool visible) override;

protected:
    void closeEvent(QCloseEvent *event) override;

private slots:
    void setIcon(int index);
    void iconActivated(QSystemTrayIcon::ActivationReason reason);
    void showMessage();
    void messageClicked();

private:
    void createIconGroupBox();
    void createMessageGroupBox();
    void createActions();
    void createTrayIcon();

    QGroupBox *iconGroupBox;
    QLabel *iconLabel;
    QComboBox *iconComboBox;
    QCheckBox *showIconCheckBox;

    QGroupBox *messageGroupBox;
    QLabel *typeLabel;
    QLabel *durationLabel;
    QLabel *durationWarningLabel;
    QLabel *titleLabel;
    QLabel *bodyLabel;
    QComboBox *typeComboBox;
    QSpinBox *durationSpinBox;
    QLineEdit *titleEdit;
    QTextEdit *bodyEdit;
    QPushButton *showMessageButton;

    QAction *minimizeAction;
    QAction *maximizeAction;
    QAction *restoreAction;
    QAction *quitAction;

    QSystemTrayIcon *trayIcon;
    QMenu *trayIconMenu;
};

Nous implémentons plusieurs slots privés pour répondre aux interactions de l'utilisateur. Les autres fonctions privées ne sont que des fonctions de commodité fournies pour simplifier le constructeur.

L’icône de la barre d’état système est une instance de la classe ` QSystemTrayIcon `. Pour vérifier si une barre d’état système est présente sur le bureau de l’utilisateur, appelez la fonction statique ` QSystemTrayIcon::isSystemTrayAvailable()`. Associé à l’icône, nous fournissons un menu contenant les actions classiques « minimize », « maximize », « restore » et « quit ». Nous réimplémentons la fonction QWidget::setVisible() afin de mettre à jour le menu de l’icône de la barre d’état dès que l’apparence de l’éditeur change, par exemple lors de l’agrandissement ou de la réduction de la fenêtre principale de l’application.

Enfin, nous réimplémentons la fonction closeEvent() de QWidget afin de pouvoir informer l’utilisateur (lors de la fermeture de la fenêtre de l’éditeur) que le programme continuera de s’exécuter dans la barre d’état système jusqu’à ce qu’il sélectionne l’entrée « Quit » dans le menu contextuel de l’icône.

Implémentation de la classe Window

Lors de la construction du widget éditeur, nous créons d’abord les différents éléments de l’éditeur avant de créer l’icône de la barre d’état système proprement dite :

Window::Window()
{
    createIconGroupBox();
    createMessageGroupBox();

    iconLabel->setMinimumWidth(durationLabel->sizeHint().width());

    createActions();
    createTrayIcon();

    connect(showMessageButton, &QAbstractButton::clicked, this, &Window::showMessage);
    connect(showIconCheckBox, &QAbstractButton::toggled, trayIcon, &QSystemTrayIcon::setVisible);
    connect(iconComboBox, &QComboBox::currentIndexChanged,
            this, &Window::setIcon);
    connect(trayIcon, &QSystemTrayIcon::messageClicked, this, &Window::messageClicked);
    connect(trayIcon, &QSystemTrayIcon::activated, this, &Window::iconActivated);

    QVBoxLayout *mainLayout = new QVBoxLayout;
    mainLayout->addWidget(iconGroupBox);
    mainLayout->addWidget(messageGroupBox);
    setLayout(mainLayout);

    iconComboBox->setCurrentIndex(1);
    trayIcon->show();

    setWindowTitle(tr("Systray"));
    resize(400, 300);
}

Nous nous assurons que l’application réagisse aux actions de l’utilisateur en connectant la plupart des widgets d’entrée de l’éditeur (y compris l’icône de la barre d’état système) aux slots privés de l’application. Mais notez la case à cocher « Visibilité » : son signal ` toggled()` est quant à lui connecté à la fonction ` setVisible()` de l’icône.

void Window::setIcon(int index)
{
    QIcon icon = iconComboBox->itemIcon(index);
    trayIcon->setIcon(icon);
    setWindowIcon(icon);

    trayIcon->setToolTip(iconComboBox->itemText(index));
}

Le slot ` setIcon() ` est déclenché chaque fois que l’index actuel dans la liste déroulante des icônes change, c’est-à-dire chaque fois que l’utilisateur choisit une autre icône dans l’éditeur. Notez qu’il est également appelé lorsque l’utilisateur active l’icône de la barre d’état système avec le bouton gauche de la souris, ce qui déclenche le signal ` activated()` de l’icône. Nous reviendrons sur ce signal dans un instant.

La fonction QSystemTrayIcon::setIcon() définit la propriété icon qui contient l’icône de la barre d’état système proprement dite. Sous Windows, la taille de l’icône de la barre d’état système est de 16x16 ; sous X11, la taille recommandée est de 22x22. L’icône sera redimensionnée à la taille appropriée si nécessaire.

Notez que sous X11, en raison d’une limitation de la spécification de la barre d’état système, les clics de souris sur les zones transparentes de l’icône sont propagés vers la barre d’état système. Si ce comportement est inacceptable, nous vous suggérons d’utiliser une icône sans transparence.

void Window::iconActivated(QSystemTrayIcon::ActivationReason reason)
{
    switch (reason) {
    case QSystemTrayIcon::Trigger:
    case QSystemTrayIcon::DoubleClick:
        iconComboBox->setCurrentIndex((iconComboBox->currentIndex() + 1) % iconComboBox->count());
        break;
    case QSystemTrayIcon::MiddleClick:
        showMessage();
        break;
    default:
        ;
    }
}

Chaque fois que l’utilisateur active l’icône de la barre d’état système, celle-ci émet son signal ` activated()` en passant la raison du déclenchement en paramètre. ` QSystemTrayIcon ` fournit l’énumération ` ActivationReason ` pour décrire comment l’icône a été activée.

Dans le constructeur, nous avons connecté le signal ` activated()` de notre icône à notre slot personnalisé ` iconActivated() ` : si l’utilisateur a cliqué sur l’icône avec le bouton gauche de la souris, cette fonction modifie l’image de l’icône en incrémentant l’index actuel de la liste déroulante des icônes, ce qui déclenche le slot ` setIcon() ` comme mentionné ci-dessus. Si l’utilisateur active l’icône à l’aide du bouton central de la souris, cela appelle le slot personnalisé showMessage():

void Window::showMessage()
{
    showIconCheckBox->setChecked(true);
    int selectedIcon = typeComboBox->itemData(typeComboBox->currentIndex()).toInt();
    QSystemTrayIcon::MessageIcon msgIcon = QSystemTrayIcon::MessageIcon(selectedIcon);

    if (selectedIcon == -1) { // custom icon
        QIcon icon(iconComboBox->itemIcon(iconComboBox->currentIndex()));
        trayIcon->showMessage(titleEdit->text(), bodyEdit->toPlainText(), icon,
                          durationSpinBox->value() * 1000);
    } else {
        trayIcon->showMessage(titleEdit->text(), bodyEdit->toPlainText(), msgIcon,
                          durationSpinBox->value() * 1000);
    }
}

Lorsque le slot showMessage() est déclenché, nous récupérons d’abord l’icône du message en fonction du type de message actuellement sélectionné. L’énumération QSystemTrayIcon::MessageIcon décrit l’icône qui s’affiche lorsqu’un message en bulle est affiché. Ensuite, nous appelons la fonction showMessage() de QSystemTrayIcon pour afficher le message avec son titre, son corps et son icône pendant la durée spécifiée en millisecondes.

Remarque pour les utilisateurs de macOS : le système de notification Growl doit être installé pour que la fonction QSystemTrayIcon::showMessage() puisse afficher des messages.

QSystemTrayIcon Il existe également le signal correspondant, messageClicked(), qui est émis lorsque l'utilisateur clique sur un message affiché par showMessage().

void Window::messageClicked()
{
    QMessageBox::information(nullptr, tr("Systray"),
                             tr("Sorry, I already gave what help I could.\n"
                                "Maybe you should try asking a human?"));
}

Dans le constructeur, nous avons connecté le signal messageClicked() à notre slot personnalisé messageClicked() qui affiche simplement un message à l’aide de la classe QMessageBox.

QMessageBox fournit une boîte de dialogue modale contenant un message court, une icône et des boutons dont la disposition dépend du style actuel. Elle prend en charge quatre niveaux de gravité : « Question », « Information », « Avertissement » et « Critique ». La manière la plus simple d’afficher une boîte de message dans Qt consiste à appeler l’une des fonctions statiques associées, par exemple QMessageBox::information().

Comme nous l’avons mentionné précédemment, nous réimplémentons quelques fonctions virtuelles de ` QWidget` :

void Window::setVisible(bool visible)
{
    minimizeAction->setEnabled(visible);
    maximizeAction->setEnabled(!isMaximized());
    restoreAction->setEnabled(isMaximized() || !visible);
    QDialog::setVisible(visible);
}

Notre réimplémentation de la fonction ` QWidget::setVisible()` met à jour le menu de l’icône de la barre d’état dès que l’apparence de l’éditeur change, par exemple lors de l’agrandissement ou de la réduction de la fenêtre principale de l’application, avant d’appeler l’implémentation de la classe parente.

void Window::closeEvent(QCloseEvent *event)
{
    if (!event->spontaneous() || !isVisible())
        return;
    if (trayIcon->isVisible()) {
        QMessageBox::information(this, tr("Systray"),
                                 tr("The program will keep running in the "
                                    "system tray. To terminate the program, "
                                    "choose <b>Quit</b> in the context menu "
                                    "of the system tray entry."));
        hide();
        event->ignore();
    }
}

Nous avons réimplémenté le gestionnaire d’événements ` QWidget::closeEvent()` pour recevoir les événements de fermeture des widgets, affichant le message ci-dessus aux utilisateurs lorsqu’ils ferment la fenêtre de l’éditeur. Nous devons éviter d’afficher ce message et d’accepter l’événement de fermeture lorsque l’utilisateur a réellement l’intention de quitter l’application : c’est-à-dire lorsqu’il a cliqué sur « Quitter » dans la barre de menus ou dans le menu contextuel de l’icône de la barre d’état, ou encore lorsqu’il a appuyé sur le raccourci Commande+Q sous macOS.

En plus des fonctions et des slots évoqués ci-dessus, nous avons également implémenté plusieurs fonctions pratiques pour simplifier le constructeur : createIconGroupBox(), createMessageGroupBox(), createActions() et createTrayIcon(). Consultez le fichier desktop/systray/window.cpp pour plus de détails.

Exemple de projet sur code.qt.io