QObject Class

Documentation des fonctions membres

[explicit invokable] QObject::QObject(QObject *parent = nullptr)

Crée un objet dont l'objet parent est parent.

Le parent d’un objet peut être considéré comme le propriétaire de cet objet. Par exemple, un dialog box est le parent des boutons OK et Cancel qu’il contient.

Le destructeur d’un objet parent détruit tous les objets enfants.

Définir parent sur nullptr crée un objet sans parent. Si l’objet est un widget, il deviendra une fenêtre de niveau supérieur.

Voir également parent(), findChild() et findChildren().

[virtual noexcept] QObject::~QObject()

Détruit l'objet et supprime tous ses objets enfants.

Tous les signaux entrants et sortants de l’objet sont automatiquement déconnectés, et tous les événements en attente pour cet objet sont supprimés de la file d’attente des événements. Cependant, il est souvent plus sûr d’utiliser ` deleteLater()` plutôt que de supprimer directement une sous-classe de ` QObject `.

Voir également deleteLater().

[noexcept] bool QObject::blockSignals(bool block)

Si ` block ` est vrai, les signaux émis par cet objet sont bloqués (c'est-à-dire que l'émission d'un signal ne déclenchera aucune action sur les éléments qui y sont connectés). Si ` block ` est faux, aucun blocage de ce type ne se produira.

La valeur renvoyée est la valeur précédente de signalsBlocked().

Notez que le signal destroyed() sera émis même si les signaux de cet objet ont été bloqués.

Les signaux émis pendant le blocage ne sont pas mis en mémoire tampon.

Voir également signalsBlocked() et QSignalBlocker.

[virtual protected] void QObject::childEvent(QChildEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir des événements liés aux enfants. L'événement est transmis via le paramètre event.

QEvent::ChildAdded Les événements ` QEvent::ChildRemoved ` sont envoyés aux objets lorsque des enfants sont ajoutés ou supprimés. Dans les deux cas, vous ne pouvez compter que sur le fait que l’enfant soit un ` QObject`, ou, si ` isWidgetType()` renvoie ` true`, un ` QWidget`. (En effet, dans le cas de ` ChildAdded `, l’enfant n’est pas encore entièrement construit, et dans le cas de ` ChildRemoved `, il a peut-être déjà été détruit.)

QEvent::ChildPolished Des événements sont envoyés aux widgets lorsque des enfants sont finalisés, ou lorsque des enfants déjà finalisés sont ajoutés. Si vous recevez un événement « child polished », la construction de l’enfant est généralement terminée. Cependant, cela n’est pas garanti, et plusieurs événements « polished » peuvent être émis pendant l’exécution du constructeur d’un widget.

Pour chaque widget enfant, vous recevez un événement « ChildAdded », zéro ou plusieurs événements « ChildPolished » et un événement « ChildRemoved ».

L’événement ` ChildPolished ` est omis si un enfant est supprimé immédiatement après avoir été ajouté. Si un enfant fait l’objet de plusieurs opérations de « polish » au cours de sa construction et de sa destruction, vous pouvez recevoir plusieurs événements `child polished` pour le même enfant, chacun avec une table virtuelle différente.

Voir également event().

const QObjectList &QObject::children() const

Renvoie une liste d'objets enfants. La classe ` QObjectList ` est définie dans le fichier d'en-tête ` <QObject> ` comme suit :

typedef QList<QObject*> QObjectList;

Le premier enfant ajouté est l’objet ` first ` de la liste et le dernier enfant ajouté est l’objet ` last ` de la liste ; en d’autres termes, les nouveaux enfants sont ajoutés à la fin.

Notez que l’ordre de la liste change lorsque les enfants de ` QWidget ` sont de type ` raised ` ou ` lowered`. Un widget qui est « élevé » devient le dernier objet de la liste, et un widget qui est « abaissé » devient le premier objet de la liste.

Voir également findChild(), findChildren(), parent() et setParent().

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion entre l'type spécifiée, provenant de l'signal de l'objet sender, et l'method de l'objet receiver. Renvoie un descripteur de connexion qui pourra être utilisé ultérieurement pour la déconnecter.

Le descripteur de connexion sera invalide si la connexion ne peut pas être établie, par exemple si les paramètres sont invalides. Vous pouvez vérifier si l’ QMetaObject::Connection est valide en le convertissant en booléen.

Cette fonction fonctionne de la même manière que ` connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) `, mais elle utilise ` QMetaMethod ` pour spécifier le signal et la méthode.

Voir également connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion entre l’ type spécifié, issu de l’ signal de l’objet sender, et le method de l’objet receiver. Renvoie un descripteur de connexion qui peut être utilisé ultérieurement pour la déconnecter.

Vous devez utiliser les macros ` SIGNAL() ` et ` SLOT() ` lorsque vous spécifiez ` signal ` et ` method`, par exemple :

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

Cet exemple garantit que l'étiquette affiche toujours la valeur actuelle de la barre de défilement. Notez que les paramètres signal et slots ne doivent contenir aucun nom de variable, mais uniquement le type. Par exemple, le code suivant ne fonctionnerait pas et renverrait false :

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

Un signal peut également être connecté à un autre signal :

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

MyWidget::MyWidget()
{
    myButton = new QPushButton(this);
    connect(myButton, SIGNAL(clicked()),
            this, SIGNAL(buttonClicked()));
}

Dans cet exemple, le constructeur MyWidget transmet un signal provenant d’une variable membre privée et le rend accessible sous un nom lié à MyWidget.

Un signal peut être connecté à plusieurs slots et signaux. Plusieurs signaux peuvent être connectés à un même slot.

Si un signal est connecté à plusieurs slots, ceux-ci sont activés dans l’ordre dans lequel les connexions ont été établies, lorsque le signal est émis.

La fonction renvoie un ` QMetaObject::Connection ` représentant un descripteur de connexion si elle parvient à connecter le signal au slot. Le descripteur de connexion sera invalide si la connexion ne peut pas être établie, par exemple si ` QObject ` ne parvient pas à vérifier l’existence de ` signal ` ou de ` method`, ou si leurs signatures ne sont pas compatibles. Vous pouvez vérifier si le descripteur est valide en le convertissant en `bool`.

Par défaut, un signal est émis pour chaque connexion établie ; deux signaux sont émis en cas de connexions en double. Vous pouvez interrompre toutes ces connexions à l’aide d’un seul appel à ` disconnect()`. Si vous passez l'Qt::UniqueConnection type , la connexion ne sera établie que si elle n'est pas en double. S'il existe déjà un doublon (exactement le même signal vers exactement le même slot sur les mêmes objets), la connexion échouera et la fonction `connect` renverra un ` QMetaObject::Connection` invalide.

Le paramètre facultatif ` type ` décrit le type de connexion à établir. Il détermine notamment si un signal donné est transmis immédiatement à un slot ou mis en file d’attente pour être transmis ultérieurement. Si le signal est mis en file d’attente, les paramètres doivent être de types connus du système de méta-objets de Qt, car Qt doit copier les arguments pour les stocker dans un événement en arrière-plan. Si vous essayez d’utiliser une connexion mise en file d’attente et que vous obtenez le message d’erreur

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

appelez qRegisterMetaType() pour enregistrer le type de données avant d’établir la connexion.

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

Voir également disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE() et Différences entre les connexions basées sur des chaînes de caractères et celles basées sur des foncteurs.

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

Crée une connexion entre signal dans l'objet sender et functor, puis renvoie un descripteur vers cette connexion

Le signal doit être une fonction déclarée en tant que signal dans l’en-tête. La fonction de slot peut être n’importe quelle fonction ou foncteur pouvant être connecté au signal. Une fonction de slot peut être connectée à un signal donné si ce dernier possède au moins autant d’arguments que la fonction de slot. Il doit exister une conversion implicite entre les types des arguments correspondants du signal et du slot.

Exemple :

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, someFunction);
}

