QApplication Class

Documentation des fonctions membres

QApplication::QApplication(int &argc, char **argv)

Initialise le système de fenêtres et construit un objet d'application avec les arguments de la ligne de commande argc dans argv.

Le pointeur global qApp fait référence à cet objet d'application. Un seul objet d'application doit être créé.

Cet objet d'application doit être construit avant tout paint devices (y compris les widgets, pixmaps, bitmaps, etc.).

Tous les programmes Qt supportent automatiquement les options de ligne de commande suivantes :

• -style= style, définit le style de l'interface graphique de l'application. Les valeurs possibles dépendent de la configuration de votre système. Si vous avez compilé Qt avec des styles supplémentaires ou si vous avez des styles supplémentaires en tant que plugins, ceux-ci seront disponibles pour l'option de ligne de commande -style. Vous pouvez également définir le style pour toutes les applications Qt en définissant la variable d'environnement QT_STYLE_OVERRIDE.
• -style style, est identique à la liste ci-dessus.
• -stylesheet= stylesheet, définit la feuille de style de l'application. La valeur doit être un chemin vers un fichier contenant la feuille de style.

  Remarque : les URL relatives dans le fichier de feuille de style sont relatives au chemin d'accès du fichier de feuille de style.

• -stylesheet feuille de style, est identique à la liste ci-dessus.
• -widgetcount, affiche un message de débogage à la fin de l'exécution concernant le nombre de widgets non détruits et le nombre maximum de widgets existants en même temps.
• -reverse, définit la direction de la mise en page de l'application à Qt::RightToLeft
• -qmljsdebugger=, active le débogueur QML/JS avec un port spécifié. La valeur doit être du format port:1234[,block], où block est optionnel et fera attendre l'application jusqu'à ce qu'un débogueur se connecte à elle.

Voir aussi QCoreApplication::arguments().

[virtual noexcept] QApplication::~QApplication()

Nettoie toutes les ressources du système de fenêtres qui ont été allouées par cette application. Définit la variable globale qApp à nullptr.

[static slot] void QApplication::aboutQt()

Affiche une boîte de message simple sur Qt. Le message inclut le numéro de version de Qt utilisé par l'application.

Il est utile de l'inclure dans le menu Help d'une application, comme le montre l'exemple des menus.

Cette fonction est un slot de commodité pour QMessageBox::aboutQt().

[static] QWidget *QApplication::activeModalWidget()

Renvoie le widget modal actif.

Un widget modal est un widget spécial de premier niveau qui est une sous-classe de QDialog et qui spécifie que le paramètre modal du constructeur est vrai. Un widget modal doit être fermé avant que l'utilisateur puisse poursuivre d'autres parties du programme.

Les widgets modaux sont organisés en pile. Cette fonction renvoie le widget modal actif au sommet de la pile.

Voir également activePopupWidget() et topLevelWidgets().

[static] QWidget *QApplication::activePopupWidget()

Renvoie le widget popup actif.

Un widget popup est un widget spécial de haut niveau qui active le drapeau du widget Qt::WType_Popup, par exemple le widget QMenu. Lorsque l'application ouvre un widget popup, tous les événements sont envoyés au popup. Les widgets normaux et les widgets modaux ne sont pas accessibles avant la fermeture du widget popup.

Seuls d'autres widgets popup peuvent être ouverts lorsqu'un widget popup est affiché. Les fenêtres contextuelles sont organisées en pile. Cette fonction renvoie le widget popup actif au sommet de la pile.

Voir aussi activeModalWidget() et topLevelWidgets().

[static] QWidget *QApplication::activeWindow()

Renvoie la fenêtre de premier niveau de l'application qui a le focus sur l'entrée clavier, ou nullptr si aucune fenêtre de l'application n'a le focus. Il peut y avoir une activeWindow() même s'il n'y a pas de focusWidget(), par exemple si aucun widget dans cette fenêtre n'accepte les événements de touche.

Voir également QWidget::setFocus(), QWidget::hasFocus() et focusWidget().

