QApplication Class

Documentation des fonctions membres

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

Initialise le système de fenêtrage et crée un objet d'application à l'aide des arguments de ligne de commande indiqués dans argc sur 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 instancié avant tout paint devices (y compris les widgets, les pixmaps, les bitmaps, etc.).

Tous les programmes Qt prennent automatiquement en charge 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 disposez de styles supplémentaires sous forme de plugins, ceux-ci seront disponibles via 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: équivaut à l’option ci-dessus.
• -stylesheet= feuille de style, définit la feuille de style de l'application. La valeur doit être un chemin d'accès à un fichier contenant la feuille de style.

  Remarque : les URLrelatives dans le fichier de feuille de style sont relatives au chemin d’accès de ce fichier.

• -stylesheet feuille-de-style: correspond à ce qui est indiqué ci-dessus.
• -widgetcount, affiche un message de débogage à la fin indiquant le nombre de widgets non détruits et le nombre maximal de widgets ayant existé simultanément
• -reverse, définit le sens de mise en page de l'application sur Qt::RightToLeft
• -qmljsdebugger=, active le débogueur QML/JS sur un port spécifié. La valeur doit être au format port:1234[,block], où block est facultatif et force l'application à attendre qu'un débogueur s'y connecte.

Voir également QCoreApplication::arguments().

[virtual noexcept] QApplication::~QApplication()

Libère toutes les ressources système liées aux fenêtres qui avaient été allouées par cette application. Définit la variable globale qApp sur nullptr.

[static slot] void QApplication::aboutQt()

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

Cette fonction est utile pour l'intégrer dans le menu « Help » d'une application, comme le montre l'exemple 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 niveau supérieur, sous-classe de ` QDialog `, dont le paramètre `modal` du constructeur est défini sur `true`. Un widget modal doit être fermé avant que l'utilisateur puisse poursuivre l'exécution d'autres parties du programme.

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

Voir également ` activePopupWidget()` et ` topLevelWidgets()`.

[static] QWidget *QApplication::activePopupWidget()

Renvoie le widget contextuel actif.

Un widget contextuel est un widget spécial de niveau supérieur qui active l'indicateur « Qt::WType_Popup », comme par exemple le widget QMenu. Lorsque l'application ouvre un widget contextuel, tous les événements sont envoyés vers ce widget. Les widgets normaux et modaux ne sont pas accessibles tant que le widget contextuel n'est pas fermé.

Seuls d'autres widgets contextuels peuvent être ouverts lorsqu'un widget contextuel est affiché. Les widgets contextuels sont organisés en pile. Cette fonction renvoie le widget contextuel actif situé au sommet de la pile.

Voir également activeModalWidget() et topLevelWidgets().

[static] QWidget *QApplication::activeWindow()

Renvoie la fenêtre de niveau supérieur de l'application sur laquelle se trouve le focus du clavier, ou ` nullptr ` si aucune fenêtre d'application n'a le focus. La fonction `activeWindow()` peut renvoyer une valeur même s'il n'y a pas de ` focusWidget()` (), par exemple si aucun widget de cette fenêtre n'accepte les événements clavier.

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

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

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

Actuellement, cette fonction n'a aucun effet sous Qt pour Linux embarqué.

Sous macOS, cela fonctionne davantage au niveau de l’application et provoque le rebond de l’icône de l’application dans le Dock.