Les expressions lambda peuvent également être utilisées :

    QByteArray page = "...";
    QTcpSocket *socket = new QTcpSocket;
    socket->connectToHost("qt-project.org", 80);
    QObject::connect(socket, &QTcpSocket::connected, [=] () {
            socket->write("GET " + page + "\r\n");
        });

La connexion se déconnectera automatiquement si l'émetteur est détruit. Cependant, vous devez veiller à ce que tous les objets utilisés au sein du foncteur soient toujours actifs lorsque le signal est émis.

C’est pourquoi il est recommandé d’utiliser la surcharge de la fonction `connect()` qui prend également un ` QObject ` comme récepteur/contexte. Il est possible de désactiver l’utilisation de la surcharge sans contexte en définissant la macro ` QT_NO_CONTEXTLESS_CONNECT `.

Les fonctions surchargées peuvent être résolues à l’aide de ` qOverload`.

Remarque : cette fonction est thread-safe.

QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const

Relie signal de l'objet sender à method de cet objet.

Équivalent à connect(sender, signal, this, method, type).

Chaque connexion établie émet un signal ; ainsi, les connexions en double émettent deux signaux. Vous pouvez interrompre une connexion à l'aide de la fonction disconnect().

Remarque : cette fonction est thread-safe.

Voir également disconnect().

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion d'un objet ` type ` donné, provenant de ` signal ` dans ` sender `, vers ` functor ` afin de l'intégrer dans une boucle d'événements spécifique de ` context`, et renvoie un descripteur vers cette connexion.

Le signal doit être une fonction déclarée en tant que signal dans l’en-tête. La fonction slot peut être n’importe quelle fonction ou foncteur pouvant être connecté au signal. Une fonction slot peut être connectée à un signal donné si ce dernier possède au moins autant d’arguments que la fonction slot. Il doit exister une conversion implicite entre les types des arguments correspondants dans le signal et dans le slot.

Exemple :

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
}

Les expressions lambda peuvent également être utilisées :

QByteArray page = "...";
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
        socket->write("GET " + page + "\r\n");
    }, Qt::AutoConnection);

La connexion se déconnectera automatiquement si l'émetteur ou le contexte est détruit. Cependant, vous devez veiller à ce que tous les objets utilisés au sein du foncteur soient encore actifs lorsque le signal est émis.

Les fonctions surchargées peuvent être résolues à l’aide de ` qOverload`.

Remarque : cette fonction est thread-safe.

[static] template <typename PointerToMemberFunction> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

Crée une connexion entre l'type donné de l'signal dans l'objet sender et le method dans l'objet receiver. Renvoie un descripteur de connexion qui peut être utilisé pour la déconnecter ultérieurement.

Le signal doit être une fonction déclarée en tant que signal dans l’en-tête. La fonction de slot peut être n’importe quelle fonction membre pouvant être connectée au signal. Un slot peut être connecté à un signal donné si ce dernier possède au moins autant d’arguments que le slot, et s’il existe une conversion implicite entre les types des arguments correspondants dans le signal et dans le slot.

Exemple :

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                label,  &QLabel::setText);

Cet exemple garantit que l’étiquette affiche toujours le texte actuel de la zone de saisie.

Un signal peut être connecté à plusieurs slots et signaux. Plusieurs signaux peuvent être connectés à un même slot.

Si un signal est connecté à plusieurs slots, ceux-ci sont activés dans le même ordre que celui dans lequel la connexion a été établie, lorsque le signal est émis

La fonction renvoie un descripteur de connexion si elle parvient à connecter le signal au slot. Le descripteur de connexion sera invalide si la connexion ne peut pas être établie, par exemple si la fonction ` QObject ` ne parvient pas à vérifier l’existence de ` signal ` (si celui-ci n’a pas été déclaré comme signal). Vous pouvez vérifier si l’ QMetaObject::Connection est valide en le convertissant en booléen.

