QCoreApplication Class

Documentation des fonctions membres

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

Crée une application Qt Core. Les applications « Qt Core » sont des applications dépourvues d'interface utilisateur graphique. Ces applications sont utilisées en mode console ou en tant que processus serveur.

Les arguments argc et argv sont traités par l'application, puis mis à disposition sous une forme plus pratique par la fonction arguments().

[virtual noexcept] QCoreApplication::~QCoreApplication()

Supprime l'objet « QCoreApplication ».

[private signal] void QCoreApplication::aboutToQuit()

Ce signal est émis lorsque l'application est sur le point de quitter la boucle d'événements principale, par exemple lorsque le niveau de la boucle d'événements tombe à zéro. Cela peut se produire soit après un appel à la fonction ` quit()` depuis l'intérieur de l'application, soit lorsque l'utilisateur met fin à l'ensemble de la session de bureau.

Ce signal est particulièrement utile si votre application doit effectuer des opérations de nettoyage de dernière minute. Notez qu’aucune interaction avec l’utilisateur n’est possible dans cet état.

Voir aussi quit().

[static] void QCoreApplication::addLibraryPath(const QString &path)

Ajoute path au début de la liste des chemins d'accès aux bibliothèques, garantissant ainsi que ce chemin soit consulté en premier lors de la recherche de bibliothèques. Si path est vide ou figure déjà dans la liste des chemins d'accès, celle-ci n'est pas modifiée.

La liste de chemins par défaut se compose d’une ou deux entrées. La première correspond au répertoire d’installation des plugins, à savoir INSTALL/plugins, où INSTALL désigne le répertoire dans lequel Qt a été installé. La seconde correspond au répertoire propre à l’application (et non au répertoire courant), mais uniquement après l’instanciation de l’objet QCoreApplication.

Les chemins d'accès aux bibliothèques sont réinitialisés à leurs valeurs par défaut lorsqu'une instance de ` QCoreApplication ` est détruite.

Voir également removeLibraryPath(), libraryPaths() et setLibraryPaths().

[static] QString QCoreApplication::applicationDirPath()

Renvoie le répertoire contenant l'exécutable de l'application.

Par exemple, si vous avez installé Qt dans le répertoire C:\Qt et que vous exécutez l'exemple regexp, cette fonction renverra « C:/Qt/examples/tools/regexp ».

Sous macOS et iOS, cela pointera vers le répertoire contenant effectivement le fichier exécutable, qui peut se trouver à l'intérieur d'un bundle d'application (si l'application est fournie sous forme de bundle).

Sous Android, cela pointera vers le répertoire contenant effectivement l'exécutable, qui peut se trouver à l'intérieur de l'APK de l'application (si celle-ci a été compilée avec la prise en charge des bibliothèques non compressées).

Voir également applicationFilePath().

[static] QString QCoreApplication::applicationFilePath()

Renvoie le chemin d'accès au fichier exécutable de l'application.

Par exemple, si vous avez installé Qt dans le répertoire /usr/local/qt et que vous exécutez l'exemple regexp, cette fonction renverra « /usr/local/qt/examples/tools/regexp/regexp ».

Voir aussi applicationDirPath().

[static noexcept] qint64 QCoreApplication::applicationPid()

Renvoie l'identifiant du processus actuel de l'application.

[static] QStringList QCoreApplication::arguments()

Renvoie la liste des arguments de ligne de commande.

En général, arguments().at(0) correspond au nom du programme, arguments().at(1) au premier argument et arguments().last() au dernier argument. Voir la remarque ci-dessous concernant Windows.

L'appel de cette fonction est lent : vous devriez stocker le résultat dans une variable lors de l'analyse de la ligne de commande.

Sous Windows, la liste est construite à partir des paramètres argc et argv uniquement si des paramètres argv/argc modifiés sont transmis au constructeur. Dans ce cas, des problèmes d’encodage peuvent survenir.

Sinon, les arguments() sont construits à partir de la valeur renvoyée par GetCommandLine(). De ce fait, la chaîne fournie par arguments().at(0) peut ne pas correspondre exactement au programme utilisé pour lancer l'application sous Windows.

Voir également applicationFilePath() et QCommandLineParser.

[since 6.5] Qt::PermissionStatus QCoreApplication::checkPermission(const QPermission &permission)