Sous Windows, cela provoque le clignotement temporaire de l’entrée de la fenêtre dans la barre des tâches. 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, cela entraîne le marquage de la fenêtre comme « nécessitant une attention particulière » ; pour que cela fonctionne, la fenêtre ne doit pas être masquée (c'est-à-dire qu'aucune fonction hide() ne doit être appelée sur celle-ci, mais qu'elle doit rester visible d'une manière ou d'une autre).

[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 également topLevelWidgets() et QWidget::isVisible().

[static] void QApplication::beep()

Fait retentir la sonnerie en utilisant le volume et le son par défaut. Cette fonction n' est pas disponible dans Qt pour Linux embarqué.

[static slot] void QApplication::closeAllWindows()

Ferme toutes les fenêtres de niveau supérieur.

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 refuse l’événement de fermeture. L’application se ferme lorsque la dernière fenêtre a été fermée avec succès, sauf si quitOnLastWindowClosed est défini sur false. Pour déclencher la fermeture de l’application à partir, par exemple, d’un menu, utilisez QCoreApplication::quit() à la place 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 d'événements principale et attend que la fonction ` exit()` soit appelée, puis renvoie la valeur qui a été définie dans ` exit()` (qui est égale à 0 si ` exit()` est appelée via ` quit()`).

Il est nécessaire d’appeler cette fonction pour lancer la gestion des événements. La boucle d’événements principale reçoit les événements du système de fenêtrage et les distribue aux widgets de l’application.

En règle générale, aucune interaction avec l’utilisateur ne peut avoir lieu avant l’appel à `exec()`. À titre d’exception, les widgets modaux tels que ` QMessageBox ` peuvent être utilisés avant l’appel à `exec()`, car les widgets modaux appellent eux-mêmes `exec()` pour lancer une boucle d’événements locale.

Pour que votre application effectue un traitement en veille, c'est-à-dire qu'elle exécute une fonction spécifique lorsqu'il n'y a pas d'événements en attente, utilisez un QChronoTimer avec un délai d'expiration de 0 ns. Des schémas de traitement en veille plus avancés peuvent être mis en œuvre à l'aide de processEvents().

Nous vous recommandons de connecter le code de nettoyage au signal aboutToQuit(), plutôt que de l’intégrer à la fonction main() de votre application. En effet, sur certaines plateformes, l’appel à QApplication::exec() peut ne pas renvoyer de résultat. Par exemple, sous 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’ y a donc aucune garantie que l’application ait 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 à `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 détient le focus clavier passe de l'état « old » à l'état « now », c'est-à-dire lorsque l'utilisateur appuie sur la touche Tab, clique dans un widget ou change de fenêtre active. Les états « old » et « now » peuvent tous deux être « nullptr ».

Le signal est émis une fois que les deux widgets ont été informés du changement via QFocusEvent.

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

[static] QWidget *QApplication::focusWidget()

Renvoie le widget de l'application sur lequel se trouve le focus du clavier, ou ` nullptr ` si aucun widget de cette application n'a le focus.

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

[static] QFont QApplication::font()

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

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

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

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

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

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

Renvoie la police utilisée pour les widgets de l'className donné.

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

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

Renvoie « true » si l'option « effect » est activée ; sinon, renvoie « false ».

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

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

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

Réimplémente : QGuiApplication::notify(QObject *object, QEvent *event).

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

Si un objet ` widget ` est passé en paramètre, 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'existe pas de palette spécifique pour certains types de widgets, mais il existe une exception notable : le menu contextuel sous Windows, si l'utilisateur a défini une couleur d'arrière-plan spécifique 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'className donné.

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

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

Active l'effet d'interface utilisateur « effect » si la valeur de ` enable ` est « true » ; dans le cas contraire, l'effet ne sera pas utilisé.

Voir également isEffectEnabled(), Qt::UIEffect et setDesktopSettingsAware().

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

Modifie la police par défaut de l'application pour « font ». Si l'on passe « className », la modification ne s'applique qu'aux classes héritant 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êtrage. Elle peut varier en fonction à la fois de la version du système de fenêtrage et des paramètres régionaux. Cette fonction vous permet de remplacer la police par défaut ; toutefois, cela peut s’avérer déconseillé car, par exemple, certains paramètres régionaux nécessitent des polices très grandes pour prendre en charge leurs caractères spéciaux.

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

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

Modifie la palette de l'application pour qu'elle utilise « palette ».

Si className est passé, la modification s'applique uniquement aux widgets héritant de className (comme indiqué par QObject::inherits()). Si className est laissé à 0, la modification affecte tous les widgets, remplaçant ainsi toute palette spécifique à une classe précédemment définie.

La palette peut être modifiée en fonction du style d'interface graphique actuel via 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 sur style. La propriété de l'objet de style est transférée à QApplication; ainsi, QApplication supprimera l'objet de style à la fermeture 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"));

Lors du changement de style de l’application, la palette de couleurs est réinitialisé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 entièrement conformes au guide de style.

Définir le style avant qu’une palette n’ait été définie, c’est-à-dire avant de créer ` QApplication`, entraînera l’utilisation de ` QStyle::standardPalette()` par l’application pour la palette.

Voir également style(), QStyle, setPalette() et desktopSettingsAware().

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

Demande un objet ` QStyle ` pour ` style ` auprès de ` QStyleFactory`.

La chaîne doit correspondre à l'une des valeurs de QStyleFactory::keys(), généralement « windows », « windowsvista », « fusion » ou « macos ». Les noms de style ne sont pas sensibles à la casse.

Renvoie nullptr si un style inconnu est passé ; sinon, l’objet QStyle renvoyé est défini comme 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 niveau supérieur situé à l'point indiquée ; renvoie « nullptr » si ce widget n'existe pas.

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

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

[static] QWidgetList QApplication::topLevelWidgets()

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

Exemple :

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

Voir également allWidgets(), QWidget::isWindow() et QWidget::isHidden().

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

Renvoie le widget situé à 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 également QCursor::pos(), QWidget::grabMouse() et QWidget::grabKeyboard().

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

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