Par défaut, un signal est émis pour chaque connexion que vous établissez ; deux signaux sont émis en cas de connexions en double. Vous pouvez interrompre toutes ces connexions à l’aide d’un seul appel à disconnect(). Si vous passez l’ type Qt::UniqueConnection , la connexion ne sera établie que si elle n’est pas en double. S’il existe déjà un doublon (exactement le même signal vers exactement le même slot sur les mêmes objets), la connexion échouera et connect renverra un QMetaObject::Connection invalide.

Le paramètre facultatif ` type ` décrit le type de connexion à établir. Il détermine notamment si un signal donné est transmis immédiatement à un slot ou mis en file d’attente pour être transmis ultérieurement. Si le signal est mis en file d’attente, les paramètres doivent être de types reconnus par le système de méta-objets de Qt, car Qt doit copier les arguments pour les stocker dans un événement en arrière-plan. Si vous essayez d’utiliser une connexion en file d’attente et que vous obtenez le message d’erreur

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

, veillez à déclarer le type d’argument avec Q_DECLARE_METATYPE

Les fonctions surchargées peuvent être résolues à l'aide de qOverload.

Remarque : cette fonction est thread-safe.

Voir également Différences entre les connexions basées sur des chaînes de caractères et celles basées sur des foncteurs.

[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)

Cette fonction virtuelle est appelée lorsqu'un élément a été connecté à ` signal ` dans cet objet.

Si vous souhaitez comparer la propriété ` signal ` à un signal spécifique, vous pouvez utiliser la fonction ` QMetaMethod::fromSignal()` comme suit :

    if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
        // signal is valueChanged
    }

Voir également connect() et disconnectNotify().

[virtual protected] void QObject::customEvent(QEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir des événements personnalisés. Les événements personnalisés sont des événements définis par l'utilisateur dont la valeur de type est au moins aussi grande que l'élément « QEvent::User » de l'énumération « QEvent::Type » ; il s'agit généralement d'une sous-classe de « QEvent ». L'événement est transmis via le paramètre « event ».

Voir également event() et QEvent.

[slot] void QObject::deleteLater()

Planifie la suppression de cet objet.

L'objet sera supprimé lorsque le contrôle reviendra à la boucle d'événements. Si la boucle d'événements n'est pas en cours d'exécution lorsque cette fonction est appelée (par exemple, si deleteLater() est appelée sur un objet avant l'appel de ` QCoreApplication::exec()`), l'objet sera supprimé dès que la boucle d'événements sera lancée. Si deleteLater() est appelée après l’arrêt de la boucle d’événements principale, l’objet ne sera pas supprimé. Si deleteLater() est appelée sur un objet résidant dans un thread dont la boucle d’événements n’est pas en cours d’exécution, l’objet sera détruit à la fin du thread.

Une pratique courante lors de l’utilisation d’un QObject de travail dans une QThread consiste à connecter le signal « finished() » du thread au slot « deleteLater() » du de travail afin de garantir sa suppression en toute sécurité :

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

Notez que le fait d’entrer dans une nouvelle boucle d’événements ou d’en sortir (par exemple, en ouvrant une boîte de dialogue modale) n’ entraînera pas la suppression différée ; pour que l’objet soit supprimé, le contrôle doit revenir à la boucle d’événements à partir de laquelle deleteLater() a été appelé. Cela ne s’applique pas aux objets supprimés alors qu’une boucle d’événements précédente et imbriquée était encore en cours d’exécution : la boucle d’événements Qt supprimera ces objets dès que la nouvelle boucle d’événements imbriquée démarrera.

Dans les situations où Qt ne pilote pas le répartiteur d'événements via, par exemple, ` QCoreApplication::exec()` ou ` QEventLoop::exec()`, les suppressions différées ne seront pas traitées automatiquement. Pour garantir la suppression différée dans ce scénario, la solution de contournement suivante peut être utilisée :

const auto *eventDispatcher = QThread::currentThread()->eventDispatcher();
QObject::connect(eventDispatcher, &QAbstractEventDispatcher::aboutToBlock,
    QThread::currentThread(), []{
        if (QThread::currentThread()->loopLevel() == 0)
            QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
    }
);

Remarque : cette fonction est thread-safe.

Voir également ` destroyed()` et ` QPointer`.

[signal] void QObject::destroyed(QObject *obj = nullptr)

Ce signal est émis juste avant la destruction de l'objet obj, une fois que toutes les instances de QPointer ont été notifiées, et il ne peut pas être bloqué.

Tous les enfants de l'objet sont détruits immédiatement après l'émission de ce signal.

Voir également deleteLater() et QPointer.

Déconnecter une connexion.

Si connection est de type invalid ou a déjà été déconnecté, ne rien faire et renvoyer false.

Ces fonctions ont été introduites dans Qt 6.12.

Voir aussi connect().

[static] bool QObject::disconnect(const QMetaObject::Connection &connection)

Déconnecte connection et le réinitialise à invalid.

Si connection n'est pas valide ou a déjà été déconnecté, ne fait rien et renvoie false.

Voir également QT_NO_DISCONNECT_CONST_CONNECTION et connect().

[static] bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method)

Déconnecte signal dans l'objet sender de method dans l'objet receiver. Renvoie true si la connexion est interrompue avec succès ; sinon, renvoie false.

Cette fonction offre les mêmes possibilités que disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) mais utilise QMetaMethod pour représenter le signal et la méthode à déconnecter.

De plus, cette fonction renvoie `false` et aucun signal ni slot n’est déconnecté si :

1. signal n’est pas un membre de la classe émettrice ou de l’une de ses classes parentes.
2. method n’est pas un membre de la classe réceptrice ou de l’une de ses classes parentes.
3. signal l’instance ne représente pas un signal.

Pour éviter toute incompatibilité, enregistrez le descripteur de connexion renvoyé par connect() et utilisez-le dans l’appel à disconnect().

QMetaMethod() peut être utilisé comme caractère générique dans le sens de « n’importe quel signal » ou « n’importe quel slot dans l’objet récepteur ». De la même manière, nullptr peut être utilisé pour receiver dans le sens de « n’importe quel objet récepteur ». Dans ce cas, la méthode doit également être de type QMetaMethod(). Le paramètre sender ne doit jamais être de type nullptr.

