Les Événements dans Qt

Présentation

Les programmes Qt sont pilotés par des événements, où chaque interaction est initiée par un événement interne. La génération et le traitement des événements forment le cycle d'exécution principal, présents tout au long de l'application. Les types courents incluent :

• Événements de temporisation, clavier, souris, dessin
• Événements de glisser-déposer, molette, focus, entrée/sortie
• Événements de déplacement, redimensionnement, affichage, fenêtre

Qt convertit les messages système en événements Qt, encapsulés en objets héritant de la classe abstraite QEvent. Tout QObject peut traiter ces événements.

Origine des Événements

Événements système d'exploitation : Immédiatement envoyés à l'objet QWidget correspondant, traités via la fonction virtuelle event(QEvent*), qui appelle des gestionnaires spécifiques émettant des signaux prédéfinis.

Événements générés par l'application : Utilisation de QApplication::postEvent() pour un envoi asynchrone (ex: QWidget::update()) et QApplication::sendEvent() pour un envoi synchrone (ex: QWidget::repaint()).

Traitement des Événements

Pour personnaliser le traitement, on redéfinit les fnoctions virtuelles dans des sous-classes de QWidget. Par exemple :

• mousePressEvent(QMouseEvent*) pour les clics souris
• paintEvent(QPaintEvent*) pour le dessin

Événements de Temporisation

Qt offre deux mécanismes : événements de timer via QObject et signaux via QTimer.

Exemple avec QObject :

int QObject::startTimer(int interval); // Lance le timer, retourne son ID
void QObject::timerEvent(QTimerEvent*); // Gestionnaire d'événement
void QObject::killTimer(int id); // Arrête le timer

Horloge et Chronomètre

Conception de l'interface utilisateur avec des composants tels que des afficheurs LCD et boutons.

Implémentation de l'horloge en utilisant un QTimer :

#include <QTimer>
#include <QTime>

private slots:
    void on_timerHorloge_timeout();
private:
    QTimer m_horloge;

Connexion du signal timeout à la fonction slot pour mettre à jour l'affichgae chaque seconde.

Pour le chronomètre, redéfinition de timerEvent avec un intervalle d'une milliseconde :

void ChronometreDialog::timerEvent(QTimerEvent *) {
    m_chrono = m_chrono.addMSecs(1);
    ui->affichageTemps->display(m_chrono.toString("HH:mm:ss.zzz"));
}

Événements Souris

Surcharge des fonctions virtuelles pour gérer les interactions souris :

• mousePressEvent pour les appuis
• mouseMoveEvent pour les mouvements
• mouseReleaseEvent pour les relâchements

Exemple de déplacement d'un label par glisser-déposer :

void SourisDialog::mousePressEvent(QMouseEvent *e) {
    if (e->button() == Qt::LeftButton) {
        QRect zoneLabel = ui->blocMobile->geometry();
        if (zoneLabel.contains(e->pos())) {
            m_glissement = true;
            m_decalage = ui->blocMobile->pos() - e->pos();
        }
    }
}

void SourisDialog::mouseMoveEvent(QMouseEvent *e) {
    if (m_glissement) {
        QPoint nouvellePosition = e->pos() + m_decalage;
        // Limitation à la zone de la fenêtre
        QSize tailleFenetre = this->size();
        int xMin = 0, xMax = tailleFenetre.width() - ui->blocMobile->width();
        int yMin = 0, yMax = tailleFenetre.height() - ui->blocMobile->height();
        nouvellePosition.setX(qBound(xMin, nouvellePosition.x(), xMax));
        nouvellePosition.setY(qBound(yMin, nouvellePosition.y(), yMax));
        ui->blocMobile->move(nouvellePosition);
    }
}

Événements Clavier

Fonctions virtuelles pour les touches : keyPressEvent et keyReleaseEvent, similaire aux événements souris.

Événements de Dessin

Déclenchement de paintEvent lors de l'affichage initial, du changement de visibilité, du redimensionnement, ou des appels à update()/repaint().

Exemple de visionneuse d'images :

#include <QPainter>

void Visionneuse::paintEvent(QPaintEvent *) {
    QPainter peintre(this);
    QRect zoneImage = ui->cadreImage->frameRect();
    zoneImage.translate(ui->cadreImage->pos());
    QImage image(":/images/" + QString::number(m_indexImage) + ".jpg");
    peintre.drawImage(zoneImage, image);
}

Dessin dans Qt

Stylo (QPen)

Configuration des lignes : couleur, largeur, style, etc.

Pinceau (QBrush)

Paramétrage du remplissage des zones.

Police (QFont)

Gestion du texte : gras, italique, taille, etc.

Système de Dessin

QPainter pour les opérations graphiques, QPaintDevice comme surface cible (QWidget, QPixmap, QImage).

Exemple de dessin avec stylo et pinceau :

void DessinDialog::paintEvent(QPaintEvent *) {
    QPainter artiste(this);
    QPen stylo;
    stylo.setColor(Qt::red);
    stylo.setWidth(5);
    stylo.setStyle(Qt::DashDotLine);
    artiste.setPen(stylo);

    QBrush pinceau;
    pinceau.setColor(Qt::yellow);
    pinceau.setStyle(Qt::SolidPattern);
    artiste.setBrush(pinceau);

    int largeur = width(), hauteur = height();
    artiste.drawRect(QRect(QPoint(largeur/5, hauteur/5), QPoint(4*largeur/5, 4*hauteur/5)));

    stylo.setColor(Qt::blue);
    stylo.setWidth(3);
    stylo.setStyle(Qt::SolidLine);
    artiste.setPen(stylo);

    pinceau.setTextureImage(QImage(":/images/texture.png"));
    pinceau.setStyle(Qt::TexturePattern);
    artiste.setBrush(pinceau);
    artiste.drawRect(QRect(QPoint(2*largeur/5, 2*hauteur/5), QPoint(3*largeur/5, 3*hauteur/5)));
}