Vérifie l'état de l'élément indiqué permission

Si le résultat est « Qt::PermissionStatus::Undetermined », il convient de demander l'autorisation via requestPermission() afin de déterminer l'intention de l'utilisateur.

Cette fonction a été introduite dans Qt 6.5.

Voir également requestPermission() et Autorisations d'application.

[static] bool QCoreApplication::closingDown()

Renvoie « true » si les objets de l'application sont en cours de destruction ; sinon, renvoie « false ».

Voir également startingUp().

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

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

[static] QAbstractEventDispatcher *QCoreApplication::eventDispatcher()

Renvoie un pointeur vers l'objet « event dispatcher » du thread principal. Si aucun « event dispatcher » n'existe pour ce thread, cette fonction renvoie ` nullptr`.

Voir également setEventDispatcher().

[static] int QCoreApplication::exec()

Entre dans la boucle d'événements principale et attend que la fonction ` exit()` soit appelée. Renvoie la valeur qui a été transmise à ` exit()` (c'est-à-dire 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.

Pour que votre application effectue un traitement en veille (en exécutant une fonction spéciale lorsqu’il n’y a pas d’événements en attente), utilisez une 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, car sur certaines plateformes, l’appel à 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 à `exec()`.

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

[static slot] void QCoreApplication::exit(int returnCode = 0)

Indique à l'application de se fermer en renvoyant un code de retour.

Une fois cette fonction appelée, l'application quitte la boucle d'événements principale et revient de l'appel à exec(). La fonction exec() renvoie returnCode. Si la boucle d'événements n'est pas en cours d'exécution, cette fonction ne fait rien.

Par convention, une valeur de ` returnCode ` égale à 0 signifie que l'opération a réussi, tandis que toute valeur différente de zéro indique une erreur.

Il est recommandé de toujours connecter les signaux à ce slot à l’aide d’un QueuedConnection. Si un signal connecté (non mis en file d’attente) à ce slot est émis avant que le contrôle n’entre dans la boucle d’événements principale (par exemple avant que « int main » n’appelle exec()), le slot n’a aucun effet et l’application ne se termine jamais. L'utilisation d’une connexion mise en file d’attente garantit que l’événement ne sera pas déclenché avant que le contrôle n’entre dans la boucle d’événements principale.

Notez que, contrairement à la fonction de la bibliothèque C du même nom, cette fonction revient à l’appelant : c’est le traitement des événements qui s’arrête.

Notez également que cette fonction n’est pas sûre pour les threads. Elle ne doit être appelée qu’à partir du thread principal (le thread sur lequel l’objet ` QCoreApplication ` traite les événements). Pour demander à l’application de se fermer depuis un autre thread, utilisez soit ` QCoreApplication::quit()`, soit appelez cette fonction depuis le thread principal à l’aide de `QMetaMethod::invokeMethod()`.

Voir également quit() et exec().

void QCoreApplication::installNativeEventFilter(QAbstractNativeEventFilter *filterObj)

Installe un filtre d'événements filterObj pour tous les événements natifs reçus par l'application dans le thread principal.

Le filtre d'événements filterObj reçoit les événements via sa fonction nativeEventFilter(), qui est appelée pour tous les événements natifs reçus dans le thread principal.

La fonction QAbstractNativeEventFilter::nativeEventFilter() doit renvoyer true si l'événement doit être filtré, c'est-à-dire bloqué. Elle doit renvoyer false pour permettre au traitement Qt normal de se poursuivre : l'événement natif peut alors être converti en QEvent et géré par le filtrage standard de Qt event, par exemple QObject::installEventFilter().

Si plusieurs filtres d’événements sont installés, c’est le filtre installé en dernier qui est activé en premier.

Pour une portabilité maximale, vous devriez toujours essayer d’utiliser QEvent et QObject::installEventFilter() dans la mesure du possible.

Voir également QObject::installEventFilter().

[static] bool QCoreApplication::installTranslator(QTranslator *translationFile)

Ajoute le fichier de traduction « translationFile » à la liste des fichiers de traduction à utiliser pour les traductions.

Plusieurs fichiers de traduction peuvent être installés. Les traductions sont recherchées dans l’ordre inverse de leur installation : le fichier de traduction installé le plus récemment est donc consulté en premier, et le premier fichier de traduction installé est consulté en dernier. La recherche s’arrête dès qu’une traduction contenant une chaîne correspondante est trouvée.