Voir également disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

[static] bool QObject::disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)

Déconnecte l'signal, situé dans l'objet sender, de l'method, situé dans l'objet receiver. Renvoie true si la connexion est interrompue avec succès ; sinon, renvoie false.

Une connexion signal-slot est supprimée lorsque l’un des objets concernés est détruit.

La fonction disconnect() est généralement utilisée de trois manières, comme le montrent les exemples suivants.

1. Déconnecter tout ce qui est connecté aux signaux d’un objet :

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

   équivalent à la fonction surchargée non statique

       myObject->disconnect();

2. Déconnecter tout ce qui est relié à un signal spécifique :

       QObject::disconnect(myObject, SIGNAL(mySignal()), nullptr, nullptr);

   équivalent à la fonction surchargée non statique

       myObject->disconnect(SIGNAL(mySignal()));

3. Déconnecter un récepteur spécifique :

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

   équivalent à la fonction surchargée non statique

       myObject->disconnect(myReceiver);

Pour éviter toute incompatibilité, enregistrez le descripteur de connexion renvoyé par connect() et utilisez-le dans l’appel à disconnect().

nullptr peut être utilisé comme caractère générique, signifiant respectivement « n’importe quel signal », « n’importe quel objet récepteur » ou « n’importe quel slot de l’objet récepteur ».

L’ sender ne peut en aucun cas être nullptr. (Vous ne pouvez pas déconnecter les signaux de plusieurs objets en un seul appel.)

Si signal est nullptr, il déconnecte receiver et method de tout signal. Sinon, seul le signal spécifié est déconnecté.

Si receiver vaut nullptr, cela déconnecte tout ce qui est connecté à signal. Sinon, les slots des objets autres que receiver ne sont pas déconnectés.

Si ` method ` est ` nullptr`, tout ce qui est connecté à ` receiver` est déconnecté. Sinon, seuls les slots nommés ` method ` seront déconnectés, et tous les autres slots resteront inchangés. L’ method doit être ` nullptr ` si ` receiver ` est omis ; il n’est donc pas possible de déconnecter un slot portant un nom spécifique sur tous les objets.

Remarque : cette fonction est thread-safe.

Voir aussi connect().

bool QObject::disconnect(const QObject *receiver, const char *method = nullptr) const

Déconnecte tous les signaux de cet objet de la liste method de receiver.

Pour éviter toute incompatibilité, enregistrez le descripteur de connexion renvoyé par connect() et utilisez-le dans l’appel à disconnect().

Une connexion signal-slot est supprimée lorsque l’un des objets impliqués est détruit.

bool QObject::disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const

Déconnecte signal de method de receiver.

Pour éviter toute incompatibilité, enregistrez le descripteur de connexion renvoyé par connect() et utilisez-le dans l’appel à disconnect().

Une connexion signal-slot est supprimée lorsque l’un des objets impliqués est détruit.

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

[static] template <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

Déconnecte signal dans l'objet sender de method dans l'objet receiver. Renvoie true si la connexion est interrompue avec succès ; sinon, renvoie false.

Une connexion signal-slot est supprimée lorsque l'un des objets concernés est détruit.

La fonction disconnect() est généralement utilisée de trois façons, comme le montrent les exemples suivants.

1. Déconnecter tout ce qui est connecté aux signaux d’un objet :

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

2. Déconnecter tout ce qui est connecté à un signal spécifique :

       QObject::disconnect(myObject, &MyObject::mySignal, nullptr, nullptr);

3. Déconnecter un récepteur spécifique :

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

4. Déconnecter une connexion entre un signal spécifique et un emplacement spécifique :

       QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                       label,  &QLabel::setText);

nullptr peut être utilisé comme caractère générique, signifiant respectivement « n'importe quel signal », « n'importe quel objet récepteur » ou « n'importe quel emplacement dans l'objet récepteur ».

L'sender ne peut en aucun cas être nullptr. (Vous ne pouvez pas déconnecter des signaux de plusieurs objets en un seul appel.)

Si signal est nullptr, cela déconnecte receiver et method de tout signal. Sinon, seul le signal spécifié est déconnecté.

Si receiver est nullptr, cela déconnecte tout ce qui est connecté à signal. Sinon, seuls les slots du récepteur spécifié sont déconnectés. La fonction disconnect() avec un receiver non nul déconnecte également les fonctions de slot qui étaient connectées avec receiver comme objet de contexte.

Si method est nullptr, cela déconnecte tout ce qui est connecté à receiver. Sinon, seuls les slots nommés method seront déconnectés, et tous les autres slots resteront inchangés. Le method doit être nullptr si receiver est omis ; il n’est donc pas possible de déconnecter un slot portant un nom spécifique sur tous les objets.

Remarque : cette fonction est thread-safe.

Voir aussi connect().

[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)

Cette fonction virtuelle est appelée lorsqu'un élément a été déconnecté de signal dans cet objet.

Voir connectNotify() pour un exemple illustrant comment comparer signal à un signal spécifique.

Si tous les signaux ont été déconnectés de cet objet (par exemple, si l’argument signal de la fonction disconnect() était nullptr), la fonction disconnectNotify() n’est appelée qu’une seule fois, et l’ signal sera une valeur non valide QMetaMethod (la fonctionQMetaMethod::isValid() renvoie false).

Voir également disconnect() et connectNotify().

void QObject::dumpObjectInfo() const

Affiche dans la sortie de débogage des informations concernant les connexions de signaux, etc., pour cet objet.

Voir également ` dumpObjectTree()`.

void QObject::dumpObjectTree() const

Affiche l'arborescence des éléments enfants dans la sortie de débogage.

Voir aussi dumpObjectInfo().

QList<QByteArray> QObject::dynamicPropertyNames() const

Renvoie les noms de toutes les propriétés qui ont été ajoutées dynamiquement à l'objet à l'aide de la fonction ` setProperty()`.

