Les minuteries

QObject, la classe de base de tous les objets Qt, fournit la prise en charge de base des minuteries dans Qt. La fonction QObject::startTimer() permet de démarrer une minuterie en lui passant un intervalle en millisecondes comme argument. La fonction renvoie un identifiant de minuterie entier unique. La minuterie se déclenchera alors à intervalles réguliers jusqu’à ce que vous appeliez explicitement la fonction QObject::killTimer() avec cet identifiant de minuterie.

Au lieu de gérer directement les identifiants de minuteurs, vous pouvez utiliser ` QBasicTimer`. ` QBasicTimer ` est une classe-valeur, un wrapper RAII autour d’un identifiant de minuteur. Vous démarrez le minuteur avec ` QBasicTimer::start()` et l'arrêtez avec ` QBasicTimer::stop()` (cette dernière méthode est également appelée 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 du minuteur.

Pour que ce mécanisme fonctionne, l’application doit s’exécuter dans une boucle d’événements. Vous pouvez démarrer une boucle d’événements avec QCoreApplication::exec(). Pour les Qt Widgets les applications, voir QApplication::exec(). Lorsqu’un minuteur se déclenche, l’application envoie un QTimerEvent, et le flux de contrôle quitte la boucle d’événements jusqu’à ce que l’événement du minuteur soit traité. Cela implique qu’un minuteur ne peut pas se déclencher pendant que votre application est occupée à effectuer une autre tâche. En d’autres termes : la précision des minuteries dépend de la granularité de votre application. La précision des minuteries dépend également du système d’exploitation et du matériel sous-jacents. Les intervalles courts peuvent être arrondis ou retardés par le planificateur système, et tous les types de minuteries peuvent expirer plus tard que prévu si le système est occupé. Pour plus d’informations sur la résolution des minuteries et Qt::TimerType, consultez la documentation QTimer.

Dans les applications multithread, vous pouvez utiliser le mécanisme de minuterie dans n’importe quel thread disposant d’une boucle d’événements. Pour démarrer une boucle d’événements à partir d’un thread non-GUI, utilisez la fonction ` QThread::exec()`. Qt utilise la propriété ` thread affinity ` de l’objet pour déterminer quel thread transmettra l’ QTimerEvent. De ce fait, vous devez démarrer et arrêter tous les temporisateurs dans le thread de l’objet ; il n’est pas possible de démarrer des temporisateurs pour des objets situés dans un autre thread.

L'API principale pour la fonctionnalité de minuterie est QTimer. QTimer stocke l'intervalle sous la forme d'un entier signé, ce qui limite l'intervalle maximal pris en charge au nombre de millisecondes pouvant tenir dans un entier signé (en pratique, cela correspond à une période d'environ 24 jours).

Qt 6.8 a introduit la classe ` QChronoTimer `. La principale différence entre les deux classes réside dans le fait que ` QChronoTimer ` prend en charge une plage d’intervalles plus large et une précision supérieure (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 en millisecondes et d’une plage 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 pour atteindre std::chrono::nanoseconds sans rompre la compatibilité binaire.

QTimer fournit des minuteries classiques qui émettent un signal lorsqu’elles se déclenchent, et hérite de QObject afin de s’intégrer parfaitement dans la structure de propriété de la plupart des programmes Qt. Voici comment l’utiliser habituellement :

        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 ` est rendu enfant de l’objet ` this ` afin que, lorsque ` this ` est détruit, le minuteur le soit également. Ensuite, le signal ` timeout()` est connecté au slot qui effectuera l’action souhaitée ; l’intervalle du minuteur peut être soit passé au constructeur, soit défini ultérieurement avec `setInterval()`.

QTimer fournit également des fonctions statiques pour les minuteries à déclenchement 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, votre application doit disposer d’une boucle d’événements ; en d’autres termes, vous devez appeler ` QCoreApplication::exec()` quelque part. Les événements de la minuterie ne seront délivrés que tant que la boucle d’événements est en cours d’exécution.

Dans les applications multithread, vous pouvez utiliser ` QTimer ` dans n’importe quel thread disposant d’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’ thread affinity du minuteur pour déterminer quel thread émettra le signal timeout(). C’est pourquoi vous devez démarrer et arrêter le minuteur dans son propre thread ; il n’est pas possible de démarrer un minuteur à partir d’un autre thread.

L'exemple « Analog Clock » montre comment utiliser QTimer pour rafraîchir l'affichage d'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 ` appelle le slot ` QWidget::update()` pour actualiser l’affichage de l’horloge.