L’installation ou la suppression d’un fichier « QTranslator », ou la modification d’un fichier de traduction déjà installé ( QTranslator ), génère un événement « LanguageChange » pour l’instance « QCoreApplication ». Une instance « QApplication » propagera cet événement à tous les widgets de niveau supérieur, où une réimplémentation de la méthode « changeEvent » peut traduire à nouveau l’interface utilisateur en transmettant les chaînes visibles par l’utilisateur via la fonction « tr() » aux accesseurs de propriétés correspondants. Les classes d’interface utilisateur générées par Qt Widgets Designer fournissent une fonction retranslateUi() qui peut être appelée.

La fonction renvoie true en cas de succès et false en cas d'échec.

Voir également removeTranslator(), translate(), QTranslator::load() et « Se préparer aux changements de langage dynamique ».

[static noexcept] QCoreApplication *QCoreApplication::instance()

Renvoie un pointeur vers l'instance de ` QCoreApplication ` (ou ` QGuiApplication` / `QApplication`) de l'application.

Si aucune instance n'a été allouée, nullptr est renvoyée.

Avertissement concernant les conflits d'accès: cette fonction ne doit pas être utilisée pour vérifier l'existence de l'instance QCoreApplication à partir de threads auxiliaires, sauf si le code appelant est compilé en C++20.

[static] bool QCoreApplication::isSetuidAllowed()

Renvoie « true » si l'application est autorisée à s'exécuter en mode setuid sur les plateformes UNIX.

Voir aussi QCoreApplication::setSetuidAllowed().

[static] QStringList QCoreApplication::libraryPaths()

Renvoie une liste des chemins d'accès que l'application explorera lors du chargement dynamique des bibliothèques.

La valeur renvoyée par cette fonction peut changer lors de la création d’un objet ` QCoreApplication `. Il n’est pas recommandé de l’appeler avant d’avoir créé un objet ` QCoreApplication`. Le répertoire de l’exécutable de l’application (etnon le répertoire de travail) fait partie de la liste s’il est connu. Pour le rendre connu, il faut construire un objet ` QCoreApplication `, car celui-ci utilisera ` argv[0] ` pour le trouver.

Qt fournit des chemins d’accès par défaut aux bibliothèques, mais ceux-ci peuvent également être définis à l’aide d’un fichier qt.conf. Les chemins spécifiés dans ce fichier remplaceront les valeurs par défaut. Notez que si le fichier qt.conf se trouve dans le répertoire de l’exécutable de l’application, il se peut qu’il ne soit pas détecté tant qu’un objet de type ` QCoreApplication ` n’aura pas été créé. S’il n’est pas détecté lors de l’appel de cette fonction, les chemins d’accès par défaut aux bibliothèques seront utilisés.

La liste inclura les répertoires d’installation des plugins s’ils existent (le répertoire d’installation par défaut des plugins est INSTALL/plugins, où INSTALL correspond au répertoire dans lequel Qt a été installé). Les entrées séparées par des deux-points de la variable d’environnement QT_PLUGIN_PATH sont toujours ajoutées. Le répertoire d’installation des plugins (et son existence) peut changer lorsque le répertoire de l’exécutable de l’application est connu.

Voir également setLibraryPaths(), addLibraryPath(), removeLibraryPath(), QLibrary et Comment créer des plugins Qt.

[virtual] bool QCoreApplication::notify(QObject *receiver, QEvent *event)

Envoie l'événement « event » à l'objet « receiver » : receiver->event(event). Renvoie la valeur renvoyée par le gestionnaire d'événements du destinataire. Notez que cette fonction est appelée pour tous les événements envoyés à n'importe quel objet, quel que soit le thread.

Pour certains types d’événements (par exemple, les événements de souris et de clavier), l’événement sera propagé au parent du récepteur, et ainsi de suite jusqu’à l’objet de niveau supérieur si le récepteur n’est pas intéressé par l’événement (c’est-à-dire s’il renvoie ` false`).

Il existe cinq façons différentes de traiter les événements ; la réimplémentation de cette fonction virtuelle n’est que l’une d’entre elles. Les cinq approches sont énumérées ci-dessous :

