QCoreApplication Class

Documentation sur les fonctions membres

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

Construit une application Qt Core. Les applications de base sont des applications sans interface utilisateur graphique. Ces applications sont utilisées dans la console ou en tant que processus serveur.

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

[virtual noexcept] QCoreApplication::~QCoreApplication()

Détruit 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 après un appel à quit() à l'intérieur de l'application ou lorsque l'utilisateur ferme toute la session de bureau.

Ce signal est particulièrement utile si votre application doit effectuer un 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, afin de s'assurer que les bibliothèques sont recherchées en premier. Si path est vide ou se trouve 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 est le répertoire d'installation des plugins, qui est INSTALL/plugins, où INSTALL est le répertoire où Qtt a été installé. La seconde est le répertoire de l'application(et non le 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 à leur valeur par défaut lorsqu'une instance de QCoreApplication est détruite.

Voir aussi removeLibraryPath(), libraryPaths() et setLibraryPaths().

[static] QString QCoreApplication::applicationDirPath()

Renvoie le répertoire qui contient 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".

Sur macOS et iOS, cette fonction pointera vers le répertoire contenant l'exécutable, qui peut se trouver à l'intérieur d'un paquet d'applications (si l'application est groupée).

Sur Android, cela pointera vers le répertoire contenant l'exécutable, qui peut se trouver dans l'APK de l'application (s'il a été construit avec la prise en charge des bibliothèques non compressées).

Voir aussi applicationFilePath().

[static] QString QCoreApplication::applicationFilePath()

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

Par exemple, si vous avez installé Qt XML 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 en cours pour l'application.

[static] QStringList QCoreApplication::arguments()

Renvoie la liste des arguments de la ligne de commande.

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

L'appel à 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 passés au constructeur. Dans ce cas, des problèmes d'encodage peuvent survenir.

Sinon, les arguments() sont construits à partir de la valeur de retour de GetCommandLine(). Par conséquent, la chaîne donnée par arguments().at(0) peut ne pas être le programme exact utilisé pour démarrer l'application sous Windows.

Voir aussi applicationFilePath() et QCommandLineParser.

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

Vérifie l'état de la demande d'information donnée. permission

Si le résultat est Qt::PermissionStatus::Undetermined, la permission doit être demandée via requestPermission() pour déterminer l'intention de l'utilisateur.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi requestPermission() et Permissions d'application.

[static] bool QCoreApplication::closingDown()

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

Voir aussi startingUp().

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

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

[static] QAbstractEventDispatcher *QCoreApplication::eventDispatcher()

Renvoie un pointeur sur l'objet de distribution d'événements pour le thread principal. S'il n'existe pas de distributeur d'événements pour le thread, cette fonction renvoie nullptr.

Voir également setEventDispatcher().

[static] int QCoreApplication::exec()

Entre dans la boucle d'événements principale et attend que exit() soit appelé. Renvoie la valeur qui a été transmise à 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 les événements du système de fenêtres et les distribue aux widgets de l'application.

