QObject Class

Documentation sur les fonctions membres

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

Construit un objet avec l'objet parent parent.

Le parent d'un objet peut être considéré comme le propriétaire de l'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.

La définition de parent en nullptr construit un objet sans parent. Si l'objet est un widget, il deviendra une fenêtre de premier niveau.

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

[virtual noexcept] QObject::~QObject()

Détruit l'objet, en supprimant tous ses objets enfants.

Tous les signaux vers et depuis l'objet sont automatiquement déconnectés, et tous les événements postés en attente pour l'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 n'invoquera rien qui lui soit connecté). Si block est faux, il n'y a pas de blocage.

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

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

Les signaux émis alors qu'ils sont bloqués 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 les événements des enfants. L'événement est transmis dans le paramètre event.

QEvent::ChildAdded et 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 ChildAdded, l'enfant n'est pas encore entièrement construit et, dans le cas ChildRemoved, il a peut-être déjà été détruit).

QEvent::ChildPolished sont envoyés aux widgets lorsque des enfants sont polis ou lorsque des enfants polis sont ajoutés. Si vous recevez un événement "enfant poli", la construction de l'enfant est généralement terminée. Cependant, cela n'est pas garanti, et plusieurs événements de polissage peuvent être envoyés 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 est poli plusieurs fois au cours de sa construction et de sa destruction, vous pouvez recevoir plusieurs événements de polissage d'enfant pour le même enfant, chaque fois avec une table virtuelle différente.

Voir aussi 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, c'est-à-dire que les nouveaux enfants sont ajoutés à la fin.

Notez que l'ordre de la liste change lorsque les enfants de QWidget sont 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 aussi 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 du type type à partir de signal dans l'objet sender jusqu'à method dans l'objet receiver. Renvoie un identifiant de la connexion qui peut être utilisé pour la déconnecter ultérieurement.

L'identifiant de la connexion sera invalide s'il n'est pas possible de créer la connexion, par exemple si les paramètres ne sont pas valides. Vous pouvez vérifier si l'adresse QMetaObject::Connection est valide en la transformant en bool.

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 aussi 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 du type type à partir de signal dans l'objet sender jusqu'à method dans l'objet receiver. Renvoie un handle à la connexion qui peut être utilisé pour la déconnecter ultérieurement.

Vous devez utiliser les macros SIGNAL() et SLOT() lorsque vous spécifiez les macros 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 pas contenir de noms de variables, mais uniquement le type. Par exemple, l'exemple suivant ne fonctionnerait pas et renverrait un message faux :

// 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 de MyWidget relaie un signal provenant d'une variable membre privée et le rend disponible sous un nom lié à MyWidget.

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

Si un signal est connecté à plusieurs slots, les slots sont activés dans l'ordre dans lequel les connexions ont été faites, lorsque le signal est émis.

La fonction renvoie une adresse QMetaObject::Connection qui représente une poignée de connexion si elle réussit à connecter le signal à l'emplacement. L'identifiant de connexion sera invalide s'il ne peut pas créer la connexion, par exemple si QObject ne peut pas vérifier l'existence de signal ou method, ou si leurs signatures ne sont pas compatibles. Vous pouvez vérifier si l'identifiant est valide en le transformant en bool.

Par défaut, un signal est émis pour chaque connexion que vous établissez ; deux signaux sont émis pour les connexions dupliquées. Vous pouvez rompre toutes ces connexions avec un seul appel à disconnect(). Si vous passez l'option Qt::UniqueConnection type , la connexion ne sera établie que s'il ne s'agit pas d'un doublon. S'il existe déjà un doublon (même signal à la même place sur les mêmes objets), la connexion échouera et connect renverra une adresse invalide QMetaObject::Connection.

Le paramètre optionnel type décrit le type de connexion à établir. En particulier, il détermine si un signal particulier est délivré à un slot immédiatement ou s'il est mis en file d'attente pour être délivré 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 coulisses. Si vous essayez d'utiliser une connexion en file d'attente et que vous obtenez le message d'erreur suivant

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 à l'épreuve des threads.

Voir aussi disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE(), et Différences entre les connexions basées sur des chaînes 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, et renvoie un identifiant à la connexion.