1. Réimplémenter ` paintEvent()`, ` mousePressEvent()` et ainsi de suite. C’est la méthode la plus courante, la plus simple et la moins puissante.
2. Réimplémenter cette fonction. Cette méthode est très puissante et offre un contrôle total ; cependant, une seule sous-classe peut être active à la fois.
3. Installer un filtre d’événements sur ` QCoreApplication::instance()`. Un tel filtre d’événements est capable de traiter tous les événements de tous les widgets ; il est donc tout aussi puissant que la réimplémentation de `notify()` ; de plus, il est possible d’avoir plusieurs filtres d’événements globaux à l’échelle de l’application. Les filtres d’événements globaux détectent même les événements de souris pour disabled widgets. Notez que les filtres d’événements d’application ne sont appelés que pour les objets qui résident dans le thread principal.
4. Réimplémenter la méthode ` QObject::event()` (comme le fait ` QWidget `). Si vous procédez ainsi, vous recevez les appuis sur la touche Tab et vous pouvez voir ces événements avant tout filtre d’événements spécifique à un widget.
5. Installation d'un filtre d'événements sur l'objet. Un tel filtre d'événements reçoit tous les événements, y compris les pressions sur les touches Tab et Maj+Tab, tant qu'elles ne modifient pas le widget actif.

Orientation future : cette fonction ne sera plus appelée pour les objets situés en dehors du thread principal dans Qt 7. Les applications qui ont besoin de cette fonctionnalité devront trouver d’autres solutions pour leurs besoins d’inspection des événements en attendant. Ce changement pourrait être étendu au thread principal, ce qui rendrait cette fonction obsolète.

Voir également QObject::event() et installNativeEventFilter().

[static] void QCoreApplication::postEvent(QObject *receiver, QEvent *event, int priority = Qt::NormalEventPriority)

Ajoute l'événement event, avec l'objet receiver comme destinataire de l'événement, à une file d'attente d'événements, puis revient immédiatement.

L'événement doit être alloué sur le tas, car la file d'attente d'événements prendra possession de l'événement et le supprimera une fois qu'il aura été envoyé. Il n' est pas sûr d'accéder à l'événement après son envoi.

Lorsque le contrôle revient à la boucle d’événements principale, tous les événements stockés dans la file d’attente seront envoyés à l’aide de la fonction notify().

Les événements sont triés par ordre décroissant d’« priority », c’est-à-dire que les événements ayant une valeur de « priority » élevée sont mis en file d’attente avant ceux dont la valeur de « priority » est inférieure. La valeur « priority » peut être n’importe quelle valeur entière, c’est-à-dire comprise entre INT_MAX et INT_MIN, inclus ; voir Qt::EventPriority pour plus de détails. Les événements ayant une valeur de « priority » égale seront traités dans l’ordre où ils ont été postés.

QObject::connect(thread, &QThread::finished, worker, &QObject::deleteLater);

Remarque : cette fonction est sûre pour les threads.

Voir également sendEvent(), notify(), sendPostedEvents() et Qt::EventPriority.

[static] void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents)

Traite certains événements en attente pour le thread appelant, conformément à l'flags spécifiée.

L'utilisation de cette fonction est déconseillée. Préférez plutôt déplacer les opérations longues hors du thread de l'interface graphique vers un thread auxiliaire et évitez complètement le traitement en boucle d'événements imbriquées. Si le traitement des événements est vraiment nécessaire, envisagez d'utiliser QEventLoop à la place.

Si vous exécutez une boucle locale qui appelle cette fonction en continu, sans boucle d’événements, les événements de ` DeferredDelete ` ne seront pas traités. Cela peut affecter le comportement des widgets, par exemple ` QToolTip`, qui dépendent des événements de ` DeferredDelete ` pour fonctionner correctement. Une alternative serait d’appeler ` sendPostedEvents()` depuis l’intérieur de cette boucle locale.

L'appel de cette fonction traite les événements uniquement pour le thread appelant et renvoie un résultat une fois que tous les événements disponibles ont été traités. Les événements disponibles sont ceux mis en file d'attente avant l'appel de la fonction. Cela signifie que les événements postés pendant l'exécution de la fonction seront mis en file d'attente jusqu'à un cycle de traitement ultérieur.

Remarque : cette fonction est sûre pour les threads.