[virtual] bool QObject::event(QEvent *e)

Cette fonction virtuelle reçoit les événements d'un objet et doit renvoyer « true » si l'événement e a été détecté et traité.

La fonction `event()` peut être réimplémentée pour personnaliser le comportement d'un objet.

Veillez à appeler l’implémentation de la classe d’événement parente pour tous les événements que vous n’avez pas gérés.

Exemple :

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = nullptr);
    ~MyClass();

    bool event(QEvent* ev) override
    {
        if (ev->type() == QEvent::PolishRequest) {
            // overwrite handling of PolishRequest if any
            doThings();
            return true;
        } else  if (ev->type() == QEvent::Show) {
            // complement handling of Show if any
            doThings2();
            QWidget::event(ev);
            return true;
        }
        // Make sure the rest of events are handled
        return QWidget::event(ev);
    }
};

Voir également installEventFilter(), timerEvent(), QCoreApplication::sendEvent() et QCoreApplication::postEvent().

[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)

Filtre les événements si cet objet a été installé en tant que filtre d'événements pour l'objet « watched ».

Dans votre réimplémentation de cette fonction, si vous souhaitez exclure l'event, c'est-à-dire empêcher qu'il ne soit traité davantage, renvoyez true ; sinon, renvoyez false.

Exemple :

class MainWindow : public QMainWindow
{
public:
    MainWindow() ;

protected:
    bool eventFilter(QObject*obj, QEvent*ev) override;

private:
    QTextEdit*textEdit;
};

MainWindow::MainWindow()
{
    textEdit = new QTextEdit;
    setCentralWidget(textEdit);

    textEdit->installEventFilter(this);
}

bool MainWindow::eventFilter(QObject*obj, QEvent*event)
{
    if (obj== textEdit) {
        if (event->type()== QEvent::KeyPress) {
            QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
            qDebug() << "Ate key press" << keyEvent->key();
           return true;
        } else {
            return false;
        }
    } else {
        // transmettre l'événement à la classe parente
        return QMainWindow::eventFilter(obj, event);
    }
}

Notez dans l'exemple ci-dessus que les événements non gérés sont transmis à la fonction eventFilter() de la classe de base, car celle-ci a peut-être réimplémenté eventFilter() à des fins internes.

Certains événements, tels que ` QEvent::ShortcutOverride `, doivent être explicitement acceptés (en appelant ` accept()` sur ceux-ci) afin d'empêcher leur propagation.

Voir également installEventFilter().

template <typename T> T QObject::findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Renvoie l’enfant de cet objet pouvant être converti en type T et appelé « name », ou « nullptr » s’il n’existe aucun objet de ce type. Un argument « name » nul entraîne la correspondance de tous les objets. Un argument « name » vide et non nul ne correspond qu’aux objets dont le champ « objectName » est vide. La recherche est effectuée de manière récursive, sauf si « options » spécifie l’option « FindDirectChildrenOnly ».

S’il y a plusieurs enfants correspondant à la recherche, l’ancêtre le plus direct est renvoyé. S’il y a plusieurs ancêtres les plus directs, le premier enfant de children() sera renvoyé. Dans ce cas, il est préférable d’utiliser findChildren() pour obtenir la liste complète de tous les enfants.

Cet exemple renvoie un enfant QPushButton de parentWidget nommé "button1", même si le bouton n'est pas un enfant direct du parent :

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

Cet exemple renvoie un enfant de type « QListWidget » de parentWidget:

QListWidget *list = parentWidget->findChild<QListWidget *>();

Cet exemple renvoie un enfant QPushButton de parentWidget (son parent direct) nommé "button1":

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

Cet exemple renvoie un enfant de type ` QListWidget ` de ` parentWidget`, son parent direct :

QListWidget *list = parentWidget->findChild<QListWidget *>(Qt::FindDirectChildrenOnly);

Voir également findChildren().

[since 6.7] template <typename T> T QObject::findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Renvoie l'enfant de cet objet pouvant être converti en type T, ou nullptr s'il n'existe aucun objet de ce type. La recherche est effectuée de manière récursive, sauf si options spécifie l'option FindDirectChildrenOnly.

S’il existe plusieurs enfants correspondant à la recherche, l’ancêtre le plus direct est renvoyé. S’il existe plusieurs ancêtres les plus directs, le premier enfant de ` children()` sera renvoyé. Dans ce cas, il est préférable d’utiliser ` findChildren()` pour obtenir la liste complète de tous les enfants.

Cette fonction a été introduite dans Qt 6.7.

Voir également ` findChildren()`.

template <typename T> QList<T> QObject::findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Renvoie tous les enfants de cet objet dont l’ name est conforme à la spécification donnée et pouvant être convertis en type T, ou une liste vide s’il n’existe aucun objet de ce type. Un argument name nul entraîne la sélection de tous les objets, tandis qu’un argument vide ne sélectionne que ceux dont l’ objectName est vide. La recherche est effectuée de manière récursive, sauf si options spécifie l’option FindDirectChildrenOnly.

L’exemple suivant montre comment trouver une liste des QWidgets enfants de l’ parentWidget spécifiée nommée widgetname:

QList<QWidget *> widgets = parentWidget->findChildren<QWidget *>("widgetname");

Cet exemple renvoie tous les QPushButtons qui sont des enfants de parentWidget:

QList<QPushButton *> allPButtons = parentWidget->findChildren<QPushButton *>();

Cet exemple renvoie toutes les QPushButtons qui sont des enfants directs de parentWidget:

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(Qt::FindDirectChildrenOnly);

Voir également findChild().

[since 6.3] template <typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Renvoie tous les enfants de cet objet pouvant être convertis en type T, ou une liste vide s’il n’existe aucun objet de ce type. La recherche est effectuée de manière récursive, sauf si l’ options e spécifie l’option FindDirectChildrenOnly.

Cette fonction a été introduite dans Qt 6.3.

Voir également findChild().

