QGuiApplication Class

Documentation des fonctions membres

QGuiApplication::QGuiApplication(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 pixmaps, les bitmaps, etc.).

Options de ligne de commande prises en charge

Tous les programmes Qt supportent automatiquement un ensemble d'options de ligne de commande qui permettent de modifier la façon dont Qt interagit avec le système de fenêtrage. Certaines options sont également accessibles via des variables d'environnement, qui sont la forme préférée si l'application peut lancer des sous-processus d'interface graphique 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 :

• -platform platformName[: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 plate-forme.

  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. L'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 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.
• -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 Qt::RightToLeftCette 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 de la locale de l'utilisateur (voir aussi 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 l'affichage 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, après 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:

• altgrdétecte la touche AltGr trouvée sur certains claviers en tant que Qt::GroupSwitchModifier (depuis Qt 5.12).
• darkmode=[0|1|2] contrôle la façon dont Qt répond à 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 basculer les bordures de la fenêtre en noir lorsque le mode sombre pour les applications est activé et qu'aucun thème à contraste élevé n'est utilisé. Ceci est destiné aux applications qui implémentent leur propre thème.

  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. Ceci est actuellement expérimental en attendant l'introduction d'un nouveau style qui s'adapte 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 à 0 ou 1.

• dialogs=[xp|none]La version anglaise de Qt, xp utilise des boîtes de dialogue natives de style XP et none les désactive.
• fontengine=freetype, utilise le moteur de polices FreeType.
• fontengine=gdi, utilise la base de données de polices GDI et utilise par défaut le moteur de polices GDI (qui n'est par ailleurs utilisé que pour certains types de polices ou propriétés de polices) (depuis Qt 6.8).
• menus=[native|none]La commande "Native menus", contrôle l'utilisation des menus natifs.

  Les menus natifs sont mis en œuvre à l'aide de l'API Win32 et sont plus simples que les menus basés sur QMenu, par exemple parce qu'ils ne permettent pas de placer des widgets ou de modifier des propriétés telles que les polices et qu'ils ne fournissent pas de signaux de 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ésactiver les polices DirectWrite Color (depuis Qt 5.8).
• nodirectwrite Désactiver les polices DirectWrite (depuis Qt 5.8). Ceci sélectionne implicitement le moteur de polices GDI.
• nomousefromtouch Ignore les événements souris synthétisés à partir des événements tactiles par le système d'exploitation.
• nowmpointer Passe de la gestion des messages d'entrée de pointeur à la gestion de la souris traditionnelle (depuis Qt 5.12).
• reverse Active le mode droite-gauche (expérimental). Les barres de titre des fenêtres seront affichées en conséquence dans les locales de droite à gauche (depuis Qt 5.13).
• tabletabsoluterange=<value> Définit une valeur pour la détection du mode souris des tablettes WinTab (Legacy, 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 plate-forme disponibles pour les plates-formes Linux embarquées, voir Qt pour Linux embarqué.

Voir aussi arguments() et QGuiApplication::platformName.

[virtual noexcept] QGuiApplication::~QGuiApplication()

Détruit 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/la reprise des tâches gourmandes en ressources processeur, la libération/le chargement des ressources ou la sauvegarde/restauration des données de l'application.

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

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

Voir également applicationState().

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

Modifie le curseur de remplacement de l'application actuellement active en cursor.

Cette fonction n'a aucun effet si setOverrideCursor() n'a pas été appelé.

Voir aussi 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 de la session. Il est émis lorsque le site QSessionManager souhaite que l'application engage toutes ses données.

En général, cela signifie qu'il faut enregistrer tous les fichiers ouverts, après avoir obtenu l'autorisation de l'utilisateur. En outre, vous pouvez vouloir fournir un moyen par lequel l'utilisateur peut annuler l'arrêt de l'application.

Vous ne devez pas quitter l'application dans le cadre de ce signal. Au lieu de cela, le gestionnaire de session peut ou non le faire par la suite, en fonction du contexte.

Voir aussi isSessionRestored(), sessionId(), saveStateRequest(), et Session Management.

[static] bool QGuiApplication::desktopSettingsAware()

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

Voir aussi setDesktopSettingsAware().

qreal QGuiApplication::devicePixelRatio() const

Renvoie le rapport de pixels du périphérique d'écran le plus élevé trouvé 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().

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 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().

Pour que votre application effectue un traitement inactif, par exemple en exécutant une fonction spéciale chaque fois qu'il n'y a pas d'événements en attente, utilisez un QChronoTimer avec un délai 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 plates-formes, l'appel à QApplication::exec() peut ne pas être retourné.

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

[static] QObject *QGuiApplication::focusObject()

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

[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 aussi focusObject().

[static] QWindow *QGuiApplication::focusWindow()

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

Voir également QWindow::requestActivate().

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

Ce signal est émis lorsque la fenêtre focalisée change. focusWindow est la nouvelle fenêtre focalisée.

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 du système changent.

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

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

Renvoie la politique d'arrondi du facteur d'échelle pour les hauts DPI.

Voir aussi setHighDpiScaleFactorRoundingPolicy().

[static] QInputMethod *QGuiApplication::inputMethod()

renvoie la méthode input.

La méthode input renvoie des propriétés sur l'état et la position du clavier virtuel. Elle fournit également des informations sur la position de l'élément de saisie actuellement ciblé.

Voir aussi QInputMethod.

[static] bool QGuiApplication::isLeftToRight()

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

Voir aussi layoutDirection() et isRightToLeft().

[static] bool QGuiApplication::isRightToLeft()

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

Voir aussi layoutDirection() et isLeftToRight().

bool QGuiApplication::isSavingSession() const

Renvoie true si l'application est en train de sauvegarder la session, sinon renvoie false.

Il s'agit de true lorsque commitDataRequest() et saveStateRequest() sont émis, mais aussi lorsque les fenêtres sont fermées par la suite par la gestion de la session.

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 aussi sessionId(), commitDataRequest() et saveStateRequest().

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

Renvoie l'état actuel des touches de modification du clavier. L'état actuel est mis à jour de manière synchrone lorsque la file d'attente des événements est vidée des événements qui modifieront spontanément l'état du clavier (événementsQEvent::KeyPress et QEvent::KeyRelease ).

Il convient de noter que cet état peut ne pas refléter les touches réellement maintenues sur le périphérique d'entrée au moment de l'appel, mais plutôt les modificateurs tels qu'ils ont été signalés pour la dernière fois dans l'un des événements susmentionnés. Si aucune touche n'est maintenue, Qt::NoModifier est renvoyé.

Voir également mouseButtons() et queryKeyboardModifiers().

[signal] void QGuiApplication::lastWindowClosed()

Ce signal est émis par exec() lorsque la dernière fenêtre primaire visible (c'est-à-dire la fenêtre de premier niveau sans parent transitoire) est fermée.

Par défaut, QGuiApplication se ferme après l'émission de ce signal. Cette fonctionnalité peut être désactivée en réglant 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 ne puisse poursuivre 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. L'état actuel est mis à jour de manière synchrone lorsque la file d'attente des événements est vidée des événements qui modifieront spontanément l'état de la souris (événementsQEvent::MouseButtonPress et QEvent::MouseButtonRelease ).

Il convient de noter que cet état peut ne pas refléter les boutons réellement maintenus sur le périphérique d'entrée au moment de l'appel, mais plutôt les boutons de la souris tels qu'ils ont été signalés pour la dernière fois dans l'un des événements susmentionnés. Si aucun bouton de souris n'est maintenu, Qt::NoButton est renvoyé.

Voir aussi keyboardModifiers().

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

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

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

Si l'interface demandée n'est pas disponible, la fonction renvoie nullptr.

[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 de curseurs internes est vide).

Voir aussi setOverrideCursor() et restoreOverrideCursor().

[static] QPalette QGuiApplication::palette()

Renvoie la palette actuelle de l'application.

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

Voir aussi setPalette().

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

Demande et renvoie l'état des touches de modification du clavier. Contrairement à keyboardModifiers, cette méthode renvoie les touches effectivement maintenues 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 pression de touche reçus par ce processus, ce qui permet de vérifier les modificateurs tout en déplaçant une fenêtre, par exemple. Notez que dans la plupart des cas, vous devriez utiliser keyboardModifiers(), qui est plus rapide et plus précis puisqu'il contient l'état des modificateurs tel qu'il était lorsque l'événement actuellement traité a été reçu.

Voir également keyboardModifiers().

[static] void QGuiApplication::restoreOverrideCursor()

Annule le dernier appel à setOverrideCursor().

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

Voir également setOverrideCursor() et overrideCursor().

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

Ce signal concerne la gestion des sessions. Il est invoqué lorsque le site session manager souhaite que l'application conserve son état pour une session ultérieure.

Par exemple, un éditeur de texte crée un fichier temporaire qui contient le contenu actuel de ses tampons d'édition, l'emplacement du curseur et d'autres aspects de la session d'édition en cours.

Vous ne devez jamais quitter l'application à l'intérieur de ce signal. Au lieu de cela, le gestionnaire de session peut ou non le faire par la suite, en fonction du contexte. En outre, 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 connaître la politique de redémarrage de l'application.

Voir aussi isSessionRestored(), sessionId(), commitDataRequest(), et Session Management.

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

Ce signal est émis chaque fois qu'un nouvel écran screen a été ajouté au système.

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

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

Renvoie l'écran à point, ou nullptr s'il est en dehors de tout écran.

Le site point est en relation avec la virtualGeometry() de chaque ensemble de frères et sœurs virtuels. Si le point correspond à plus d'un ensemble de frères et sœurs virtuels, la première correspondance 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 votre fenêtre d'application QWidget::windowHandle()->screen()), utilisez QScreen::virtualSiblingAt().

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

Ce signal est émis chaque fois qu'une page screen est retirée du système. Il permet de gérer les fenêtres sur l'écran avant que Qt ne les déplace sur l'écran principal.

Voir aussi 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'identifiant de la session est garanti unique pour des applications différentes et pour des instances différentes de la même application.

Voir aussi 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 qu'à la fin de la session précédente.

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

Voir aussi isSessionRestored(), sessionId(), commitDataRequest() et saveStateRequest().

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

Définit le badge de l'application à number.

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

Le badge sera superposé à l'icône de l'application dans le Dock sous macOS, à l'icône de l'écran d'accueil sous iOS ou à la barre des tâches sous Windows et Linux.

Si le nombre est en dehors de la plage prise en charge par la plateforme, il sera limité à la plage prise en charge. Si le nombre ne tient pas dans le badge, il peut être supprimé visuellement.

Le fait de mettre le nombre à 0 effacera le badge.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi applicationName.

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

Définit si Qt doit utiliser les couleurs, polices, etc. standard du système à on. Par défaut, c'est true.

Cette fonction doit être appelée avant de créer l'objet QGuiApplication, comme ceci :

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)

Change la police par défaut de l'application en font.

Voir aussi font().

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

Définit la politique d'arrondi du facteur d'échelle pour les hauts DPI pour l'application. Le site policy décide de la manière dont les facteurs d'échelle non entiers (tels que Windows 150%) sont traités.

Les deux principales options consistent à arrondir ou non les facteurs d'échelle fractionnaires à un nombre entier. En conservant le facteur d'échelle tel quel, la taille de l'interface utilisateur correspondra exactement aux paramètres du système d'exploitation, mais peut provoquer des erreurs de peinture, par exemple avec le style Windows.

Si l'arrondi est souhaité, il convient ensuite de déterminer le type d'arrondi. Les arrondis mathématiquement corrects sont pris en charge, mais ne donnent pas forcément les meilleurs résultats visuels : Considérez si vous voulez rendre 1,5x comme 1x ("petite interface utilisateur") ou comme 2x ("grande interface utilisateur"). Voir l'enum Qt::HighDpiScaleFactorRoundingPolicy pour une liste complète de toutes les options.

Cette fonction doit être appelée avant de créer l'objet d'application. L'accesseur QGuiApplication::highDpiScaleFactorRoundingPolicy() reflète l'environnement, s'il est défini.

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

Voir également highDpiScaleFactorRoundingPolicy().

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

Définit le curseur d'annulation de l'application à cursor.

Les curseurs d'annulation d'application sont destinés à montrer à l'utilisateur que l'application est dans un état spécial, par exemple pendant une opération qui peut prendre un certain temps.

Ce curseur sera affiché dans tous les widgets de l'application jusqu'à ce que restoreOverrideCursor() ou un autre setOverrideCursor() soit appelé.

Les curseurs des applications sont stockés sur une pile interne. setOverrideCursor() place le curseur sur la pile, et restoreOverrideCursor() retire le curseur actif de la pile. changeOverrideCursor() modifie le curseur de remplacement de l'application actuellement active.

Chaque setOverrideCursor() doit être suivi d'un restoreOverrideCursor() correspondant, 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 en 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 aussi palette().

[static] QStyleHints *QGuiApplication::styleHints()

Renvoie les conseils de style de l'application.

Les conseils de style encapsulent un ensemble de propriétés dépendant de la plate-forme, telles que les intervalles de double clic, la sélection sur toute la largeur et d'autres.

Les indications peuvent être utilisées pour une intégration plus étroite avec la plate-forme sous-jacente.

Voir aussi QStyleHints.

[static] void QGuiApplication::sync()

Fonction qui peut être utilisée pour synchroniser l'état de Qt avec l'état du système de fenêtres.

Cette fonction commencera par vider les événements Qts en appelant QCoreApplication::processEvents(), puis le plugin de plateforme se synchronisera avec le système Windows, et enfin les événements Qts seront délivrés par un autre 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 premier niveau à la position donnée pos, le cas échéant.

[static] QWindowList QGuiApplication::topLevelWindows()

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

Voir aussi allWindows().