Voir également exec(), QTimer, QChronoTimer, QEventLoop::processEvents() et sendPostedEvents().

[static, since 6.7] void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, QDeadlineTimer deadline)

Traite les événements en attente pour le thread appelant jusqu'à l'expiration de ` deadline `, ou jusqu'à ce qu'il n'y ait plus d'événements à traiter, selon la première éventualité.

L'utilisation de cette fonction est déconseillée. Préférez plutôt déplacer les opérations longues hors du thread de l'interface graphique vers un thread auxiliaire et évitez complètement le traitement imbriqué des boucles d'événements. Si le traitement des événements est vraiment nécessaire, envisagez plutôt d'utiliser ` QEventLoop `.

L’appel de cette fonction traite les événements uniquement pour le thread appelant.

Remarque : cette fonction est thread-safe.

Cette fonction a été introduite dans Qt 6.7.

Voir également exec(), QTimer, QChronoTimer et QEventLoop::processEvents().

[static] void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int ms)

Traite les événements en attente pour le thread appelant pendant ms millisecondes ou jusqu’à ce qu’il n’y ait plus d’événements à traiter, la durée la plus courte étant retenue.

Cela équivaut à appeler :

QCoreApplication::processEvents(flags, QDeadlineTimer(ms));

[static slot] void QCoreApplication::quit()

Demande à l'application de se fermer.

La requête peut être ignorée si l'application empêche la fermeture, par exemple si l'une de ses fenêtres ne peut pas être fermée. L'application peut influencer ce comportement en gérant l'événement « QEvent::Quit » au niveau de l'application, ou les événements « QEvent::Close » pour chaque fenêtre individuellement.

Si la fermeture n'est pas interrompue, l'application se fermera avec un code de retour 0 (succès).

Pour quitter l’application sans risque d’interruption, appelez directement ` exit()`. Notez que cette méthode n’est pas thread-safe.

Il est recommandé de toujours connecter les signaux à ce slot à l’aide d’un QueuedConnection. Si un signal connecté (non mis en file d’attente) à ce slot est émis avant que le contrôle n’entre dans la boucle d’événements principale (par exemple avant que « int main » n’appelle exec()), le slot n’a aucun effet et l’application ne se ferme jamais. L'utilisation d'une connexion mise en file d'attente garantit que le slot ne sera pas appelé avant que le contrôle n'entre dans la boucle d'événements principale.

Exemple :

QPushButton *quitButton = new QPushButton("Quit");
QObject::connect(quitButton, &QPushButton::clicked, &app, &QCoreApplication::quit, Qt::QueuedConnection);

Remarque concernant la sécurité des threads: cette fonction peut être appelée depuis n’importe quel thread pour provoquer, en toute sécurité, la sortie de la boucle principale de l’application en cours d’exécution. Cependant, la sécurité des threads n’est pas garantie si l’objet ` QCoreApplication ` est en cours de destruction au même moment.

Remarque : cette fonction est sans danger pour les threads.

Voir également exit() et aboutToQuit().

[static] void QCoreApplication::removeLibraryPath(const QString &path)

Supprime path de la liste des chemins d'accès aux bibliothèques. Si path est vide ou ne figure pas dans la liste des chemins d'accès, celle-ci reste inchangée.

Les chemins d'accès aux bibliothèques sont réinitialisés à leurs valeurs par défaut lorsqu'une instance de ` QCoreApplication ` est détruite.

Voir également addLibraryPath(), libraryPaths() et setLibraryPaths().

void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter *filterObject)

Supprime un filtre d'événement filterObject de cet objet. La requête est ignorée si aucun filtre d'événement de ce type n'a été installé.

Tous les filtres d'événements associés à cet objet sont automatiquement supprimés lorsque celui-ci est détruit.

La suppression d’un filtre d’événement ne présente aucun risque, même pendant l’activation du filtre d’événement (c’est-à-dire à partir de la fonction nativeEventFilter()).

Voir également installNativeEventFilter().

[static] void QCoreApplication::removePostedEvents(QObject *receiver, int eventType = 0)

Supprime tous les événements de l'eventType on indiquée qui ont été ajoutés à l'aide de la fonction postEvent() pour receiver.