Le signal doit être une fonction déclarée comme signal dans l'en-tête. La fonction slot peut être n'importe quelle fonction ou foncteur qui peut être connecté au signal. Une fonction slot peut être connectée à un signal donné si le signal a 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 le 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'expéditeur est détruit. Cependant, vous devez veiller à ce que les objets utilisés dans le foncteur soient toujours vivants lorsque le signal est émis.

Pour cette raison, il est recommandé d'utiliser la surcharge de 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 à l'épreuve des threads.

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

Connecte signal de l'objet sender à l'objet method.

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

Chaque connexion que vous établissez émet un signal, de sorte que les connexions dupliquées émettent deux signaux. Vous pouvez interrompre une connexion en utilisant disconnect().

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

Voir aussi 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 type donné de signal dans l'objet sender à functor pour être placé dans une boucle d'événement spécifique de context, et renvoie un handle à la connexion.

Le signal doit être une fonction déclarée comme signal dans l'en-tête. La fonction slot peut être n'importe quelle fonction ou foncteur qui peut être connecté au signal. Une fonction slot peut être connectée à un signal donné si le signal a 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 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éconnecte automatiquement si l'expéditeur ou le contexte est détruit. Toutefois, vous devez veiller à ce que les objets utilisés dans le foncteur soient toujours vivants lorsque le signal est émis.

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

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

[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 du type type à partir de signal dans l'objet sender jusqu'à method dans l'objet receiver. Renvoie une poignée à la connexion qui peut être utilisée pour la déconnecter ultérieurement.

Le signal doit être une fonction déclarée comme signal dans l'en-tête. La fonction slot peut être n'importe quelle fonction membre qui peut être connectée au signal. Un slot peut être connecté à un signal donné si le signal a au moins autant d'arguments que le slot, et s'il y a une conversion implicite entre les types des arguments correspondants dans le signal et le slot.

Exemple :

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

Cet exemple permet de s'assurer que l'étiquette affiche toujours le texte de la ligne en cours d'édition.

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

Si un signal est connecté à plusieurs slots, les slots 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 identifiant de connexion si elle réussit à connecter le signal à l'emplacement. La poignée de connexion sera invalide si elle ne peut pas créer la connexion, par exemple si QObject ne peut pas vérifier l'existence de signal (s'il n'a pas été déclaré en tant que signal). Vous pouvez vérifier si QMetaObject::Connection est valide en le transformant en bool.

Par défaut, un signal est émis pour chaque connexion que vous établissez ; deux signaux sont émis pour les connexions dupliquées. Vous pouvez interrompre toutes ces connexions avec un seul appel à disconnect(). Si vous passez l'option Qt::UniqueConnection type , la connexion ne sera établie que s'il ne s'agit pas d'un doublon. S'il existe déjà un doublon (même signal à la même place sur les mêmes objets), la connexion échouera et connect renverra une adresse invalide QMetaObject::Connection.

Le paramètre facultatif type décrit le type de connexion à établir. En particulier, il détermine si un signal particulier est délivré à un slot immédiatement ou s'il est mis en file d'attente pour être délivré 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 coulisses. Si vous essayez d'utiliser une connexion en file d'attente et que vous obtenez le message d'erreur suivant

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

assurez-vous de 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 à l'épreuve des threads.

Voir aussi 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 lorsque quelque chose a été connecté à signal dans cet objet.

Si vous souhaitez comparer signal avec un signal spécifique, vous pouvez utiliser QMetaMethod::fromSignal() comme suit :

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

Voir aussi connect() et disconnectNotify().

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

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

Voir aussi 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, deleteLater() est appelée sur un objet avant QCoreApplication::exec()), l'objet sera supprimé une fois que la boucle d'événements sera lancée. Si deleteLater() est appelée après l'arrêt de la boucle événementielle principale, l'objet ne sera pas supprimé. Si deleteLater() est appelé sur un objet qui vit dans un thread sans boucle d'événements en cours, l'objet sera détruit lorsque le thread se terminera.

Un schéma courant lors de l'utilisation d'un worker QObject dans un QThread est de connecter le signal finished() du thread au slot deleteLater() du worker afin de s'assurer qu'il est supprimé en toute sécurité :

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

