Ejemplo de ventana rasterizada

Punto de entrada de la aplicación

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

    RasterWindow window;
    window.show();

    return app.exec();
}

El punto de entrada para una aplicación basada en QWindow es la clase QGuiApplication. Esta clase gestiona el flujo de control de la aplicación GUI y los ajustes principales. Pasamos los argumentos de la línea de comandos que se pueden utilizar para recoger ciertas opciones de todo el sistema.

A partir de ahí, pasamos a crear nuestra instancia de ventana y luego llamamos a la función QWindow::show() para decirle al sistema de ventanas que esta ventana debe hacerse visible en la pantalla.

Una vez hecho esto, entramos en el bucle de eventos de la aplicación para que ésta pueda ejecutarse.

Declaración 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;
};

Primero empezamos incluyendo la cabecera <QtGui>. Esto significa que podemos utilizar todas las clases del módulo Qt GUI. También se pueden incluir las clases individualmente si se prefiere.

La clase RasterWindow subclasea directamente a QWindow y proporciona un constructor que permite que la ventana sea una subventana de otra QWindow. Las QWindows sin padre aparecen en el sistema de ventanas como ventanas de nivel superior.

La clase declara un QBackingStore que es lo que utilizamos para gestionar el back buffer de la ventana para los gráficos basados en QPainter.

La ventana raster también se reutiliza en algunos otros ejemplos y añade algunas funciones de ayuda, como renderLater().

Implementación de RasterWindow

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

En el constructor creamos el backingstore y le pasamos la instancia de ventana que debe gestionar. También establecemos la geometría inicial de la ventana.

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

Poco después de llamar a QWindow::show() en una ventana creada, se llamará a la función virtual QWindow::exposeEvent() para notificarnos que la exposición de la ventana en el sistema de ventanas ha cambiado. El evento contiene la subregión expuesta, pero como de todas formas dibujaremos la ventana entera cada vez, no hacemos uso de ello.

La función QWindow::isExposed() nos dirá si la ventana se está mostrando o no. Necesitamos esto porque el evento exposeEvent es llamado también cuando la ventana se oscurece en el sistema de ventanas. Si la ventana se está mostrando, llamamos a renderNow() para dibujar la ventana inmediatamente. Queremos dibujar inmediatamente para poder presentar al sistema algún contenido visual.

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

El evento resize está garantizado para ser llamado antes de que la ventana sea mostrada en pantalla y también será llamado cada vez que la ventana sea redimensionada mientras esté en pantalla. Usamos esto para redimensionar el buffer trasero, y diferir el renderizado al correspondiente/siguiente evento expose.

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 función renderNow configura lo necesario para que QWindow renderice su contenido utilizando QPainter. Como las ventanas oscurecidas no serán visibles, abortamos si la ventana no está expuesta en el sistema de ventanas. Esto puede ocurrir, por ejemplo, cuando otra ventana oscurece completamente esta ventana.

Comenzamos el dibujo llamando a QBackingStore::beginPaint() en la región que queremos dibujar. Luego obtenemos el QPaintDevice del back buffer y creamos un QPainter para renderizar a ese dispositivo de pintura.

Para no dejar rastros del renderizado anterior y comenzar con un buffer limpio, llenamos todo el buffer con el color blanco. Luego llamamos a la función virtual render() que hace el dibujo real de esta ventana.

Una vez completado el dibujo, llamamos a endPaint() para señalar que hemos terminado de renderizar y presentamos el contenido en el buffer trasero usando QBackingStore::flush().

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

La función render contiene el código de dibujo de la ventana. En este ejemplo minial, sólo dibujamos la cadena "QWindow" en el centro.

Renderizando Asíncronamente

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

Pasamos por algunos lugares donde la ventana necesitaba ser repintada inmediatamente. Hay algunos casos en los que esto no es deseable, sino dejar que la aplicación vuelva al bucle de eventos y programe el repintado para más tarde. Conseguimos esto solicitando una actualización, usando QWindow::requestUpdate(), que será entregada cuando el sistema esté listo para repintar.

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

Reimplementamos la función virtual QObject::event() para manejar el evento de actualización. Cuando llega el evento llamamos a renderNow() para renderizar la ventana inmediatamente.

Proyecto de ejemplo @ code.qt.io