[static] void QApplication::alert(QWidget *widget, int msec = 0)

Provoque l'affichage d'une alerte sur widget si la fenêtre n'est pas la fenêtre active. L'alerte est affichée pendant msec millisecondes. Si msec est égal à zéro (valeur par défaut), l'alerte est affichée indéfiniment jusqu'à ce que la fenêtre redevienne active.

Actuellement, cette fonction n'a aucun effet sur Qt for Embedded Linux.

Sous macOS, elle fonctionne plutôt au niveau de l'application et fait rebondir l'icône de l'application dans le dock.

Sous Windows, l'entrée de la barre des tâches de la fenêtre clignote pendant un certain temps. Si msec est égal à zéro, le clignotement s'arrête et l'entrée de la barre des tâches prend une couleur différente (actuellement orange).

Sous X11, la fenêtre sera marquée comme "exigeant de l'attention". La fenêtre ne doit pas être cachée (c'est-à-dire qu'elle ne doit pas faire l'objet d'un appel à hide(), mais être visible d'une manière ou d'une autre) pour que cela fonctionne.

[static] QWidgetList QApplication::allWidgets()

Renvoie une liste de tous les widgets de l'application.

La liste est vide (QList::isEmpty()) s'il n'y a pas de widgets.

Exemple :

void updateAllWidgets()
{
    const QWidgetList allWidgets = QApplication::allWidgets();
    for (QWidget *widget : allWidgets)
        widget->update();
}

Voir aussi topLevelWidgets() et QWidget::isVisible().

[static] void QApplication::beep()

Sonne la cloche, en utilisant le volume et le son par défaut. Cette fonction n'est pas disponible dans Qt for Embedded Linux.

[static slot] void QApplication::closeAllWindows()

Ferme toutes les fenêtres de premier niveau.

Cette fonction est particulièrement utile pour les applications comportant de nombreuses fenêtres de premier niveau.

Les fenêtres sont fermées dans un ordre aléatoire, jusqu'à ce qu'une fenêtre n'accepte pas l'événement de fermeture. L'application se termine lorsque la dernière fenêtre a été fermée avec succès, à moins que quitOnLastWindowClosed ne soit défini comme faux. Pour déclencher la fermeture de l'application à partir d'un menu, par exemple, utilisez QCoreApplication::quit() au lieu de cette fonction.

Voir également quitOnLastWindowClosed, lastWindowClosed(), QWidget::close(), QWidget::closeEvent(), QCoreApplication::quit(), topLevelWidgets() et QWidget::isWindow().

[override virtual protected] bool QApplication::event(QEvent *e)

Réimplémente : QGuiApplication::event(QEvent *e).

[static] int QApplication::exec()

Entre dans la boucle événementielle principale et attend que exit() soit appelé, puis renvoie la valeur qui a été définie à exit() (qui est 0 si exit() est appelé via quit()).

Il est nécessaire d'appeler cette fonction pour commencer à gérer les événements. La boucle d'événements principale reçoit des événements du système de fenêtres et les distribue aux widgets de l'application.

En général, aucune interaction avec l'utilisateur ne peut avoir lieu avant l'appel à exec(). Dans un cas particulier, les widgets modaux tels que QMessageBox peuvent être utilisés avant d'appeler exec(), car les widgets modaux appellent exec() pour démarrer une boucle d'événements locale.

Pour que votre application effectue un traitement au ralenti, c'est-à-dire qu'elle exécute une fonction spéciale chaque fois qu'il n'y a pas d'événements en attente, utilisez un QChronoTimer avec un délai d'attente de 0ns. Des schémas de traitement au ralenti plus avancés peuvent être réalisés en utilisant processEvents().

Nous vous recommandons de connecter le code de nettoyage au signal aboutToQuit(), plutôt que de le placer dans la fonction main() de votre application. En effet, sur certaines plateformes, l'appel à QApplication::exec() peut ne pas être retourné. Par exemple, sur la plate-forme Windows, lorsque l'utilisateur se déconnecte, le système met fin au processus après que Qt a fermé toutes les fenêtres de niveau supérieur. Il n' est donc pas garanti que l'application aura le temps de sortir de sa boucle d'événements et d'exécuter le code à la fin de la fonction main(), après l'appel de QApplication::exec().