Notez que l'entrée et la sortie d'une nouvelle boucle d'événements (par exemple, en ouvrant une boîte de dialogue modale) n' effectuera 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 imbriquée précédente était encore en cours d'exécution : la boucle d'événements de Qt supprimera ces objets dès que la nouvelle boucle d'événements imbriquée commencera.

Dans les situations où Qt XML ne pilote pas le distributeur 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 à l'épreuve des threads.

Voir également destroyed() et QPointer.

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

Ce signal est émis immédiatement avant la destruction de l'objet obj, après que toutes les instances de QPointer ont été notifiées, et ne peut pas être bloqué.

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

Voir aussi deleteLater() et QPointer.

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

Déconnexion d'une connexion.

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

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

En outre, cette fonction renvoie false, aucun signal et les slots déconnectés si :

1. signal n'est pas membre de la classe de l'émetteur ou de l'une de ses classes parentes.
2. method n'est pas membre de la classe des récepteurs ou de l'une de ses classes mères.
3. signal l'instance ne représente pas un signal.

Pour éviter les incohérences, stockez la poignée de connexion renvoyée par connect() et utilisez-la dans l'appel à disconnect().

QMetaMethod() peut être utilisé comme joker dans la signification "tout signal" ou "tout emplacement dans l'objet récepteur". De la même manière, nullptr peut être utilisé pour receiver dans le sens "tout objet récepteur". Dans ce cas, la méthode doit également être QMetaMethod(). Le paramètre sender ne doit jamais être nullptr.

Voir aussi 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 signal dans l'objet sender de method dans l'objet receiver. Renvoie true si la connexion est rompue avec succès ; sinon, renvoie false.

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

disconnect() est typiquement utilisé 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);

   équivalent à la fonction surchargée non statique

       myObject->disconnect();

2. Déconnecter tout ce qui est connecté à 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 les incohérences, stockez la poignée de connexion renvoyée par connect() et utilisez-la dans l'appel à disconnect().

nullptr peut être utilisé comme un joker, signifiant "tout signal", "tout objet récepteur" ou "tout emplacement dans l'objet récepteur", respectivement.

Le sender ne peut jamais être nullptr(vous ne pouvez pas déconnecter les signaux de plus d'un objet 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 est nullptr, il 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 sont déconnectés, et tous les autres slots sont laissés en l'état. L'adresse method doit être nullptr si l'adresse receiver est omise, de sorte qu'il n'est pas possible de déconnecter un emplacement nommé spécifiquement sur tous les objets.

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

Voir également connect().

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

Déconnecte tous les signaux de cet objet de receiver's method.

Pour éviter les incohérences, stockez la poignée de connexion renvoyée par connect() et utilisez-la dans l'appel à disconnect().

Une connexion de fente de signal est supprimée lorsque l'un ou l'autre des objets concerné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 les incohérences, stockez la poignée de connexion renvoyée par connect() et utilisez-la dans l'appel à disconnect().

Une connexion de créneau de signalisation est supprimée lorsque l'un des objets concernés est détruit.

Remarque : cette fonction est à l'épreuve des 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 rompue avec succès ; sinon, renvoie false.

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

disconnect() est typiquement utilisé 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 d'un signal spécifique à un emplacement spécifique :

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

nullptr peut être utilisé comme un joker, signifiant respectivement "tout signal", "tout objet récepteur" ou "tout emplacement dans l'objet récepteur".

Le sender ne peut jamais être nullptr(vous ne pouvez pas déconnecter les signaux de plus d'un objet 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 est nullptr, il déconnecte tout ce qui est connecté à signal. Sinon, seuls les slots du récepteur spécifié sont déconnectés. disconnect() avec un receiver non nul déconnecte également les fonctions slot qui étaient connectées avec receiver comme objet de contexte.

Si method est nullptr, il déconnecte tout ce qui est connecté à receiver. Sinon, seuls les slots nommés method seront déconnectés, et tous les autres slots seront laissés tranquilles. L'adresse method doit être nullptr si l'adresse receiver est omise, de sorte qu'il n'est pas possible de déconnecter un slot nommé spécifiquement sur tous les objets.

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

Voir aussi connect().

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

Cette fonction virtuelle est appelée lorsque quelque chose a été déconnecté de signal dans cet objet.

Voir connectNotify() pour un exemple de comparaison de signal avec un signal spécifique.

Si tous les signaux ont été déconnectés de cet objet (par exemple, le signal argument de disconnect() était nullptr), disconnectNotify() n'est appelé qu'une seule fois, et signal sera un QMetaMethod invalide (QMetaMethod::isValid() renvoie false).

Voir aussi disconnect() et connectNotify().

void QObject::dumpObjectInfo() const

Fournit des informations sur les connexions de signaux, etc. pour cet objet sur la sortie de débogage.

Voir aussi dumpObjectTree().

void QObject::dumpObjectTree() const

Affiche un arbre d'enfants sur 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 setProperty().

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

Cette fonction virtuelle reçoit les événements d'un objet et renvoie un message vrai si l'événement e a été reconnu 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 parent pour tous les événements que vous n'avez pas traité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é comme filtre d'événement pour l'objet watched.

Dans votre réimplémentation de cette fonction, si vous souhaitez filtrer l'objet event, c'est-à-dire ne plus le traiter, renvoyez true ; sinon, renvoyez false.

Exemple :

classe 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 mère return QMainWindow::eventFilter(obj, event) ; } }