template <typename T> QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Renvoie les enfants de cet objet qui peuvent être convertis en type T et dont les noms correspondent à l'expression régulière re, ou une liste vide s'il n'existe aucun objet de ce type. La recherche est effectuée de manière récursive, sauf si options spécifie l'option FindDirectChildrenOnly.

bool QObject::inherits(const char *className) const

Renvoie « true » si cet objet est une instance d’une classe héritant de « className » ou d’une sous-classe de « QObject » héritant de « className » ; sinon, renvoie « false ».

Une classe est considérée comme héritant d'elle-même.

Exemple :

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits("QTimer");          // returns true
timer->inherits("QObject");         // returns true
timer->inherits("QAbstractButton"); // returns false

// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject");        // returns true
layout->inherits("QLayoutItem");    // returns true (even though QLayoutItem is not a QObject)

Si vous devez déterminer si un objet est une instance d’une classe particulière dans le but de le convertir, envisagez plutôt d’utiliser qobject_cast<Type *>(object).

Voir également metaObject() et qobject_cast().

void QObject::installEventFilter(QObject *filterObj)

Installe un filtre d'événements filterObj sur cet objet. Par exemple :

monitoredObj->installEventFilter(filterObj);

Un filtre d'événements est un objet qui reçoit tous les événements envoyés à cet objet. Le filtre peut soit intercepter l'événement, soit le transmettre à cet objet. Le filtre d'événements filterObj reçoit les événements via sa fonction eventFilter(). La fonction eventFilter() doit renvoyer true si l'événement doit être filtré (c'est-à-dire intercepté) ; sinon, elle doit renvoyer false.

Si plusieurs filtres d’événements sont installés sur un même objet, c’est le filtre installé en dernier qui est activé en premier.

Si la fonction ` filterObj ` a déjà été installée pour cet objet, cette fonction la déplace de manière à ce qu’elle se comporte comme si elle avait été installée en dernier.

Voici une classe d’ KeyPressEater qui intercepte les frappes de ses objets surveillés :

class KeyPressEater : public QObject
{
    Q_OBJECT
public:
    KeyPressEater(QObject*parent = nullptr) : QObject(parent) {}
//...

protected:
    bool eventFilter(QObject*obj, QEvent*event) override;
};

bool KeyPressEater::eventFilter(QObject*obj, QEvent*event)
{
    if (event->type()== QEvent::KeyPress) {
        QKeyEvent*keyEvent = static_cast<QKeyEvent*>(event);
        qDebug("Ate key press %d", keyEvent->key());
       return true;
    } else {
        // traitement standard de l'événement
        return QObject::eventFilter(obj, event);
    }
}

Et voici comment l'installer sur deux widgets :

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

La classe QShortcut, par exemple, utilise cette technique pour intercepter les pressions sur les touches de raccourci.

Notez que l’objet de filtrage doit se trouver dans le même thread que cet objet. Si filterObj se trouve dans un thread différent, cette fonction ne fait rien. Si filterObj ou cet objet sont déplacés vers un autre thread après l’appel de cette fonction, le filtre d’événements ne sera pas appelé tant que les deux objets n’auront pas retrouvé la même affinité de thread (elle n’ est pas supprimée).

Voir également removeEventFilter(), eventFilter() et event().

[noexcept, since 6.11] bool QObject::isQmlExposed() const

Indique si l'objet a été créé par le moteur QML ou si la propriété a été explicitement définie via la fonction ` QJSEngine::setObjectOwnership()`.

Cette fonction a été introduite dans Qt 6.11.

[since 6.4] bool QObject::isQuickItemType() const

Renvoie true si l'objet est un QQuickItem; sinon, renvoie false.

L'appel de cette fonction équivaut à l'appel de ` inherits("QQuickItem")`, à ceci près qu'elle est beaucoup plus rapide.

Cette fonction a été introduite dans Qt 6.4.

[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const

Renvoie ` true ` si l'signal est connecté à au moins un récepteur ; sinon, renvoie ` false`.

signal doit être un membre de type signal de cet objet, sinon le comportement est indéfini.

    static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
    if (QObject::isSignalConnected(valueChangedSignal)) {
        QByteArray data;
        data = get_the_value();       // expensive operation
        emit valueChanged(data);
    }

Comme l’illustre l’extrait de code ci-dessus, vous pouvez utiliser cette fonction pour éviter des opérations coûteuses ou l’émission d’un signal que personne n’écoute.

Voir aussi receivers().

bool QObject::isWidgetType() const

Renvoie « true » si l'objet est un widget ; sinon, renvoie « false ».

L'appel de cette fonction équivaut à l'appel de ` inherits("QWidget")`, à la différence près qu'elle est beaucoup plus rapide.

bool QObject::isWindowType() const

Renvoie ` true ` si l'objet est une fenêtre ; sinon, renvoie ` false`.

L'appel de cette fonction équivaut à l'appel de ` inherits("QWindow")`, à ceci près qu'elle est beaucoup plus rapide.

void QObject::killTimer(int id)

Arrête le minuteur associé à l'identifiant de minuteur, id.

L'identifiant du minuteur est renvoyé par la fonction startTimer() lorsqu'un événement de minuteur est lancé.

Voir également timerEvent() et startTimer().

[since 6.8] void QObject::killTimer(Qt::TimerId id)

Cette fonction a été introduite dans Qt 6.8.

[virtual] const QMetaObject *QObject::metaObject() const

Renvoie un pointeur vers le méta-objet de cet objet.

Un méta-objet contient des informations sur une classe qui hérite de ` QObject`, par exemple le nom de la classe, le nom de la superclasse, les propriétés, les signaux et les slots. Toute sous-classe de ` QObject ` qui contient la macro ` Q_OBJECT ` disposera d’un méta-objet.

Les informations du méta-objet sont requises par le mécanisme de connexion signal/slot et par le système de propriétés. La fonction ` inherits()` utilise également le méta-objet.

Si vous ne disposez d’aucun pointeur vers une instance d’objet réelle mais que vous souhaitez tout de même accéder au méta-objet d’une classe, vous pouvez utiliser staticMetaObject.

Exemple :

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QPushButton::staticMetaObject.className();  // returns "QPushButton"

Voir également ` staticMetaObject`.

bool QObject::moveToThread(QThread *targetThread)

Modifie l'affinité de thread de cet objet et de ses enfants, et renvoie ` true ` en cas de succès. L'objet ne peut pas être déplacé s'il possède un parent. Le traitement des événements se poursuivra dans le ` targetThread`.

Pour déplacer un objet vers le thread principal, utilisez ` QApplication::instance()` pour récupérer un pointeur vers l’application en cours, puis utilisez ` QApplication::thread()` pour récupérer le thread dans lequel réside l’application. Par exemple :

myObject->moveToThread(QApplication::instance()->thread());

Si targetThread est égal à nullptr, tout le traitement des événements pour cet objet et ses enfants s’arrête, car ils ne sont plus associés à aucun thread.

Notez que toutes les minuteries actives de l’objet seront réinitialisées. Les minuteries sont d’abord arrêtées dans le thread actuel, puis redémarrées (avec le même intervalle) dans le thread targetThread. Par conséquent, le fait de déplacer constamment un objet d’un thread à l’autre peut retarder indéfiniment les événements de minuterie.

Un événement « QEvent::ThreadChange » est envoyé à cet objet juste avant que l’affinité du thread ne soit modifiée. Vous pouvez gérer cet événement pour effectuer tout traitement particulier. Notez que tout nouvel événement envoyé à cet objet sera géré dans le « targetThread », à condition que celui-ci ne soit pas « nullptr » : lorsqu’il est « nullptr », aucun traitement d’événement ne peut avoir lieu pour cet objet ou ses enfants, car ils ne sont plus associés à aucun thread.

Dans les versions de Qt antérieures à la version 6.7, cette fonction n'avait pas de valeur de retour (void).

Voir également thread().

[private signal] void QObject::objectNameChanged(const QString &objectName)

Ce signal est émis une fois que le nom de l'objet a été modifié. Le nouveau nom de l'objet est transmis sous la forme « objectName ».

Voir également QObject::objectName.

QObject *QObject::parent() const

Renvoie un pointeur vers l'objet parent.

Voir également setParent() et children().

QVariant QObject::property(const char *name) const

Renvoie la valeur de la propriété name de l'objet.

Si cette propriété n'existe pas, le variant renvoyé n'est pas valide.

Des informations sur toutes les propriétés disponibles sont fournies par les fonctions metaObject() et dynamicPropertyNames().

Voir également setProperty(), QVariant::isValid(), metaObject() et dynamicPropertyNames().

[protected] int QObject::receivers(const char *signal) const

Renvoie le nombre de récepteurs connectés à l'signal.

Étant donné que les slots et les signaux peuvent tous deux servir de récepteurs pour les signaux, et que les mêmes connexions peuvent être établies plusieurs fois, le nombre de récepteurs correspond au nombre de connexions établies à partir de ce signal.

Lorsque vous appelez cette fonction, vous pouvez utiliser la macro SIGNAL() pour passer un signal spécifique :

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

Comme l’illustre l’extrait de code ci-dessus, vous pouvez utiliser cette fonction pour éviter des opérations coûteuses ou l’émission d’un signal que personne n’écoute.

Voir aussi isSignalConnected().

void QObject::removeEventFilter(QObject *obj)

Supprime un objet filtre d'événement obj 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.

Il est toujours sans risque de supprimer un filtre d'événement, même pendant son activation (c'est-à-dire à partir de la fonction eventFilter()).

Voir également installEventFilter(), eventFilter() et event().

[protected] QObject *QObject::sender() const

Renvoie un pointeur vers l'objet qui a envoyé le signal, si la fonction est appelée dans un slot activé par un signal ; sinon, elle renvoie ` nullptr`. Le pointeur n'est valide que pendant l'exécution du slot qui appelle cette fonction depuis le contexte de thread de cet objet.

Le pointeur renvoyé par cette fonction devient invalide si l’émetteur est détruit, ou si le slot est déconnecté du signal de l’émetteur.

Voir aussi ` senderSignalIndex()`.

[protected] int QObject::senderSignalIndex() const

Renvoie l'index de la méta-méthode du signal qui a appelé le slot en cours d'exécution, lequel est un membre de la classe renvoyée par la fonction ` sender()`. Si cette fonction est appelée en dehors d'un slot activé par un signal, elle renvoie -1.

Pour les signaux comportant des paramètres par défaut, cette fonction renvoie toujours l’index avec tous les paramètres, quel que soit celui qui a été utilisé avec connect(). Par exemple, le signal destroyed(QObject *obj = \nullptr) aura deux indices différents (avec et sans le paramètre), mais cette fonction renverra toujours l’index avec un paramètre. Cela ne s’applique pas lors de la surcharge de signaux avec des paramètres différents.

Voir aussi sender(), QMetaObject::indexOfSignal() et QMetaObject::method().

void QObject::setObjectName(const QString &name)

Définit le nom de l'objet sur « name ».

Voir aussi objectName().

[since 6.4] void QObject::setObjectName(QAnyStringView name)

Cette fonction a été introduite dans Qt 6.4.

void QObject::setParent(QObject *parent)

Fait de l'objet un enfant de parent.

Voir également parent() et children().

bool QObject::setProperty(const char *name, const QVariant &value)

Définit la valeur de la propriété « name » de l'objet sur « value ».

Si la propriété est définie dans la classe à l'aide de ` Q_PROPERTY `, la fonction renvoie `true` en cas de succès et `false` dans le cas contraire. Si la propriété n'est pas définie à l'aide de ` Q_PROPERTY` et n'apparaît donc pas dans le méta-objet, elle est ajoutée en tant que propriété dynamique et la fonction renvoie `false`.

Des informations sur toutes les propriétés disponibles sont fournies par les méthodes ` metaObject()` et ` dynamicPropertyNames()`.

Les propriétés dynamiques peuvent être interrogées à nouveau à l’aide de ` property()` et peuvent être supprimées en attribuant à la propriété une valeur ` QVariant` non valide. La modification de la valeur d’une propriété dynamique entraîne l’envoi d’un événement ` QDynamicPropertyChangeEvent ` à l’objet.

Remarque : les propriétés dynamiques commençant par « _q_ » sont réservées à un usage interne.

Voir également property(), metaObject(), dynamicPropertyNames() et QMetaProperty::write().

[since 6.6] bool QObject::setProperty(const char *name, QVariant &&value)

Cette fonction a été introduite dans Qt 6.6.

[noexcept] bool QObject::signalsBlocked() const

Renvoie « true » si les signaux sont bloqués ; sinon, renvoie « false ».

Par défaut, les signaux ne sont pas bloqués.

Voir également blockSignals() et QSignalBlocker.

int QObject::startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer)

