Exemple de fenêtre raster

Point d'entrée de l'application

int main(int argc, char **argv)
{
    QGuiApplication app(argc, argv);

    RasterWindow window;
    window.show();

    return app.exec();
}

Le point d’entrée d’une application basée sur l’ QWindow est la classe QGuiApplication. Elle gère le flux de contrôle et les paramètres principaux de l’application graphique. Nous lui transmettons les arguments de ligne de commande qui peuvent être utilisés pour récupérer certaines options système.

À partir de là, nous créons notre instance de fenêtre, puis nous appelons la fonction ` QWindow::show()` pour indiquer au système de fenêtrage que cette fenêtre doit désormais être affichée à l’écran.

Une fois cette opération effectuée, nous entrons dans la boucle d'événements de l'application afin que celle-ci puisse s'exécuter.

Déclaration de RasterWindow

#include <QtGui>
#include <QScopedPointer>

class RasterWindow : public QWindow
{
    Q_OBJECT
public:
    explicit RasterWindow(QWindow *parent = nullptr);

    virtual void render(QPainter *painter);

public slots:
    void renderLater();
    void renderNow();

protected:
    bool event(QEvent *event) override;

    void resizeEvent(QResizeEvent *event) override;
    void exposeEvent(QExposeEvent *event) override;

private:
    QScopedPointer<QBackingStore> m_backingStore;
};

Nous commençons tout d’abord par inclure l’en-tête <QtGui>. Cela signifie que nous pouvons utiliser toutes les classes du module Qt GUI. Les classes peuvent également être incluses individuellement si vous le préférez.

La classe RasterWindow est une sous-classe directe de QWindow et fournit un constructeur qui permet à la fenêtre d’être une sous-fenêtre d’une autre QWindow. Les QWindows sans parent apparaissent dans le système de fenêtrage comme des fenêtres de niveau supérieur.

La classe déclare un ` QBackingStore `, que nous utilisons pour gérer le tampon arrière de la fenêtre pour les graphismes basés sur ` QPainter `.

La fenêtre raster est également réutilisée dans quelques autres exemples et ajoute quelques fonctions d'aide, telles que `renderLater()`.

Implémentation de RasterWindow

RasterWindow::RasterWindow(QWindow *parent)
    : QWindow(parent)
    , m_backingStore(new QBackingStore(this))
{
    setGeometry(100, 100, 300, 200);
}

Dans le constructeur, nous créons le backingstore et lui transmettons l’instance de fenêtre qu’il est censé gérer. Nous définissons également la géométrie initiale de la fenêtre.

void RasterWindow::exposeEvent(QExposeEvent *)
{
    if (isExposed())
        renderNow();
}

Peu après l’appel de ` QWindow::show()` sur une fenêtre créée, la fonction virtuelle ` QWindow::exposeEvent()` sera appelée pour nous signaler que l’exposition de la fenêtre dans le système de fenêtrage a changé. L’événement contient la sous-région exposée, mais comme nous allons de toute façon dessiner la fenêtre entière à chaque fois, nous n’utilisons pas cette information.

La fonction ` QWindow::isExposed()` nous indiquera si la fenêtre est visible ou non. Nous en avons besoin, car `exposeEvent` est également appelé lorsque la fenêtre est masquée dans le système de fenêtrage. Si la fenêtre est visible, nous appelons `renderNow()` pour la dessiner immédiatement. Nous souhaitons effectuer le dessin sans délai afin de pouvoir présenter un contenu visuel au système.

void RasterWindow::resizeEvent(QResizeEvent *resizeEvent)
{
    m_backingStore->resize(resizeEvent->size());
}

L’événement resize est appelé de manière garantie avant que la fenêtre ne s’affiche à l’écran et sera également appelé chaque fois que la fenêtre est redimensionnée alors qu’elle est à l’écran. Nous l’utilisons pour redimensionner le tampon arrière et différer le rendu jusqu’à l’événement expose correspondant ou suivant.

void RasterWindow::renderNow()
{
    if (!isExposed())
        return;

    QRect rect(0, 0, width(), height());
    m_backingStore->beginPaint(rect);

    QPaintDevice *device = m_backingStore->paintDevice();
    QPainter painter(device);

    painter.fillRect(0, 0, width(), height(), QGradient::NightFade);
    render(&painter);
    painter.end();

    m_backingStore->endPaint();
    m_backingStore->flush(rect);
}

La fonction `renderNow` configure ce qui est nécessaire pour qu’une ` QWindow ` puisse afficher son contenu à l’aide de ` QPainter`. Comme les fenêtres masquées ne sont pas visibles, nous interrompons l’opération si la fenêtre n’est pas exposée dans le système de fenêtrage. Cela peut par exemple se produire lorsqu’une autre fenêtre masque entièrement cette fenêtre.

Nous commençons le dessin en appelant ` QBackingStore::beginPaint()` sur la région que nous souhaitons dessiner. Ensuite, nous récupérons l’ QPaintDevice du tampon arrière et créons un ` QPainter ` pour effectuer le rendu sur ce périphérique de peinture.

Pour éviter de laisser des traces du rendu précédent et commencer avec un tampon vierge, nous remplissons l’intégralité du tampon avec la couleur blanche. Ensuite, nous appelons la fonction virtuelle `render()` qui effectue le dessin proprement dit de cette fenêtre.

Une fois le dessin terminé, nous appelons endPaint() pour signaler que le rendu est terminé et présentons le contenu du tampon arrière à l’aide de QBackingStore::flush().

void RasterWindow::render(QPainter *painter)
{
    painter->drawText(QRectF(0, 0, width(), height()), Qt::AlignCenter, QStringLiteral("QWindow"));
}

La fonction render contient le code de dessin de la fenêtre. Dans cet exemple minimal, nous nous contentons d’afficher la chaîne «QWindow » au centre.

Rendu asynchrone

void RasterWindow::renderLater()
{
    requestUpdate();
}

Nous avons vu plusieurs cas où la fenêtre devait être rafraîchie immédiatement. Dans certains cas, cela n’est pas souhaitable ; il vaut mieux laisser l’application revenir à la boucle d’événements et programmer le rafraîchissement pour plus tard. Pour ce faire, nous demandons une mise à jour à l’aide de ` QWindow::requestUpdate()`, qui sera ensuite exécutée lorsque le système sera prêt à rafraîchir l’affichage.

bool RasterWindow::event(QEvent *event)
{
    if (event->type() == QEvent::UpdateRequest) {
        renderNow();
        return true;
    }
    return QWindow::event(event);
}

Nous réimplémentons la fonction virtuelle QObject::event() pour gérer l'événement de mise à jour. Lorsque l'événement se produit, nous appelons renderNow() pour afficher la fenêtre immédiatement.

Exemple de projet sur code.qt.io