Remarquez dans l'exemple ci-dessus que les événements non gérés sont transmis à la fonction eventFilter() de la classe de base, puisque cette dernière peut avoir réimplémenté eventFilter() pour ses propres besoins internes.

Certains événements, tels que QEvent::ShortcutOverride, doivent être explicitement acceptés (en appelant accept() sur eux) afin d'éviter la propagation.

Voir aussi installEventFilter().

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

Renvoie l'enfant de cet objet qui peut être coulé dans le type T et qui est appelé name, ou nullptr s'il n'existe pas d'objet de ce type. Un argument name nul entraîne la correspondance avec tous les objets. Un argument name vide et non nul ne correspond qu'aux objets dont l'argument objectName est vide. La recherche est effectuée de manière récursive, sauf si options spécifie l'option FindDirectChildrenOnly.

Si plusieurs enfants correspondent à la recherche, l'ancêtre le plus direct est renvoyé. S'il y a plusieurs ancêtres les plus directs, le premier enfant dans 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 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 QListWidget de parentWidget, son parent direct :

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

Voir aussi findChildren().

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

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

S'il y a plus d'un enfant correspondant à la recherche, l'ancêtre le plus direct est renvoyé. S'il y a plusieurs ancêtres les plus directs, le premier enfant dans 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 aussi findChildren().

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

Retourne tous les enfants de cet objet avec le name donné qui peuvent être castés vers le type T, ou une liste vide s'il n'y a pas de tels objets. Si l'argument name est nul, tous les objets seront recherchés, s'il est vide, seuls les objets dont objectName est vide seront recherchés. 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 d'enfants QWidgets de l'objet parentWidget spécifié, nommé widgetname:

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

Cet exemple renvoie toutes les adresses QPushButtonqui sont des enfants de parentWidget:

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

Cet exemple renvoie tous les QPushButtonqui sont des enfants immédiats de parentWidget:

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

Voir aussi findChild().

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

Renvoie tous les enfants de cet objet qui peuvent être transformés en type T, ou une liste vide s'il n'y a pas d'objets de ce type. La recherche est effectuée de manière récursive, sauf si options spécifie l'option FindDirectChildrenOnly.

Cette fonction a été introduite dans Qt 6.3.

Voir aussi 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 de type T et dont les noms correspondent à l'expression régulière re, ou une liste vide s'il n'y a pas d'objets 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 qui hérite de className ou d'une sous-classe de QObject qui hérite 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 couler, utilisez plutôt qobject_cast<Type *>(objet).

Voir également metaObject() et qobject_cast().

void QObject::installEventFilter(QObject *filterObj)

