Queued Custom Type Example

The Window Class

We define a simple Window class with a public slot that accepts a Block object. The rest of the class is concerned with managing the user interface and handling images.

 class Window : public QWidget
 {
     Q_OBJECT

 public:
     Window();
     void loadImage(const QImage &image);

 public slots:
     void addBlock(const Block &block);

 private slots:
     void loadImage();
     void resetUi();

 private:
     QLabel *label;
     QPixmap pixmap;
     QPushButton *loadButton;
     QPushButton *resetButton;
     QString path;
     RenderThread *thread;
 };

The Window class also contains a worker thread, provided by a RenderThread object. This will emit signals to send Block objects to the window's addBlock(Block) slot.

The parts of the Window class that are most relevant are the constructor and the addBlock(Block) slot.

The constructor creates a thread for rendering images, sets up a user interface containing a label and two push buttons that are connected to slots in the same class.

 Window::Window()
 {
     thread = new RenderThread();
     label = new QLabel();
     label->setAlignment(Qt::AlignCenter);

     loadButton = new QPushButton(tr("&Load image..."));
     resetButton = new QPushButton(tr("&Stop"));
     resetButton->setEnabled(false);

     connect(loadButton, SIGNAL(clicked()), this, SLOT(loadImage()));
     connect(resetButton, SIGNAL(clicked()), thread, SLOT(stopProcess()));
     connect(thread, SIGNAL(finished()), this, SLOT(resetUi()));
     connect(thread, SIGNAL(sendBlock(Block)), this, SLOT(addBlock(Block)));

In the last of these connections, we connect a signal in the RenderThread object to the addBlock(Block) slot in the window.

     ...
     setWindowTitle(tr("Queued Custom Type"));
 }

The rest of the constructor simply sets up the layout of the window.

The addBlock(Block) slot receives blocks from the rendering thread via the signal-slot connection set up in the constructor:

 void Window::addBlock(const Block &block)
 {
     QColor color = block.color();
     color.setAlpha(64);

     QPainter painter;
     painter.begin(&pixmap);
     painter.fillRect(block.rect(), color);
     painter.end();
     label->setPixmap(pixmap);
 }

We simply paint these onto the label as they arrive.

 class RenderThread : public QThread
 {
     Q_OBJECT

 public:
     RenderThread(QObject *parent = 0);
     ~RenderThread();

     void processImage(const QImage &image);

 signals:
     void sendBlock(const Block &block);

 public slots:
     void stopProcess();

 protected:
     void run();

 private:
     bool m_abort;
     QImage m_image;
     QMutex mutex;
 };

 void RenderThread::processImage(const QImage &image)
 {
     if (image.isNull())
         return;

     m_image = image;
     m_abort = false;
     start();
 }

 void RenderThread::run()
 {
     int size = qMax(m_image.width()/20, m_image.height()/20);
     for (int s = size; s > 0; --s) {
         for (int c = 0; c < 400; ++c) {

     ...
             Block block(QRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1),
                         QColor(red/n, green/n, blue/n));
             emit sendBlock(block);
             if (m_abort)
                 return;
             msleep(10);
         }
     }
 }

 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
     qRegisterMetaType<Block>();
     qsrand(QTime::currentTime().elapsed());

     Window window;
 #if defined(Q_WS_S60)
     window.showMaximized();
 #else
     window.show();
 #endif

     window.loadImage(createImage(256, 256));
     return app.exec();
 }