Voir également quitOnLastWindowClosed, QCoreApplication::quit(), QCoreApplication::exit(), QCoreApplication::processEvents() et QCoreApplication::exec().

[signal] void QApplication::focusChanged(QWidget *old, QWidget *now)

Ce signal est émis lorsque le widget qui a le focus clavier est passé de old à now, c'est-à-dire parce que l'utilisateur a appuyé sur la touche de tabulation, cliqué dans un widget ou changé de fenêtre active. Les deux old et now peuvent être nullptr.

Le signal est émis après que les deux widgets ont été informés du changement par l'intermédiaire de QFocusEvent.

Voir également QWidget::setFocus(), QWidget::clearFocus() et Qt::FocusReason.

[static] QWidget *QApplication::focusWidget()

Renvoie le widget de l'application qui a le focus sur la saisie clavier, ou nullptr si aucun widget de cette application n'a le focus.

Voir aussi QWidget::setFocus(), QWidget::hasFocus(), activeWindow() et focusChanged().

[static] QFont QApplication::font()

Renvoie la police par défaut de l'application.

Voir aussi setFont(), fontMetrics() et QWidget::font().

[static] QFont QApplication::font(const QWidget *widget)

Renvoie la police par défaut de la classe widget. Si aucune police par défaut n'a été enregistrée pour la classe widget, elle renvoie la police par défaut de la superclasse enregistrée la plus proche.

Voir aussi fontMetrics(), setFont() et QWidget::setFont().

[static] QFont QApplication::font(const char *className)

Renvoie la police de caractères pour les widgets de l'adresse className.

Voir aussi setFont() et QWidget::font().

[static] bool QApplication::isEffectEnabled(Qt::UIEffect effect)

Renvoie true si effect est activé, sinon false.

Par défaut, Qt essaiera d'utiliser les paramètres du bureau. Pour empêcher cela, appelez setDesktopSettingsAware(false).

Voir également setEffectEnabled() et Qt::UIEffect.

[static] Qt::NavigationMode QApplication::navigationMode()

Renvoie le type de navigation de mise au point utilisé par Qt.

Cette fonctionnalité n'est disponible que dans Qt pour Linux embarqué.

Voir aussi setNavigationMode().

[override virtual] bool QApplication::notify(QObject *receiver, QEvent *e)

Réimplémente : QGuiApplication::notify(QObject *objet, QEvent *événement).

[static] QPalette QApplication::palette(const QWidget *widget)

Si une adresse widget est fournie, la palette par défaut de la classe du widget est renvoyée. Il peut s'agir ou non de la palette de l'application. Dans la plupart des cas, il n'y a pas de palette spéciale pour certains types de widgets, mais une exception notable est le menu contextuel sous Windows, si l'utilisateur a défini une couleur d'arrière-plan spéciale pour les menus dans les paramètres d'affichage.

Voir également setPalette() et QWidget::palette().

[static] QPalette QApplication::palette(const char *className)

Renvoie la palette des widgets de l'adresse className.

Voir aussi setPalette() et QWidget::palette().

[static] void QApplication::setEffectEnabled(Qt::UIEffect effect, bool enable = true)

Active l'effet d'interface utilisateur effect si enable est vrai, sinon l'effet ne sera pas utilisé.

Voir aussi isEffectEnabled(), Qt::UIEffect, et setDesktopSettingsAware().

[static] void QApplication::setFont(const QFont &font, const char *className = nullptr)

Change la police par défaut de l'application en font. Si className est fourni, le changement ne s'applique qu'aux classes qui héritent de className (comme indiqué par QObject::inherits()).