Pour que votre application effectue un traitement inactif (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 d'attente de 0ns. Des schémas de traitement au ralenti plus avancés peuvent être réalisés à l'aide de 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, car sur certaines plates-formes, l'appel exec() peut ne pas être retourné. 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 premier niveau. Il n'est donc pas garanti que l'application aura le temps de quitter 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 quitter avec un code de retour.

Après l'appel de cette fonction, l'application quitte la boucle événementielle principale et revient à 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, un returnCode de 0 signifie un succès, et toute valeur non nulle indique une erreur.

Une bonne pratique consiste à toujours connecter les signaux à ce slot à l'aide d'une connexion 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 en file d'attente garantit que le slot ne sera pas invoqué avant que le contrôle n'entre dans la boucle d'événements principale.

Notez que contrairement à la fonction du même nom de la bibliothèque C, cette fonction retourne à l ' appelant - c'est le traitement de l'événement qui s'arrête.

Notez également que cette fonction n'est pas à l'abri des 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 sortir d'un autre thread, utilisez QCoreApplication::quit() ou appelez cette fonction depuis le thread principal avec QMetaMethod::invokeMethod().

Voir aussi 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 fil d'exécution principal.

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

Si plusieurs filtres d'événements sont installés, le dernier filtre installé 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, c'est-à-dire que le fichier de traduction le plus récemment installé est recherché en premier et le premier fichier de traduction installé est recherché en dernier. La recherche s'arrête dès qu'une traduction contenant une chaîne de caractères correspondante est trouvée.

L'installation ou la suppression d'un QTranslator ou la modification d'un QTranslator installé génère un événement LanguageChange pour l'instance QCoreApplication. Une instance QApplication propagera l'événement à tous les widgets de niveau supérieur, où une réimplémentation de changeEvent peut retraduire l'interface utilisateur en transmettant des chaînes visibles par l'utilisateur via la fonction tr() aux fixateurs de propriétés respectifs. 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 Prepare for Dynamic Language Changes.

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

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

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

[static] bool QCoreApplication::isSetuidAllowed()

Retourne vrai si l'application est autorisée à exécuter setuid sur les plates-formes UNIX.

Voir aussi QCoreApplication::setSetuidAllowed().

[static] QStringList QCoreApplication::libraryPaths()

Renvoie une liste de chemins que l'application recherchera lors du chargement dynamique des bibliothèques.

La valeur de retour de cette fonction peut changer lors de la création d'un site QCoreApplication. Il n'est pas recommandé de l'appeler avant la création d'un site . Il n'est pas recommandé de l'appeler avant de créer un QCoreApplication. Le répertoire de l'exécutable de l'application(pas le répertoire de travail) fait partie de la liste s'il est connu. Pour qu'il soit connu, un QCoreApplication doit être construit, car il utilisera argv[0] pour le trouver.

Qt fournit des chemins d'accès aux bibliothèques par défaut, mais ils peuvent également être définis à l'aide du 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 peut ne pas être trouvé avant la création de QCoreApplication. S'il n'est pas trouvé lors de l'appel de cette fonction, les chemins d'accès aux bibliothèques par défaut seront utilisés.

La liste inclura le répertoire d'installation des plugins s'il existe (le répertoire d'installation par défaut des plugins est INSTALL/plugins, où INSTALL est le répertoire où Qtt a été installé). Les entrées de la variable d'environnement QT_PLUGIN_PATH, séparées par deux points, sont toujours ajoutées. Le répertoire d'installation du plugin (et son existence) peut changer lorsque le répertoire de l'exécutable de l'application est connu.

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

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

Envoie event à 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 dans n'importe quel thread.

Pour certains types d'événements (par exemple, les événements liés à la souris et aux touches), 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 qu'il renvoie false).

Les événements peuvent être traités de cinq manières différentes ; 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émentation de paintEvent(), mousePressEvent() et ainsi de suite. Il s'agit de 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 permet un contrôle total, mais 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 pour tous les widgets, il est donc tout aussi puissant que la réimplémentation de notify() ; en outre, il est possible d'avoir plus d'un filtre d'événements global pour l'application. Les filtres d'événements globaux voient 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 vivent dans le fil d'exécution principal.
4. Réimplémenter QObject::event() (comme le fait QWidget ). Si vous faites cela, vous obtiendrez les appuis sur la touche Tab, et vous verrez les événements avant tout filtre d'événement spécifique au widget.
5. Installer un filtre d'événements sur l'objet. Un tel filtre récupère tous les événements, y compris les appuis sur les touches Tab et Shift+Tab, tant qu'ils ne modifient pas le widget de focus.

Orientations futures : Cette fonction ne sera pas appelée pour les objets qui vivent en dehors du fil d'exécution principal dans Qt 7. Les applications qui ont besoin de cette fonctionnalité devraient trouver d'autres solutions pour leurs besoins d'inspection d'événements en attendant. Le changement pourrait être étendu au thread principal, ce qui rendrait cette fonction obsolète.

Voir aussi 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 récepteur de l'événement, à une file d'attente d'événements et retourne immédiatement.

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

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

Les événements sont triés dans l'ordre décroissant de priority, c'est-à-dire que les événements ayant une valeur élevée de priority sont mis en file d'attente avant les événements ayant une valeur plus faible de priority. L'adresse priority peut être n'importe quelle valeur entière, c'est-à-dire comprise entre INT_MAX et INT_MIN, inclusivement ; voir Qt::EventPriority pour plus de détails. Les événements ayant la même valeur priority seront traités dans l'ordre affiché.

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

Remarque : cette fonction est à l'épreuve des 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'adresse flags spécifiée.

L'utilisation de cette fonction est déconseillée. Préférez plutôt déplacer les longues opérations du fil d'exécution de l'interface graphique vers un fil d'exécution auxiliaire et évitez complètement le traitement des boucles 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 permanence, 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 DeferredDelete pour fonctionner correctement. Une alternative serait d'appeler sendPostedEvents() à partir de cette boucle locale.

L'appel à cette fonction traite les événements uniquement pour le thread appelant, et revient après que tous les événements disponibles ont été traités. Les événements disponibles sont les événements 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 prochain cycle de traitement des événements.

Remarque : cette fonction est à l'épreuve des threads.

Voir aussi 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'à ce que deadline ait expiré, ou jusqu'à ce qu'il n'y ait plus d'événements à traiter, selon ce qui se produit en premier.

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

L'appel à cette fonction traite les événements uniquement pour le thread appelant.

Remarque : Cette fonction est à l'épreuve des threads.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi 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 quitter.

La demande peut être ignorée si l'application empêche la sortie, par exemple si l'une de ses fenêtres ne peut pas être fermée. L'application peut y remédier en gérant l'événement QEvent::Quit au niveau de l'application, ou les événements QEvent::Close pour les fenêtres individuelles.

Si la sortie n'est pas interrompue, l'application se termine avec le 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 sûre pour les threads.

Une bonne pratique consiste à toujours connecter les signaux à ce slot à l'aide d'une connexion 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 pas d'effet et l'application ne sort jamais. L'utilisation d'une connexion en file d'attente garantit que le slot ne sera pas invoqué 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);

Note sur la sécurité des threads: cette fonction peut être appelée à partir de n'importe quel thread pour provoquer la sortie de la boucle principale de l'application en cours d'exécution, sans risque pour les threads. Cependant, la sécurité des threads n'est pas garantie si l'objet QCoreApplication est détruit en même temps.

Remarque : cette fonction est sans risque pour les threads.

Voir aussi exit() et aboutToQuit().

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

Supprime path de la liste des chemins d'accès à la bibliothèque. Si path est vide ou ne figure pas dans la liste des chemins, celle-ci n'est pas modifiée.

Les chemins d'accès aux bibliothèques sont rétablis par défaut lorsqu'une instance de QCoreApplication est détruite.

Voir aussi addLibraryPath(), libraryPaths() et setLibraryPaths().

void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter *filterObject)