Installe un filtre d'événement 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 arrêter l'événement, soit le transmettre à cet objet. Le filtre d'événements filterObj reçoit les événements par l'intermédiaire de sa fonction eventFilter(). La fonction eventFilter() doit renvoyer true si l'événement doit être filtré (c'est-à-dire arrêté) ; sinon, elle doit renvoyer false.

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

Si filterObj a déjà été installé pour cet objet, cette fonction le déplace pour qu'il agisse comme s'il avait été installé en dernier.

Voici une classe KeyPressEater qui se nourrit des pressions sur les touches des objets qu'elle surveille :

class KeyPressEater : public QObject
{ Q_OBJECTpublic: 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 des événements 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 filtrant doit être dans le même thread que cet objet. Si filterObj se trouve dans un autre thread, cette fonction ne fait rien. Si filterObj ou cet objet sont déplacés dans un thread différent après l'appel de cette fonction, le filtre d'événement ne sera pas appelé jusqu'à ce que les deux objets aient à nouveau la même affinité de thread (il n' est pas supprimé).

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

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

Retourne si l'objet a été créé par le moteur QML ou si la propriété a été explicitement définie via 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 à cette fonction est équivalent à l'appel à inherits("QQuickItem"), sauf qu'il est beaucoup plus rapide.

Cette fonction a été introduite dans Qt 6.4.

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

Renvoie true si signal est connecté à au moins un récepteur, sinon false.

signal doit être un membre 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 à cette fonction est équivalent à l'appel à inherits("QWidget"), sauf qu'il est beaucoup plus rapide.

bool QObject::isWindowType() const

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

L'appel à cette fonction est équivalent à l'appel à inherits("QWindow"), sauf qu'il est beaucoup plus rapide.

void QObject::killTimer(int id)

Tue la minuterie dont l'identifiant est id.

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

Voir aussi 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 sur 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 emplacements. Chaque sous-classe QObject qui contient la macro Q_OBJECT aura un méta-objet.

Les informations relatives au méta-objet sont nécessaires au mécanisme de connexion signal/emplacement et au système de propriétés. La fonction inherits() utilise également le méta-objet.

Si vous n'avez pas de pointeur sur une instance d'objet réelle mais que vous souhaitez néanmoins 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 aussi staticMetaObject.

bool QObject::moveToThread(QThread *targetThread)

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

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

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

Si targetThread est nullptr, tous les traitements d'événements pour cet objet et ses enfants s'arrêtent, car ils ne sont plus associés à aucun thread.

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

Un événement QEvent::ThreadChange est envoyé à cet objet juste avant que l'affinité des threads ne soit modifiée. Vous pouvez gérer cet événement pour effectuer un traitement spécial. Notez que tout nouvel événement envoyé à cet objet sera traité dans le thread targetThread, à condition qu'il ne s'agisse pas de nullptr: lorsqu'il s'agit de nullptr, aucun traitement d'événement pour cet objet ou ses enfants ne peut avoir lieu, car ils ne sont plus associés à aucun thread.

Dans les versions de Qt antérieures à la 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 lorsque le nom de l'objet a été modifié. Le nouveau nom de l'objet est transmis en tant que objectName.

Voir aussi QObject::objectName.

QObject *QObject::parent() const

Renvoie un pointeur sur l'objet parent.

Voir aussi 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, la variante renvoyée n'est pas valide.

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

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

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

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

Étant donné que les emplacements et les signaux peuvent être utilisés comme récepteurs de signaux et que les mêmes connexions peuvent être établies plusieurs fois, le nombre de récepteurs est le même que le nombre de connexions établies à partir de ce signal.

Lorsque vous appelez cette fonction, vous pouvez utiliser la macro SIGNAL() pour transmettre 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 de filtre d'événement obj 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 pour cet objet sont automatiquement supprimés lorsque cet 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 eventFilter()).

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

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

Renvoie un pointeur sur l'objet qui a envoyé le signal, s'il est appelé dans un slot activé par un signal ; sinon, il renvoie nullptr. Le pointeur n'est valide que pendant l'exécution du slot qui appelle cette fonction à partir du contexte 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, qui est un membre de la classe renvoyée par sender(). Si elle est appelée en dehors d'un slot activé par un signal, elle renvoie -1.