Au démarrage de l'application, la police par défaut dépend du système de fenêtres. Elle peut varier en fonction de la version du système de fenêtres et de la langue locale. Cette fonction vous permet de remplacer la police par défaut, mais cela peut être une mauvaise idée car, par exemple, certaines locales ont besoin de polices très grandes pour prendre en charge leurs caractères spéciaux.

Voir également font(), fontMetrics() et QWidget::setFont().

[static] void QApplication::setNavigationMode(Qt::NavigationMode mode)

Définit le type de navigation de focus que Qt doit utiliser pour mode.

Cette fonctionnalité n'est disponible que dans Qt pour Linux embarqué.

Voir également navigationMode().

[static] void QApplication::setPalette(const QPalette &palette, const char *className = nullptr)

Modifie la palette de l'application en palette.

Si className est transmis, le changement ne s'applique qu'aux widgets qui héritent de className (comme indiqué par QObject::inherits()). Si className est laissé à 0, le changement affecte tous les widgets, remplaçant ainsi toutes les palettes spécifiques à une classe définies précédemment.

La palette peut être modifiée en fonction du style d'interface graphique actuel dans QStyle::polish().

Voir également QWidget::setPalette(), palette() et QStyle::polish().

[static] void QApplication::setStyle(QStyle *style)

Définit le style de l'interface graphique de l'application à style. La propriété de l'objet style est transférée à QApplication, de sorte que QApplication supprimera l'objet style à la sortie de l'application ou lorsqu'un nouveau style est défini et que l'ancien style est toujours le parent de l'objet application.

Exemple d'utilisation :

QApplication::setStyle(QStyleFactory::create("Fusion"));

Lorsque l'on change de style d'application, la palette de couleurs est ramenée aux couleurs initiales ou aux valeurs par défaut du système. Cela est nécessaire car certains styles doivent adapter la palette de couleurs pour être totalement conformes au guide de style.

En définissant le style avant qu'une palette n'ait été définie, c'est-à-dire avant de créer QApplication, l'application utilisera QStyle::standardPalette() pour la palette.

Voir aussi style(), QStyle, setPalette(), et desktopSettingsAware().

[static] QStyle *QApplication::setStyle(const QString &style)

Demande un objet QStyle pour style à partir de QStyleFactory.

La chaîne doit être l'une des QStyleFactory::keys(), typiquement l'une des suivantes : "windows", "windowsvista", "fusion" ou "macos". Les noms de style sont insensibles à la casse.

Renvoie nullptr si un style inconnu est transmis, sinon l'objet QStyle renvoyé est défini comme le style d'interface graphique de l'application.

[static] QStyle *QApplication::style()

Renvoie l'objet de style de l'application.

Voir aussi setStyle() et QStyle.

[static] QWidget *QApplication::topLevelAt(const QPoint &point)

Renvoie le widget de premier niveau à l'adresse point; renvoie nullptr s'il n'existe pas de widget de ce type.

[static] QWidget *QApplication::topLevelAt(int x, int y)

Renvoie le widget de niveau supérieur au point (x, y) ; renvoie 0 s'il n'existe pas de widget de ce type.

[static] QWidgetList QApplication::topLevelWidgets()

Renvoie une liste des widgets de premier niveau (fenêtres) de l'application.

Exemple :

void showAllHiddenTopLevelWidgets()
{
    const QWidgetList topLevelWidgets = QApplication::topLevelWidgets();
    for (QWidget *widget : topLevelWidgets) {
        if (widget->isHidden())
            widget->show();
    }
}

Voir aussi allWidgets(), QWidget::isWindow() et QWidget::isHidden().

[static] QWidget *QApplication::widgetAt(const QPoint &point)

Renvoie le widget à la position globale de l'écran point, ou nullptr s'il n'y a pas de widget Qt à cet endroit.

Cette fonction peut être lente.

Voir aussi QCursor::pos(), QWidget::grabMouse(), et QWidget::grabKeyboard().

[static] QWidget *QApplication::widgetAt(int x, int y)

Renvoie le widget à la position globale de l'écran (x, y), ou nullptr s'il n'y a pas de widget Qt à cet endroit.