Il s'agit d'une fonction surchargée qui lance un minuteur de type timerType avec un délai d'expiration de interval millisecondes. Cela équivaut à appeler :

startTimer(std::chrono::milliseconds{interval}, timerType);

À partir de Qt 6.10, la définition d’un intervalle négatif entraînera un avertissement d’exécution et la valeur sera réinitialisée à 1 ms. Avant Qt 6.10, un Qt Timer vous permettait de définir un intervalle négatif, mais se comportait de manière imprévisible (par exemple, il pouvait arrêter le minuteur s’il était en cours d’exécution ou ne pas le démarrer du tout).

Voir également timerEvent(), killTimer(), QChronoTimer et QBasicTimer.

int QObject::startTimer(std::chrono::nanoseconds interval, Qt::TimerType timerType = Qt::CoarseTimer)

Lance un minuteur et renvoie un identifiant de minuteur, ou renvoie zéro si le minuteur n'a pas pu être lancé.

Un événement de minuteur se produira toutes les interval jusqu’à ce que la fonction killTimer() soit appelée. Si interval est égal à std::chrono::duration::zero(), alors l’événement de minuteur se produit une fois à chaque retour du contrôle à la boucle d’événements, c’est-à-dire lorsqu’il n’y a plus d’événements natifs du système de fenêtrage à traiter.

