QGuiApplication Class

Documentation sur les fonctions membres

QGuiApplication::QGuiApplication(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 argc, tels que décrits 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 instancié avant toute paint devices (y compris les pixmaps, bitmaps, etc.).

Options de ligne de commande prises en charge

Tous les programmes Qt prennent automatiquement en charge un ensemble d’options de ligne de commande permettant de modifier la manière dont Qt interagit avec le système de fenêtrage. Certaines de ces options sont également accessibles via des variables d’environnement, qui constituent la méthode privilégiée si l’application peut lancer des sous-processus GUI ou d’autres applications (les variables d’environnement seront héritées par les processus enfants). En cas de doute, utilisez les variables d’environnement.

Les options actuellement prises en charge sont les suivantes :

• -platformplatformName[ :options], spécifie le plugin Qt Platform Abstraction (QPA).

  Remplace la variable d’environnement ` QT_QPA_PLATFORM `.

• -platformpluginpath path: spécifie le chemin d'accès aux plugins de la plateforme.

  Remplace la variable d'environnement « QT_QPA_PLATFORM_PLUGIN_PATH ».

• -platformtheme platformTheme, spécifie le thème de la plateforme.

  Remplace la variable d'environnement « QT_QPA_PLATFORMTHEME ».

• -plugin plugin, spécifie les plugins supplémentaires à charger. Cet argument peut apparaître plusieurs fois.

  Il est concaténé avec les plugins de la variable d’environnement ` QT_QPA_GENERIC_PLUGINS `.

• -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.
• -qwindowgeometry geometry, spécifie la géométrie de la fenêtre principale en utilisant la syntaxe X11. Par exemple : -qwindowgeometry 100x100+50+50
• -qwindowicon, définit l'icône par défaut de la fenêtre
• -qwindowtitle, définit le titre de la première fenêtre
• -reverse, définit le sens de mise en page de l’application sur Qt::RightToLeft. Cette option est destinée à faciliter le débogage et ne doit pas être utilisée en production. La valeur par défaut est automatiquement détectée à partir des paramètres régionaux de l’utilisateur (voir également QLocale::textDirection()).
• -session session, restaure l’application à partir d’une session antérieure.

Les options de ligne de commande standard suivantes sont disponibles pour X11 :

• -display hostname:screen_number, permet de basculer entre les écrans sur X11.

  Remplace la variable d'environnement « DISPLAY ».

• -geometry geometry: identique à -qwindowgeometry.

Arguments spécifiques à la plate-forme

Vous pouvez spécifier des arguments spécifiques à la plate-forme pour l'option ` -platform `. Placez-les après le nom du plugin de la plate-forme, suivis d'un deux-points, sous forme de liste séparée par des virgules. Par exemple : ` -platform windows:dialogs=xp,fontengine=freetype`.

Les paramètres suivants sont disponibles pour « -platform windows » :

• altgr, détecte la touche « AltGr » présente sur certains claviers sous la forme « Qt::GroupSwitchModifier » (depuis Qt 5.12).
• darkmode=[0|1|2] contrôle la manière dont Qt réagit à l’activation du mode sombre pour les applications introduites dans Windows 10 1903 (depuis Qt 5.15).

  Une valeur de 0 désactive la prise en charge du mode sombre.

  Une valeur de 1 fait que Qt affiche les bordures de fenêtre en noir lorsque le mode sombre des applications est activé et qu’aucun thème à contraste élevé n’est utilisé. Cette option est destinée aux applications qui implémentent leur propre système de thèmes.

  Une valeur de 2 entraîne en outre la désactivation du style Windows Vista et le passage au style Windows utilisant une palette simplifiée en mode sombre. Cette fonctionnalité est actuellement expérimentale, dans l'attente de l'introduction d'un nouveau style s'adaptant correctement au mode sombre.

  À partir de Qt 6.5, la valeur par défaut est 2 ; pour désactiver la prise en charge du mode sombre, définissez la valeur sur 0 ou 1.

• dialogs=[xp|none], ` xp ` utilise les boîtes de dialogue natives de style XP et ` none ` les désactive.
• fontengine=freetype, utilise le moteur de polices FreeType.
• fontengine=gdi, utilise l’ancienne base de données de polices basée sur GDI et utilise par défaut le moteur de polices GDI (qui n’est par ailleurs utilisé que pour certains types de polices ou certaines propriétés de polices). (Depuis Qt 6.8).
• menus=[native|none], contrôle l’utilisation des menus natifs.

  Les menus natifs sont implémentés à l’aide de l’API Win32 et sont plus simples que les menus basés sur QMenu, notamment parce qu’ils permettent de placer des widgets dessus ou de modifier des propriétés telles que les polices, mais ne fournissent pas de signaux au survol. Ils sont principalement destinés à Qt Quick. Par défaut, ils seront utilisés si l’application n’est pas une instance de QApplication ou pour les applications Qt Quick Controls 2 (depuis Qt 5.10).

• nocolorfonts Désactive les polices DirectWrite Color (depuis Qt 5.8).
• nodirectwrite Désactive les polices DirectWrite (depuis Qt 5.8). Cela sélectionne également implicitement le moteur de polices GDI.
• nomousefromtouch Ignore les événements de souris synthétisés à partir d’événements tactiles par le système d’exploitation.
• nowmpointer Passe de la gestion des messages d’entrée par pointeur à la gestion classique de la souris (depuis Qt 5.12).
• reverse Active le mode « de droite à gauche » (expérimental). Les barres de titre Windows s'afficheront en conséquence dans les paramètres régionaux « de droite à gauche » (depuis Qt 5.13).
• tabletabsoluterange=<value> Définit une valeur pour la détection du mode souris des tablettes WinTab (mode hérité, depuis Qt 5.3).

Le paramètre suivant est disponible pour « -platform cocoa » (sur macOS) :

• fontengine=freetype, utilise le moteur de polices FreeType.

Pour plus d’informations sur les arguments spécifiques à la plateforme disponibles pour les plateformes Linux embarquées, consultez Qt pour Linux embarqué.

Voir également ` arguments()` et ` QGuiApplication::platformName`.

[virtual noexcept] QGuiApplication::~QGuiApplication()

Ferme l'application.

[static] QWindowList QGuiApplication::allWindows()

Renvoie une liste de toutes les fenêtres de l'application.

La liste est vide s'il n'y a pas de fenêtres.

Voir aussi ` topLevelWindows()`.

[static] Qt::ApplicationState QGuiApplication::applicationState()

Renvoie l'état actuel de l'application.

Vous pouvez réagir aux changements d'état de l'application pour effectuer des actions telles que l'arrêt ou la reprise de tâches gourmandes en ressources processeur, la libération ou le chargement de ressources, ou encore la sauvegarde ou la restauration des données de l'application.

[signal] void QGuiApplication::applicationStateChanged(Qt::ApplicationState state)

Ce signal est émis lorsque l'state e de l'application change.

Voir également applicationState().

[static] void QGuiApplication::changeOverrideCursor(const QCursor &cursor)

Remplace le curseur de l'application actuellement active par cursor.

Cette fonction n’a aucun effet si la fonction setOverrideCursor() n’a pas été appelée.

Voir également setOverrideCursor(), overrideCursor(), restoreOverrideCursor() et QWidget::setCursor().

[static] QClipboard *QGuiApplication::clipboard()

Renvoie l'objet permettant d'interagir avec le presse-papiers.

[signal] void QGuiApplication::commitDataRequest(QSessionManager &manager)

Ce signal concerne la gestion des sessions. Il est émis lorsque l'QSessionManager e souhaite que l'application valide toutes ses données.

En général, cela implique d'enregistrer tous les fichiers ouverts, après avoir obtenu l'autorisation de l'utilisateur. De plus, vous pouvez prévoir un moyen permettant à l'utilisateur d'annuler l'arrêt.

Vous ne devez pas quitter l’application dans le cadre de ce signal. C’est plutôt le gestionnaire de session qui se chargera ou non de le faire par la suite, selon le contexte.

Voir également isSessionRestored(), sessionId(), saveStateRequest() et Gestion des sessions.

[static] bool QGuiApplication::desktopSettingsAware()

Renvoie « true » si Qt est configuré pour utiliser les couleurs, polices, etc. par défaut du système ; sinon, renvoie « false ». La valeur par défaut est « true ».

Voir également setDesktopSettingsAware().

qreal QGuiApplication::devicePixelRatio() const

Renvoie le rapport de pixels d'écran le plus élevé détecté sur le système. Il s'agit du rapport entre les pixels physiques et les pixels indépendants du périphérique.

N'utilisez cette fonction que si vous ne savez pas quelle fenêtre vous ciblez. Si vous connaissez la fenêtre cible, utilisez plutôt QWindow::devicePixelRatio() à la place.

Voir également QWindow::devicePixelRatio().

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

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

[static] int QGuiApplication::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()` (c'est-à-dire 0 si la fonction ` 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()`.

Pour que votre application effectue un traitement en veille, par exemple en exécutant 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 d’associer 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.

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

[static] QObject *QGuiApplication::focusObject()

Renvoie l'QObject e de la fenêtre actuellement active qui sera le destinataire final des événements liés au focus, tels que les événements de touche.

[signal] void QGuiApplication::focusObjectChanged(QObject *focusObject)

Ce signal est émis lorsque le récepteur final des événements liés au focus est modifié. focusObject est le nouveau récepteur.

Voir également focusObject().

[static] QWindow *QGuiApplication::focusWindow()

Renvoie l'QWindow qui reçoit les événements liés au focus, tels que les événements de touche.

Voir aussi QWindow::requestActivate().

[signal] void QGuiApplication::focusWindowChanged(QWindow *focusWindow)

Ce signal est émis lorsque la fenêtre active change. ` focusWindow ` correspond à la nouvelle fenêtre active.

Voir aussi focusWindow().

[static] QFont QGuiApplication::font()

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

Voir aussi setFont().

[signal] void QGuiApplication::fontDatabaseChanged()

Ce signal est émis lorsque les polices disponibles ont changé.

Cela peut se produire lorsque des polices d'application sont ajoutées ou supprimées, ou lorsque les polices système changent.

Voir également QFontDatabase::addApplicationFont(), QFontDatabase::addApplicationFontFromData(), QFontDatabase::removeAllApplicationFonts() et QFontDatabase::removeApplicationFont().

[static] Qt::HighDpiScaleFactorRoundingPolicy QGuiApplication::highDpiScaleFactorRoundingPolicy()

Renvoie la politique d'arrondi du facteur d'échelle haute résolution (DPI).

Voir également setHighDpiScaleFactorRoundingPolicy().

[static] QInputMethod *QGuiApplication::inputMethod()

renvoie la méthode de saisie.

La méthode d'entrée renvoie des propriétés relatives à l'état et à la position du clavier virtuel. Elle fournit également des informations sur la position de l'élément de saisie actuellement sélectionné.

Voir également QInputMethod.

[static] bool QGuiApplication::isLeftToRight()

Renvoie « true » si la direction de mise en page de l'application est « Qt::LeftToRight » ; sinon, renvoie « false ».

Voir également layoutDirection() et isRightToLeft().

[static] bool QGuiApplication::isRightToLeft()

Renvoie true si le sens de mise en page de l'application est Qt::RightToLeft; sinon, renvoie false.

Voir également layoutDirection() et isLeftToRight().

bool QGuiApplication::isSavingSession() const

Renvoie « true » si l'application est en train d'enregistrer la session; sinon, renvoie « false ».

C'est true lorsque commitDataRequest() et saveStateRequest() sont émis, mais également lorsque les fenêtres sont fermées par la suite par la gestion des sessions.

Voir également sessionId(), commitDataRequest() et saveStateRequest().

bool QGuiApplication::isSessionRestored() const

Renvoie « true » si l'application a été restaurée à partir d'une session antérieure ; sinon, renvoie « false ».

Voir également sessionId(), commitDataRequest() et saveStateRequest().

[static] Qt::KeyboardModifiers QGuiApplication::keyboardModifiers()

Renvoie l'état actuel des touches de modification du clavier. Cet état est mis à jour de manière synchrone à mesure que la file d'attente des événements est vidée des événements susceptibles de modifier spontanément l'état du clavier (événements «QEvent::KeyPress » et « QEvent::KeyRelease »).

Il convient de noter que cela peut ne pas refléter les touches réellement enfoncées sur le périphérique d'entrée au moment de l'appel, mais plutôt les touches de modification telles qu'elles ont été signalées en dernier lieu dans l'un des événements ci-dessus. Si aucune touche n'est enfoncée, la valeur Qt::NoModifier est renvoyée.

Voir également mouseButtons() et queryKeyboardModifiers().

[signal] void QGuiApplication::lastWindowClosed()

Ce signal est émis par ` exec()` lorsque la dernière fenêtre principale visible (c'est-à-dire une fenêtre de niveau supérieur sans parent temporaire) est fermée.

Par défaut, QGuiApplication se ferme après l'émission de ce signal. Cette fonctionnalité peut être désactivée en définissant quitOnLastWindowClosed sur false.

Voir également QWindow::close(), QWindow::isTopLevel() et QWindow::transientParent().

[static] QWindow *QGuiApplication::modalWindow()

Renvoie la dernière fenêtre modale affichée. Si aucune fenêtre modale n'est visible, cette fonction renvoie zéro.

Une fenêtre modale est une fenêtre dont la propriété « modality » est définie sur « Qt::WindowModal » ou « Qt::ApplicationModal ». Une fenêtre modale doit être fermée avant que l'utilisateur puisse poursuivre l'exécution d'autres parties du programme.

Les fenêtres modales sont organisées en pile. Cette fonction renvoie la fenêtre modale située au sommet de la pile.

Voir également Qt::WindowModality et QWindow::setModality().

[static] Qt::MouseButtons QGuiApplication::mouseButtons()

Renvoie l'état actuel des boutons de la souris. Cet état est mis à jour de manière synchrone à mesure que la file d'attente des événements est vidée des événements susceptibles de modifier spontanément l'état de la souris (événements «QEvent::MouseButtonPress » et « QEvent::MouseButtonRelease »).

Il convient de noter que cela peut ne pas refléter les boutons réellement enfoncés sur le périphérique d'entrée au moment de l'appel, mais plutôt les boutons de souris tels qu'ils ont été signalés en dernier lieu dans l'un des événements ci-dessus. Si aucun bouton de souris n'est enfoncé, la valeur Qt::NoButton est renvoyée.

Voir également keyboardModifiers().

template <typename QNativeInterface> QNativeInterface *QGuiApplication::nativeInterface() const

Renvoie une interface native du type spécifié pour l'application.

Cette fonction permet d’accéder aux fonctionnalités spécifiques à la plateforme de QGuiApplication, telles que définies dans l’espace de noms QNativeInterface:

Si l'interface demandée n'est pas disponible, un objet ` nullptr ` est renvoyé.

[override virtual] bool QGuiApplication::notify(QObject *object, QEvent *event)

Réimplémente : QCoreApplication::notify(QObject *receiver, QEvent *event).

[static] QCursor *QGuiApplication::overrideCursor()

Renvoie le curseur de remplacement de l'application active.

Cette fonction renvoie « nullptr » si aucun curseur d'application n'a été défini (c'est-à-dire si la pile interne de curseurs est vide).

Voir également setOverrideCursor() et restoreOverrideCursor().

[static] QPalette QGuiApplication::palette()

Renvoie la palette de l'application actuelle.

Les rôles qui n'ont pas été explicitement définis refléteront le thème de la plateforme du système.

Voir également setPalette().

[static] Qt::KeyboardModifiers QGuiApplication::queryKeyboardModifiers()

Interroge et renvoie l'état des touches de modification du clavier. Contrairement à ` keyboardModifiers`, cette méthode renvoie les touches effectivement enfoncées sur le périphérique d'entrée au moment de l'appel de la méthode.

Elle ne dépend pas des événements de frappe reçus par ce processus, ce qui permet, par exemple, de vérifier les touches de modification lors du déplacement d’une fenêtre. Notez que dans la plupart des cas, il est préférable d’utiliser keyboardModifiers(), qui est plus rapide et plus précise puisqu’elle contient l’état des touches de modification tel qu’il était au moment de la réception de l’événement actuellement traité.

Voir également ` keyboardModifiers()`.

[static] void QGuiApplication::restoreOverrideCursor()

Annule le dernier appel à ` setOverrideCursor()`.

Si la fonction setOverrideCursor() a été appelée deux fois, l'appel de restoreOverrideCursor() activera le premier jeu de curseurs. Un deuxième appel de cette fonction rétablit les curseurs d'origine des widgets.

Voir également setOverrideCursor() et overrideCursor().

[signal] void QGuiApplication::saveStateRequest(QSessionManager &manager)

Ce signal concerne la gestion des sessions. Il est déclenché lorsque l’ session manager e souhaite que l’application conserve son état en vue d’une session future.

Par exemple, un éditeur de texte créerait un fichier temporaire contenant le contenu actuel de ses tampons d’édition, la position du curseur et d’autres aspects de la session d’édition en cours.

Vous ne devez jamais quitter l’application au sein de ce signal. C’est plutôt le gestionnaire de session qui se chargera ou non de cette tâche par la suite, selon le contexte. De plus, la plupart des gestionnaires de session demanderont très probablement un état sauvegardé immédiatement après le démarrage de l’application. Cela permet au gestionnaire de session de prendre connaissance de la politique de redémarrage de l’application.

Voir également isSessionRestored(), sessionId(), commitDataRequest() et Gestion des sessions.

[signal] void QGuiApplication::screenAdded(QScreen *screen)

Ce signal est émis chaque fois qu'une nouvelle screen d'écran a été ajoutée au système.

Voir également screens(), primaryScreen et screenRemoved().

[static] QScreen *QGuiApplication::screenAt(const QPoint &point)

Renvoie l'écran situé à l'adresse point, ou nullptr s'il ne s'agit d'aucun écran.

La méthode ` point ` s'applique par rapport à la fonction `virtualGeometry()` de chaque ensemble de frères et sœurs virtuels. Si le point correspond à plusieurs ensembles de frères et sœurs virtuels, c'est la première correspondance qui est renvoyée. Si vous souhaitez rechercher uniquement les frères et sœurs virtuels d'un écran connu (par exemple, les frères et sœurs de l'écran de la fenêtre de votre application ` QWidget::windowHandle()->screen()`), utilisez la méthode ` QScreen::virtualSiblingAt()`.

[signal] void QGuiApplication::screenRemoved(QScreen *screen)

Ce signal est émis chaque fois qu'une fenêtre « screen » est supprimée du système. Il permet de gérer les fenêtres à l'écran avant que Qt ne les déplace automatiquement vers l'écran principal.

Voir également screens(), screenAdded(), QObject::destroyed() et QWindow::setScreen().

[static] QList<QScreen *> QGuiApplication::screens()

Renvoie une liste de tous les écrans associés au système de fenêtrage auquel l'application est connectée.

QString QGuiApplication::sessionId() const

Renvoie l'identifiant de la session en cours.

Si l'application a été restaurée à partir d'une session antérieure, cet identifiant est le même que celui de cette session précédente. L'unicité de l'identifiant de session est garantie, tant entre différentes applications qu'entre différentes instances d'une même application.

Voir également isSessionRestored(), sessionKey(), commitDataRequest() et saveStateRequest().

QString QGuiApplication::sessionKey() const

Renvoie la clé de session de la session en cours.

Si l'application a été restaurée à partir d'une session antérieure, cette clé est la même que celle qui était en vigueur à la fin de la session précédente.

La clé de session change à chaque fois que la session est enregistrée. Si le processus d'arrêt est annulé, une autre clé de session sera utilisée lors du prochain arrêt.

Voir également isSessionRestored(), sessionId(), commitDataRequest() et saveStateRequest().

[slot, since 6.5] void QGuiApplication::setBadgeNumber(qint64 number)

Définit le badge de l'application sur « number ».

Utile pour informer l'utilisateur du nombre de messages non lus ou d'autres informations similaires.

Le badge s'affichera par-dessus l'icône de l'application dans le Dock sous macOS, sur l'icône de l'écran d'accueil sous iOS, ou dans la barre des tâches sous Windows et Linux.

Si le nombre dépasse la plage prise en charge par la plateforme, il sera limité à cette plage. Si le nombre ne tient pas dans le badge, il peut être tronqué visuellement.

Définir le nombre sur 0 effacera le badge.

Cette fonctionnalité a été introduite dans Qt 6.5.

Voir également applicationName.

[static] void QGuiApplication::setDesktopSettingsAware(bool on)

Détermine si Qt doit utiliser les couleurs, polices, etc. par défaut du système pour on. Par défaut, la valeur est « true ».

Cette fonction doit être appelée avant la création de l'objet ` QGuiApplication `, comme suit :

int main(int argc, char *argv[])
{
    QApplication::setDesktopSettingsAware(false);
    QApplication app(argc, argv);
    // ...
    return app.exec();
}

Voir aussi desktopSettingsAware().

[static] void QGuiApplication::setFont(const QFont &font)

Modifie la police par défaut de l'application pour « font ».

Voir également font().

[static] void QGuiApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy policy)

Définit la politique d'arrondi des facteurs d'échelle haute résolution (DPI) pour l'application. L'policy e détermine comment les facteurs d'échelle non entiers (tels que 150 % sous Windows) sont gérés.

Les deux principales options consistent à déterminer si les facteurs d'échelle fractionnaires doivent être arrondis à un entier ou non. Conserver le facteur d'échelle tel quel permettra à la taille de l'interface utilisateur de correspondre exactement au paramètre du système d'exploitation, mais peut entraîner des erreurs d'affichage, par exemple avec le style Windows.

Si l’arrondi est souhaité, il faut ensuite choisir le type d’arrondi à utiliser. L'arrondi mathématiquement correct est pris en charge, mais peut ne pas donner les meilleurs résultats visuels : demandez-vous si vous souhaitez afficher 1,5x comme 1x (« petite interface utilisateur ») ou comme 2x (« grande interface utilisateur »). Consultez l'énumération ` Qt::HighDpiScaleFactorRoundingPolicy ` pour obtenir la liste complète de toutes les options.

Cette fonction doit être appelée avant la création de l’objet application. L’accesseur QGuiApplication::highDpiScaleFactorRoundingPolicy() reflétera la configuration de l’environnement, si celle-ci est définie.

La valeur par défaut est Qt::HighDpiScaleFactorRoundingPolicy::PassThrough.

Voir également highDpiScaleFactorRoundingPolicy().

[static] void QGuiApplication::setOverrideCursor(const QCursor &cursor)

Définit le curseur de surcouche de l'application sur « cursor ».

Les curseurs de remplacement d'application sont destinés à indiquer à l'utilisateur que l'application se trouve dans un état particulier, par exemple lors d'une opération susceptible de prendre un certain temps.

Ce curseur s'affichera dans tous les widgets de l'application jusqu'à ce que la méthode ` restoreOverrideCursor()` ou une autre méthode `setOverrideCursor()` soit appelée.

Les curseurs d’application sont stockés dans une pile interne. La méthode `setOverrideCursor()` ajoute le curseur à la pile, tandis que ` restoreOverrideCursor()` retire le curseur actif de la pile. La méthode ` changeOverrideCursor()` permet de modifier le curseur de remplacement d’application actuellement actif.

Chaque appel à setOverrideCursor() doit être suivi d'un appel correspondant à restoreOverrideCursor(), sinon la pile ne sera jamais vidée.

Exemple :

QGuiApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
calculateHugeMandelbrot();              // lunch time...
QGuiApplication::restoreOverrideCursor();

Voir également overrideCursor(), restoreOverrideCursor(), changeOverrideCursor() et QWidget::setCursor().

[static] void QGuiApplication::setPalette(const QPalette &pal)

Modifie la palette de l'application pour la remplacer par pal.

Les rôles de couleur de cette palette sont combinés avec le thème de la plate-forme du système pour former la palette finale de l'application.

Voir également palette().

[static] QStyleHints *QGuiApplication::styleHints()

Renvoie les indications de style de l'application.

Ces indications de style regroupent un ensemble de propriétés dépendantes de la plateforme, telles que les intervalles entre deux clics, la sélection sur toute la largeur, etc.

Ces indications peuvent être utilisées pour assurer une meilleure intégration avec la plateforme sous-jacente.

Voir également QStyleHints.

[static] void QGuiApplication::sync()

Fonction permettant de synchroniser l'état de Qt avec celui du système de fenêtrage.

Cette fonction commence par vider la file d'attente des événements Qt en appelant ` QCoreApplication::processEvents()`, puis le plugin de la plateforme effectue la synchronisation avec le système de fenêtrage, et enfin les événements Qt sont transmis par un nouvel appel à ` QCoreApplication::processEvents()` ;

Cette fonction prend beaucoup de temps et son utilisation est déconseillée.

[static] QWindow *QGuiApplication::topLevelAt(const QPoint &pos)

Renvoie la fenêtre de niveau supérieur située à la position indiquée pos, le cas échéant.

[static] QWindowList QGuiApplication::topLevelWindows()

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

Voir aussi allWindows().