Les événements ne sont pas diffusés, mais supprimés de la file d’attente. Vous ne devriez jamais avoir besoin d’appeler cette fonction. Si vous l’appelez, sachez que la suppression d’événements peut entraîner la violation d’une ou plusieurs invariantes de receiver.

Si receiver vaut nullptr, les événements de eventType sont supprimés pour tous les objets. Si eventType vaut 0, tous les événements sont supprimés pour receiver. Vous ne devriez jamais appeler cette fonction avec eventType égal à 0.

Remarque : cette fonction est thread-safe.

[static] bool QCoreApplication::removeTranslator(QTranslator *translationFile)

Supprime le fichier de traduction translationFile de la liste des fichiers de traduction utilisés par cette application. (Cela ne supprime pas le fichier de traduction du système de fichiers.)

La fonction renvoie true en cas de succès et false en cas d'échec.

Voir également installTranslator(), translate() et QObject::tr().

[since 6.5] template <typename Functor> void QCoreApplication::requestPermission(const QPermission &permission, Functor &&functor)

Envoie la requête à l'adresse permission.

Lorsque la requête est prête, l'functor est appelée sous la forme functor(const QPermission &permission), où permission décrit le résultat de la requête.

La fonction functor peut être une fonction autonome ou une fonction membre statique :

qApp->requestPermission(QCameraPermission{}, &permissionUpdated);

ou un lambda :

qApp->requestPermission(QCameraPermission{}, [](const QPermission &permission) {
});

Si l’utilisateur accorde explicitement à l’application l’ permission demandée, ou s’il est établi que l’ permission ne nécessite pas d’autorisation de l’utilisateur sur la plateforme concernée, le statut sera Qt::PermissionStatus::Granted.

Si l'utilisateur refuse explicitement à l'application l'permission demandée, ou s'il est établi que l'permission n'est ni accessible ni applicable aux applications sur la plateforme concernée, le statut sera « Qt::PermissionStatus::Denied ».

Le résultat d’une requête ne sera jamais « Qt::PermissionStatus::Undetermined ».

Cette fonction a été introduite dans Qt 6.5.

Voir également ` checkPermission()` et Autorisations d'application.

[since 6.5] template <typename Functor> void QCoreApplication::requestPermission(const QPermission &permission, const QObject *context, Functor functor)

Envoie une requête à l'adresse permission, dans le contexte de context.

Lorsque la requête est prête, functor sera appelée sous la forme functor(const QPermission &permission), permission décrivant le résultat de la requête.

La fonction functor peut être une fonction autonome ou une fonction membre statique :

qApp->requestPermission(QCameraPermission{}, context, &permissionUpdated);

un lambda :

qApp->requestPermission(QCameraPermission{}, context, [](const QPermission &permission) {
});

ou un slot dans l’objet ` context ` :

qApp->requestPermission(QCameraPermission{}, this, &CamerWidget::permissionUpdated);

L’ functor sera appelée dans le thread de l’objet ` context `. Si ` context ` est détruit avant la fin de la requête, l’ functor ne sera pas appelée.

Si l’utilisateur accorde explicitement à l’application l’ permission demandée, ou s’il est établi que l’ permission ne nécessite pas d’autorisation de l’utilisateur sur la plateforme concernée, le statut sera Qt::PermissionStatus::Granted.

Si l’utilisateur refuse explicitement à l’application l’ permission demandée, ou s’il est établi que l’ permission n’est pas accessible ou applicable aux applications sur la plateforme concernée, le statut sera « Qt::PermissionStatus::Denied ».

Le résultat d’une requête ne sera jamais « Qt::PermissionStatus::Undetermined ».

Cette fonction a été introduite dans Qt 6.5.

Voir également checkPermission() et Autorisations d’application.

[static] bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event)

Envoie l'événement event directement au destinataire receiver, à l'aide de la fonction notify(). Renvoie la valeur renvoyée par le gestionnaire d'événements.

L'événement n' est pas supprimé une fois qu'il a été envoyé. L'approche habituelle consiste à créer l'événement sur la pile, par exemple :