Pour les signaux avec 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 index différents (avec et sans le paramètre), mais cette fonction renverra toujours l'index avec un paramètre. Cela ne s'applique pas à la surcharge des signaux avec différents paramètres.

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

void QObject::setObjectName(const QString &name)

Fixe le nom de l'objet à name.

Voir également 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 aussi parent() et children().

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

Fixe la valeur de la propriété name de l'objet à value.

Si la propriété est définie dans la classe à l'aide de Q_PROPERTY, true est renvoyé 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'est donc pas répertoriée dans le méta-objet, elle est ajoutée en tant que propriété dynamique et false est renvoyé.

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

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

Remarque : les propriétés dynamiques commençant par "_q_" sont réservées à des fins internes.

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.

Les signaux ne sont pas bloqués par défaut.

Voir aussi blockSignals() et QSignalBlocker.

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

Il s'agit d'une fonction surchargée qui démarre un timer de type timerType et un timeout 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 réinitialisation de la valeur à 1ms. Avant Qt 6.10, un Qt Timer vous permettait de définir un intervalle négatif mais se comportait de manière surprenante (par exemple en arrêtant le timer s'il était en cours d'exécution ou en ne le démarrant pas du tout).

Voir aussi timerEvent(), killTimer(), QChronoTimer, et QBasicTimer.

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

Démarre un timer et renvoie un identifiant de timer, ou renvoie zéro s'il n'a pas pu démarrer de timer.

Un événement de minuterie se produit tous les interval jusqu'à ce que killTimer() soit appelé. Si interval est égal à std::chrono::duration::zero(), l'événement de la minuterie se produit une fois chaque fois que le contrôle revient à la boucle d'événements, c'est-à-dire qu'il n'y a plus d'événements du système de fenêtres natif à traiter.

À partir de Qt 6.10, la définition d'un intervalle négatif entraînera un avertissement d'exécution et la réinitialisation de la valeur à 1ms. Avant Qt 6.10, une minuterie Qt vous permettait de définir un intervalle négatif mais se comportait de manière surprenante (par exemple en arrêtant la minuterie si elle était en cours d'exécution ou en ne la démarrant pas du tout).

La fonction virtuelle timerEvent() est appelée avec la classe de paramètres d'événement QTimerEvent lorsqu'un événement de minuterie se produit. Réimplémentez cette fonction pour obtenir des événements de minuterie.

Si plusieurs minuteries sont en cours d'exécution, la méthode QTimerEvent::id() peut être utilisée pour savoir quelle minuterie a été activée.

Exemple :

class MyObject : public QObject
{ Q_OBJECTpublic: 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(50ms) ; startTimer(5s) ; startTimer(10min) ; startTimer(1h) ; }void MyObject::timerEvent(QTimerEvent *événement){
    qDebug() << "Timer ID:" << event->id();
}

Notez que la précision de la minuterie dépend du système d'exploitation et du matériel sous-jacents.

L'argument timerType vous permet de personnaliser la précision de la minuterie. Voir Qt::TimerType pour plus d'informations sur les différents types de minuterie. La plupart des plateformes supportent une précision de 20 millisecondes ; certaines offrent plus. Si Qt n'est pas en mesure de fournir le nombre requis d'événements de temporisation, il en rejettera certains silencieusement.

Les classes QTimer et QChronoTimer fournissent une interface de programmation de haut niveau avec des minuteries à coup 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 maladroite que l'utilisation directe des ID de minuterie.

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

Voir aussi timerEvent(), killTimer(), QChronoTimer, et QBasicTimer.

QThread *QObject::thread() const

Renvoie le thread dans lequel vit 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 pour recevoir les événements de la minuterie pour l'objet.

QChronoTimer fournit des interfaces de plus haut niveau pour la fonctionnalité de la minuterie, ainsi que des informations plus générales sur les minuteries. L'événement de la minuterie est transmis dans 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 basée sur une chaîne disambiguation et une 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 le même sourceText est utilisé dans différents rôles au sein du 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"));
    ...

Voir Writing Source Code for Translation pour une description détaillée des mécanismes de traduction de Qt en général, et la section Disambiguate Identical Text pour des informations sur la désambiguïsation.

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