À partir de Qt 6.10, la définition d’un intervalle négatif entraîne un avertissement d’exécution et la valeur est réinitialisée à 1 ms. Avant Qt 6.10, un Qt Timer vous permettait de définir un intervalle négatif, mais se comportait de manière imprévisible (par exemple, il pouvait arrêter le minuteur s’il était en cours d’exécution ou ne pas le démarrer du tout).

La fonction virtuelle ` timerEvent()` est appelée avec la classe de paramètre d’événement ` QTimerEvent ` lorsqu’un événement de minuterie se produit. Réimplémentez cette fonction pour récupérer les événements de minuterie.

Si plusieurs minuteurs sont en cours d'exécution, la méthode ` QTimerEvent::id()` peut être utilisée pour déterminer quel minuteur a été activé.

Exemple :

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject*parent = nullptr);

Q_SIGNALS :
    void valueChanged();

protected:
    void timerEvent(QTimerEvent*event) override;
};

MyObject::MyObject(QObject*parent)
    : QObject(parent)
{
    using namespace std::chrono_literals;

    startTimer(50 ms);
    startTimer(5 s);
    startTimer(10 min);
    startTimer(1 h);
}

void MyObject::timerEvent(QTimerEvent*event)
{
    qDebug() << "Timer ID:" << event->id();
}

Notez que la précision du minuteur dépend du système d’exploitation et du matériel utilisés.

L’argument timerType vous permet de personnaliser la précision du minuteur. Consultez Qt::TimerType pour plus d’informations sur les différents types de minuteurs. La plupart des plateformes prennent en charge une précision de 20 millisecondes ; certaines offrent davantage. Si Qt n’est pas en mesure de fournir le nombre d’événements de minuteur demandé, il en ignorera certains sans avertissement.

Les classes ` QTimer ` et ` QChronoTimer ` fournissent une interface de programmation de haut niveau avec des minuteries à déclenchement unique et des signaux de minuterie au lieu d’événements. Il existe également une classe ` QBasicTimer ` qui est plus légère que ` QChronoTimer `, mais moins fastidieuse que l’utilisation directe des identifiants de minuterie.

    QObject *obj;
    //...
    const auto id = Qt::TimerId {obj->startTimer(100ms)};
    if (id != Qt::TimerId::Invalid)
    {
        // The timer has been started successfully
    }

Voir également timerEvent(), killTimer(), QChronoTimer et QBasicTimer.

QThread *QObject::thread() const

Renvoie le thread dans lequel réside l'objet.

Voir aussi moveToThread().

[virtual protected] void QObject::timerEvent(QTimerEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de temporisation liés à l'objet.

QChronoTimer Il fournit des interfaces de plus haut niveau pour la fonctionnalité de minuterie, ainsi que des informations plus générales sur les minuteries. L'événement de minuterie est transmis via le paramètre ` event `.

Voir également startTimer(), killTimer() et event().

[static] QString QObject::tr(const char *sourceText, const char *disambiguation = nullptr, int n = -1)

Renvoie une version traduite de sourceText, éventuellement en fonction d'une chaîne fournie par disambiguation et de la valeur de n pour les chaînes contenant des pluriels ; sinon, renvoie QString::fromUtf8(sourceText) si aucune chaîne traduite appropriée n'est disponible.

Exemple :

void SpreadSheet::setupMenuBar()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

Si la même sourceText est utilisée dans différents rôles au sein d’un même contexte, une chaîne d’identification supplémentaire peut être transmise dans disambiguation (nullptr par défaut).

Exemple :

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

Consultez la section « Écriture du code source pour la traduction » pour une description détaillée des mécanismes de traduction de Qt en général, et la section « Désambiguïsation de textes identiques » pour plus d’informations sur la désambiguïsation.

Voir également ` QCoreApplication::translate()` et « Internationalisation avec Qt ».