QMouseEvent event(QEvent::MouseButtonPress, localPos, globalPos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(mainWindow, &event);

Voir également postEvent() et notify().

[static] void QCoreApplication::sendPostedEvents(QObject *receiver = nullptr, int event_type = 0)

Déclenche immédiatement tous les événements qui ont été préalablement mis en file d’attente avec la fonction ` QCoreApplication::postEvent()` et qui concernent l’objet ` receiver ` et sont de type ` event_type`.

Les événements provenant du système de fenêtrage ne sont pas diffusés par cette fonction, mais par ` processEvents()`.

Si receiver est nullptr, les événements de type event_type sont envoyés pour tous les objets. Si event_type est égal à 0, tous les événements sont envoyés pour receiver.

Voir également postEvent().

[static] void QCoreApplication::setAttribute(Qt::ApplicationAttribute attribute, bool on = true)

Définit l'attribut « attribute » si « on » est vrai ; sinon, efface cet attribut.

Voir également testAttribute().

[static] void QCoreApplication::setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)

Définit le gestionnaire d'événements du thread principal sur ` eventDispatcher`. Cela n'est possible que tant qu'aucun gestionnaire d'événements n'a encore été installé, c'est-à-dire avant l'instanciation de ` QCoreApplication `. Cette méthode prend possession de l'objet.

Voir également eventDispatcher().

[static] void QCoreApplication::setLibraryPaths(const QStringList &paths)

Définit la liste des répertoires à parcourir lors du chargement des plugins à l'aide de ` QLibrary ` sur ` paths`. Tous les chemins existants seront supprimés et la liste des chemins sera composée des chemins indiqués dans ` paths ` et du chemin d'accès à l'application.

Les chemins d’accès aux bibliothèques sont réinitialisés à leurs valeurs par défaut lorsqu’une instance de ` QCoreApplication ` est détruite.

Voir également libraryPaths(), addLibraryPath(), removeLibraryPath() et QLibrary.

[static] void QCoreApplication::setSetuidAllowed(bool allow)

Permet à l'application de s'exécuter en mode setuid sur les plateformes UNIX si la valeur de « allow » est « true ».

Si allow est à « false » (valeur par défaut) et que Qt détecte que l'application s'exécute avec un identifiant utilisateur effectif différent de l'identifiant utilisateur réel, l'application sera interrompue lors de la création d'une instance de ` QCoreApplication `.

Qt n’est pas une solution adaptée aux programmes setuid en raison de sa grande surface d’attaque. Cependant, certaines applications peuvent être amenées à s’exécuter de cette manière pour des raisons historiques. Ce drapeau empêchera Qt d’interrompre l’application lorsque cela est détecté, et doit être défini avant la création d’une instance de ` QCoreApplication `.

Voir également isSetuidAllowed().

[static] bool QCoreApplication::startingUp()

Renvoie « true » si aucun objet d'application n'a encore été créé ; sinon, renvoie « false ».

Voir également closingDown().

[static] bool QCoreApplication::testAttribute(Qt::ApplicationAttribute attribute)

Renvoie « true » si l'attribut « attribute » est défini ; sinon, renvoie « false ».

Voir également setAttribute().

[static] QString QCoreApplication::translate(const char *context, const char *sourceText, const char *disambiguation = nullptr, int n = -1)

Renvoie le texte traduit pour sourceText, en interrogeant les fichiers de traduction installés. Les fichiers de traduction sont parcourus en partant du fichier le plus récemment installé jusqu’au premier fichier installé.

QObject::tr() offre cette fonctionnalité de manière plus pratique.

context est généralement un nom de classe (par exemple, « MyDialog ») et sourceText est soit un texte en anglais, soit un court texte d'identification.

disambiguation est une chaîne d'identification, utilisée lorsque le même sourceText est employé dans différents rôles au sein d'un même contexte. Par défaut, il s'agit de nullptr.

Consultez la documentation relative à QTranslator et QObject::tr() pour plus d’informations sur les contextes, les désambiguïsations et les commentaires.

n est utilisée conjointement avec %n pour prendre en charge les formes plurielles. Consultez QObject::tr() pour plus de détails.

Si aucun des fichiers de traduction ne contient de traduction pour sourceText dans context, cette fonction renvoie un équivalent « QString » de sourceText.

Cette fonction n’est pas virtuelle. Vous pouvez utiliser d’autres techniques de traduction en créant une sous-classe de QTranslator.

Remarque : cette fonction est thread-safe.

Voir également QObject::tr(), installTranslator(), removeTranslator() et Internationalization and Translations.