QTimer Class

Documentation des fonctions membres

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

Crée un minuteur avec l'parent on fournie.

[virtual noexcept] QTimer::~QTimer()

Supprime le minuteur.

template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(Functor &&slot)

Crée une connexion entre le signal ` timeout()` du temporisateur et ` slot`. Renvoie un descripteur de connexion.

Cette méthode est fournie à titre de commodité. Elle équivaut à l'appel suivant :

QObject::connect(timer, &QTimer::timeout, timer, slot, Qt::DirectConnection);

Voir également QObject::connect() et timeout().

template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)

Crée une connexion entre le signal ` timeout()` et ` slot ` afin de l'intégrer dans une boucle d'événements spécifique de ` context`, puis renvoie un descripteur vers cette connexion.

Cette méthode est fournie à des fins de commodité. Elle équivaut à appeler :

QObject::connect(timer, &QTimer::timeout, context, slot, connectionType);

Voir également QObject::connect() et timeout().

[since 6.8] Qt::TimerId QTimer::id() const

Renvoie un objet ` Qt::TimerId ` représentant l'identifiant du minuteur si celui-ci est en cours d'exécution ; sinon, renvoie ` Qt::TimerId::Invalid`.

Cette fonction a été introduite dans Qt 6.8.

Voir également Qt::TimerId.

std::chrono::milliseconds QTimer::intervalAsDuration() const

Renvoie l'intervalle de ce minuteur sous la forme d'un objet ` std::chrono::milliseconds `.

Voir aussi interval.

bool QTimer::isActive() const

Renvoie « true » si le minuteur est en cours d'exécution ; sinon, renvoie « false ».

std::chrono::milliseconds QTimer::remainingTimeAsDuration() const

Renvoie le temps restant dans cet objet « timer » sous la forme d’un objet « std::chrono::milliseconds ». Si ce « timer » est arrivé à échéance ou en retard, la valeur renvoyée est « std::chrono::milliseconds::zero() ». Si le temps restant n’a pas pu être déterminé ou si le « timer » n’est pas en cours d’exécution, cette fonction renvoie une durée négative.

Voir également remainingTime().

Cette fonction statique appelle functor après interval.

Cette fonction est très pratique, car elle vous évite d’avoir à vous soucier d’un objet ` timerEvent ` ou à créer un objet ` QTimer ` local.

Si context est spécifié, alors functor ne sera appelé que si l'objet context n'a pas été détruit avant que l'intervalle ne se produise. Le foncteur sera alors exécuté sur le thread de context. Le thread du contexte doit disposer d'une boucle d'événements Qt en cours d'exécution.

Si functor est une fonction membre de context, alors la fonction sera appelée sur l’objet.

Le paramètre ` interval ` peut être de type ` int ` (interprété comme un nombre de millisecondes) ou de type ` std::chrono `, qui est implicitement converti en nanosecondes.

À 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 Timer Qt 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).

Remarque : cette fonction est réentrante.

Voir également ` start()`.

[static] void QTimer::singleShot(std::chrono::nanoseconds nsec, const QObject *receiver, const char *member)

Cette fonction statique appelle un slot au bout d’un intervalle de temps donné.

Cette fonction est très pratique, car elle vous évite d’avoir à vous soucier d’un « timerEvent » ou de créer un objet « local QTimer ».

L'receiver est l'objet récepteur et l'member est le slot. L'intervalle de temps est spécifié dans l'objet de durée nsec.

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

Remarque : cette fonction est réentrante.

Voir également ` start()`.

[static] void QTimer::singleShot(std::chrono::nanoseconds nsec, Qt::TimerType timerType, const QObject *receiver, const char *member)

Cette fonction statique appelle un slot au bout d'un intervalle de temps donné.

Cette fonction est très pratique, car elle vous évite d’avoir à vous soucier d’un « timerEvent » ou de créer un objet « local QTimer ».

L'receiver est l'objet récepteur et l'member est le slot. L'intervalle de temps est spécifié dans l'objet de durée nsec. L'timerType e influe sur la précision du minuteur.

À 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 chronomètre s’il était en cours d’exécution ou ne pas le démarrer du tout).

Remarque : cette fonction est réentrante.

Voir également ` start()`.

[slot] void QTimer::start(int msec)

Lance ou relance le chronomètre avec un délai d'expiration de msec millisecondes.

Cela équivaut à :

timer.setInterval(msec);
timer.start();

Si le minuteur est déjà en cours, il sera réinitialisé à stopped et redémarré. Cela modifiera également sa valeur « id » ().

Si singleShot est vrai, le minuteur ne sera activé qu’une seule fois.

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

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        timer, qOverload(&QTimer::start));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        timer, [receiver = timer](int msec) { receiver->start(msec); });

[slot] void QTimer::start()

Lance ou relance le chronomètre avec le délai d'expiration spécifié dans ` interval`.

Si le minuteur est déjà en cours d'exécution, il sera désactivé ( stopped ) puis redémarré. Cela modifiera également sa propriété « id » ().

Si singleShot est vrai, le minuteur ne sera activé qu’une seule fois.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        timer, qOverload<>(&QTimer::start));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        timer, [receiver = timer]() { receiver->start(); });

void QTimer::start(std::chrono::milliseconds interval)

Lance ou relance le chronomètre avec un délai d'expiration de interval millisecondes.

Cela revient à :

timer.setInterval(interval);
timer.start();

Si le minuteur est déjà en cours, il sera désactivé ( stopped ) puis relancé. Cela modifiera également sa valeur « id » ().

Si singleShot est vrai, le minuteur ne sera activé qu’une seule fois.

À 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 s'arrêtait s'il était en cours d'exécution ou ne démarrait tout simplement pas).

[slot] void QTimer::stop()

Arrête le chronomètre.

Voir aussi start().

[private signal] void QTimer::timeout()

Ce signal est émis lorsque le délai de la minuterie est écoulé.

Voir également interval, start() et stop().

[override virtual protected] void QTimer::timerEvent(QTimerEvent *e)

Réimplémente : QObject::timerEvent(QTimerEvent *event).

int QTimer::timerId() const

Renvoie l'identifiant du minuteur s'il est en cours d'exécution ; sinon, renvoie -1.