Supprime un événement filterObject de cet objet. La demande est ignorée si un tel filtre d'événement n'a pas été installé.

Tous les filtres d'événements de cet objet sont automatiquement supprimés lorsque l'objet est détruit.

Il est toujours prudent de supprimer un filtre d'événement, même pendant l'activation du filtre d'événement (c'est-à-dire à partir de la fonction nativeEventFilter()).

Voir aussi installNativeEventFilter().

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

Supprime tous les événements de l'adresse eventType qui ont été postés à l'aide de postEvent() pour receiver.

Les événements ne sont pas distribué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 le fait de tuer des événements peut amener receiver à rompre un ou plusieurs invariants.

Si receiver est nullptr, les événements de eventType sont supprimés pour tous les objets. Si eventType est 0, tous les événements sont supprimés pour receiver. Vous ne devez jamais appeler cette fonction si eventType vaut 0.

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

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

Supprime le fichier de traduction translationFile de la liste des fichiers de traduction utilisés par cette application. (Elle 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)

Demande l'adresse permission.

Lorsque la demande est prête, functor sera appelé en tant que functor(const QPermission &permission), et permission décrira le résultat de la demande.

L'adresse functor peut être une fonction membre autonome ou statique :

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

ou un lambda :

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

Si l'utilisateur accorde explicitement à l'application la demande permission, ou si l'on sait que permission ne nécessite pas d'autorisation de la part de l'utilisateur sur la plate-forme donnée, le statut sera Qt::PermissionStatus::Granted.

