Qt GUI user interaction with QMessageBox from within QThread object

Question

I'm using QThread with MyObject->moveToThread(myThread); for communication functions that take a while. A few Signals and Slots keep the GUI posted about the progress.

Howeever, some situation may occur during the threaded communication that requires user interaction - since a QMessageBox can't be created inside a thread, I was thinking to emit a signal that would allow me to pause the thread and show the dialog. But first of all, there does not seem to be a way to pause a thread, and second, this attempt probably fails because it requires a way to pass a parameter back to the thread when resuming it.

A differenet approach might be to pass all parameters in question to the thread beforehand, but this may not alway be an option.

How is this usually done?

Edit

Thanks for the comment #1 and getting my hopes up, but please elaborate on how to create e.g. a dialog from an object within a thread and how to pause it..

The following example code with Qt 4.8.1 and MSVC++ 2010 results in:

MyClass::MyClass created 
MainWindow::MainWindow thread started 
MyClass::start run 
ASSERT failure in QWidget: "Widgets must be created in the GUI thread.", file kernel\qwidget.cpp, line 1299

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include "myclass.h"
#include <QThread>
#include <QDebug>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    QThread *thread = new QThread();
    MyClass* myObject = new MyClass();

    myObject->moveToThread( thread );
    connect(thread,     SIGNAL( started()),     myObject, SLOT(start()));
    connect(myObject,   SIGNAL( finished()),    thread, SLOT(quit()));
    connect(myObject,   SIGNAL( finished()),    myObject, SLOT(deleteLater()));
    connect(thread,     SIGNAL( finished()),    thread, SLOT(deleteLater()));

    thread->start();
    if( thread->isRunning() )
    {
        qDebug() << __FUNCTION__ << "thread started";
    }
}

MainWindow::~MainWindow()
{
    delete ui;
}

myclass.h

#ifndef MYCLASS_H
#define MYCLASS_H

#include <QObject>

class MyClass : public QObject
{
    Q_OBJECT
public:
    explicit MyClass(QObject *parent = 0);

signals:
    void finished();

public slots:
    void start();

};

#endif // MYCLASS_H

myclass.cpp

#include "myclass.h"

#include <QMessageBox>
#include <QDebug>

MyClass::MyClass(QObject *parent) :
    QObject(parent)
{
    qDebug() << __FUNCTION__ << "created";
}

void MyClass::start()
{
    qDebug() << __FUNCTION__ << "run";

    // do stuff ...

    // get information from user (blocking)

    QMessageBox *msgBox = new QMessageBox();
    msgBox->setWindowTitle(      tr("WindowTitle") );
    msgBox->setText(             tr("Text") );
    msgBox->setInformativeText(  tr("InformativeText") );
    msgBox->setStandardButtons(  QMessageBox::Ok | QMessageBox::Cancel);
    msgBox->setDefaultButton(    QMessageBox::Ok);
    msgBox->setEscapeButton(     QMessageBox::Cancel);
    msgBox->setIcon(             QMessageBox::Information);

    int ret = msgBox->exec();

    // continue doing stuff (based on user input) ...

    switch (ret) 
    {
        case QMessageBox::Ok:
            break;

        case QMessageBox::Cancel:
            break;

        default:
            break;
    }

    // do even more stuff

    emit finished();
}

Answer 1

Use Qt::BlockingQueuedConnection in a signal/slot connection (the call to QObject::connect()).

http://doc.qt.digia.com/qt/qt.html#ConnectionType-enum

This will block your thread until the slot on the UI thread returns, the slot in the UI thread is then free to display a messagebox/modal dialog/whatever you want to do.

You must be sure that your worker thread is actually not on the UI thread, because as the docs say this will cause a dead lock if the signal and slot are on the same thread (since it will block itself).

Answer 2

I can't give any specific code right now, but I would do it like this:

1. In MyClass::start() lock a QMutex.
2. Emit a signal e.g. messageBoxRequired().
3. Wait on a shared QWaitCondition on the recent mutex. This will also unlock the mutex while the thread is waiting.
4. In a slot in your MainWindow, e.g. showMessageBox(), show the message box.
5. Store the returned value in a member of MyClass. You can do this by offering a setter and getter which use the mutex in order to protect the member. Obviously MyClass itself should only access that member with those setters/getters itself. (Also see QMutexLocker for that).
6. Call wakeOne() or wakeAll() on the shared QWaitCondition.
7. The previous wait() call will return and MyClass::start() will continue execution. If I understand the docs correctly, QWaitCondition will lock the mutex again before it returns from wait(). This means you have to unlock the mutex directly after the wait() call.
8. You can access the message box's return value from your class member (using a thread-safe getter)

Implementations for thread-safe setters/getters would be as follows:

void MyClass::setVariable( int value )
{
    QMutexLocker( &_mutex );
    _value = value;
}

int MyClass::getVariable() // Not sure if a 'const' modifier would work here
{
    QMutexLocker( &_mutex );
    return _value;
}