Les chronomètres

QObjectla classe de base de tous les objets Qt, fournit le support de base des minuteries dans Qt. Avec QObject::startTimer(), vous démarrez une minuterie avec un intervalle en millisecondes comme argument. La fonction renvoie un identifiant unique et intégral de la minuterie. La minuterie se déclenche alors à intervalles réguliers jusqu'à ce que vous appeliez explicitement QObject::killTimer() avec cet ID de minuterie.

Au lieu de gérer directement les ID de minuterie, vous pouvez utiliser QBasicTimer. QBasicTimer est une classe de valeur, une enveloppe RAII autour d'un ID de minuterie. Vous démarrez la minuterie avec QBasicTimer::start() et l'arrêtez avec QBasicTimer::stop() (ce dernier est également appelé lors de la destruction). Pour utiliser QBasicTimer, vous devez réimplémenter timerEvent() dans votre classe (qui doit être une sous-classe de QObject) et y gérer l'événement de minuterie.

Pour que ce mécanisme fonctionne, l'application doit être exécutée dans une boucle d'événements. Vous pouvez démarrer une boucle d'événements avec QApplication::exec(). Lorsqu'une minuterie se déclenche, l'application envoie un message QTimerEvent, et le flux de contrôle quitte la boucle d'événements jusqu'à ce que l'événement de la minuterie soit traité. Cela signifie qu'une minuterie ne peut pas se déclencher pendant que votre application est occupée à faire quelque chose d'autre. En d'autres termes, la précision des minuteries dépend de la granularité de votre application.

Dans les applications multithread, vous pouvez utiliser le mécanisme de minuterie dans n'importe quel thread qui possède une boucle d'événements. Pour démarrer une boucle d'événements à partir d'un thread non-GUI, utilisez QThread::exec(). Qt utilise l'adresse thread affinity de l'objet pour déterminer quel thread fournira l'adresse QTimerEvent. Pour cette raison, vous devez démarrer et arrêter toutes les minuteries dans le thread de l'objet ; il n'est pas possible de démarrer des minuteries pour des objets dans un autre thread.

L'API principale pour la fonctionnalité de minuterie est QTimer. QTimer stocke l'intervalle dans un entier signé, ce qui limite l'intervalle maximum qu'elle prend en charge au nombre de millisecondes qui peuvent tenir dans un entier signé (en pratique, il s'agit d'une période d'environ 24 jours).

Qt 6.8 a introduit la classe QChronoTimer. La principale différence entre les deux classes est que QChronoTimer prend en charge un intervalle plus large et une précision plus élevée (std::chrono::nanoseconds). Pour QTimer, l'intervalle maximal pris en charge est de ±24 jours, tandis que pour QChronoTimer, il est de ±292 ans. Si vous n'avez besoin que d'une résolution de l'ordre de la milliseconde et d'un intervalle de ±24 jours, vous pouvez continuer à utiliser QTimer. Notez que QChronoTimer existe principalement parce que la précision de QTimer ne pouvait pas être modifiée en std::chrono::nanoseconds sans rompre la compatibilité binaire.

La précision des minuteries dépend du système d'exploitation sous-jacent. Windows 2000 a une précision de 15 ms ; les autres systèmes que nous avons testés peuvent gérer des intervalles de 1 ms.

QTimer fournit des minuteries régulières qui émettent un signal lorsque la minuterie se déclenche, et hérite de QObject de sorte qu'il s'intègre bien dans la structure de propriété de la plupart des programmes Qt. La façon normale de l'utiliser est la suivante :

        QTimer *timer = new QTimer(1s, this);
        connect(timer, &QTimer::timeout, this, &MyWidget::processOneThing);
        timer->start();
        auto *timer = new QTimer(this);
        connect(timer, &QTimer::timeout, this, &MyWidget::processOneThing);
        timer->setInterval(1s);
        timer->start();

L'objet QTimer devient un enfant de l'objet this de sorte que, lorsque this est détruit, la minuterie est également détruite. Ensuite, le signal timeout() est connecté au slot qui effectuera le travail, l'intervalle de la minuterie peut être soit transmis au constructeur, soit défini ultérieurement avec setInterval().

QTimer fournit également des fonctions statiques pour les minuteries à coup unique. Par exemple :

        MyWidget widget;
        QTimer::singleShot(200ms, &widget, &MyWidget::updateCaption);

200 ms après l'exécution de cette ligne de code, le slot updateCaption() sera appelé.

Pour que QTimer fonctionne, vous devez avoir une boucle d'événements dans votre application, c'est-à-dire que vous devez appeler QCoreApplication::exec() quelque part. Les événements de la minuterie ne sont délivrés que lorsque la boucle d'événements est en cours d'exécution.

Dans les applications multithread, vous pouvez utiliser QTimer dans n'importe quel thread qui possède une boucle d'événements. Pour démarrer une boucle d'événements à partir d'un thread non-GUI, utilisez QThread::exec(). Qt utilise le timer thread affinity pour déterminer quel thread émettra le signal timeout(). Pour cette raison, vous devez démarrer et arrêter la minuterie dans son fil d'exécution ; il n'est pas possible de démarrer une minuterie à partir d'un autre fil d'exécution.

L'exemple de l'horloge analogique montre comment utiliser QTimer pour redessiner un widget à intervalles réguliers. Extrait de l'implémentation de AnalogClock:

AnalogClock::AnalogClock(QWidget *parent)
    : QWidget(parent)
{
    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, QOverload<>::of(&AnalogClock::update));
    timer->start(1000);

    setWindowTitle(tr("Analog Clock"));
    resize(200, 200);
}

Toutes les secondes, QTimer appellera le slot QWidget::update() pour rafraîchir l'affichage de l'horloge.