Si l'utilisateur refuse explicitement à l'application la demande permission, ou si l'on sait que permission n'est pas accessible ou applicable aux applications sur la plate-forme donnée, l'état sera Qt::PermissionStatus::Denied.

Le résultat d'une demande ne sera jamais Qt::PermissionStatus::Undetermined.

Cette fonction a été introduite dans Qt 6.5.

Voir également checkPermission() et Permissions d'application.

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

Demande l'adresse permission, dans le contexte de context.

Lorsque la demande est prête, functor sera appelé en tant que functor(const QPermission &permission), et permission décrira le résultat de la demande.

functor peut être une fonction membre autonome ou 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);

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

permission Si l'utilisateur accorde explicitement à l'application l'autorisation demandée permission, ou si l'on sait que l'autorisation de l'utilisateur n'est pas nécessaire sur la plate-forme donnée, l'état sera Qt::PermissionStatus::Granted.

Si l'utilisateur refuse explicitement à l'application la demande permission, ou si l'on sait que permission n'est pas accessible ou applicable aux applications sur la plate-forme donnée, l'état sera Qt::PermissionStatus::Denied.

Le résultat d'une demande ne sera jamais Qt::PermissionStatus::Undetermined.

Cette fonction a été introduite dans Qt 6.5.

Voir également checkPermission() et Permissions d'application.

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

Envoie l'événement event directement au récepteur receiver, en utilisant la fonction notify(). Renvoie la valeur renvoyée par le gestionnaire d'événement.

L'événement n' est pas supprimé lorsque l'événement a été envoyé. L'approche normale 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)

Distribue immédiatement tous les événements qui ont été précédemment mis en file d'attente avec QCoreApplication::postEvent(), qui concernent l'objet receiver et qui ont le type d'événement event_type.

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

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

Voir aussi postEvent().

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

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

Voir aussi testAttribute().

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

Définit le distributeur d'événements pour le thread principal à eventDispatcher. Cela n'est possible que si aucun distributeur d'événements n'est encore installé. C'est-à-dire avant que QCoreApplication n'ait été instancié. 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 à rechercher lors du chargement des plugins avec QLibrary à paths. Tous les chemins d'accès existants seront supprimés et la liste des chemins d'accès se composera des chemins d'accès indiqués dans paths et du chemin d'accès à l'application.

Les chemins d'accès à la bibliothèque sont réinitialisés à leur valeur par défaut lorsqu'une instance de QCoreApplication est détruite.

Voir aussi libraryPaths(), addLibraryPath(), removeLibraryPath() et QLibrary.

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

Permet à l'application de fonctionner avec setuid sur les plates-formes UNIX si allow est vrai.

Si allow est faux (par défaut) et que Qt détecte que l'application s'exécute avec un identifiant d'utilisateur effectif différent de l'identifiant d'utilisateur réel, l'application sera interrompue lorsqu'une instance QCoreApplication sera créée.

Qt n'est pas une solution appropriée pour les programmes setuid en raison de sa grande surface d'attaque. Cependant, certaines applications peuvent devoir être exécutées de cette manière pour des raisons historiques. Ce drapeau empêchera Qt XML d'interrompre l'application lorsque cela est détecté, et doit être défini avant qu'une instance QCoreApplication ne soit créée.

Voir aussi isSetuidAllowed().

[static] bool QCoreApplication::startingUp()

Renvoie true si un objet d'application n'a pas encore été créé ; sinon, renvoie false.

Voir aussi closingDown().

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

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

Voir aussi setAttribute().

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

Renvoie le texte de la traduction de sourceText, en interrogeant les fichiers de traduction installés. Les fichiers de traduction sont recherchés à partir 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 anglais, soit un court texte d'identification.

disambiguation est une chaîne d'identification, pour les cas où le même sourceText est utilisé dans différents rôles dans le même contexte. Par défaut, il s'agit de nullptr.

Voir la documentation de QTranslator et QObject::tr() pour plus d'informations sur les contextes, les désambiguïsations et les commentaires.

n est utilisé en conjonction avec %n pour prendre en charge les formes plurielles. Voir 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 sous-classant QTranslator.

Remarque : cette fonction est à l'épreuve des threads.

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