Qt Add loading widget screen while opening a project

Question

I created an application in which I would like to add a loading screen when the application is opening a project because the loading of the project can be long and sometimes, the gui blocks so the user can think there is a crash.

So I tried with QThread, reading doc and "solved" examples on this forum but nothing to do, I can't make it work.

I have a MainWindow class which deals with GUI and this class is the one I create in the main function :

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

Then I have : mainwindow.h

class MyThread;
class MainWindow : public QMainWindow
{
    Q_OBJECT
    ...
    private :
        Controller *controller;//inherits from QObject and loads the project
        QList<MyThread*> threads;
    public slots :
        void animateLoadingScreen(int inValue);
}

mainwindow.cpp

MainWindow::MainWindow(...)
{
    controller=new Controller(...);

    threads.append(new MyThread(30, this));
    connect(threads[0], SIGNAL(valueChanged(int)), this, SLOT(animateLoadingScreen(int)));
}

void MainWindow::animateLoadingScreen(int inValue)
{
    cout<<"MainWindow::animateLoadingScreen"<<endl;
    widgetLoadingScreen->updateValue(inValue);//to update the animation
}

void MainWindow::openProject()
{
    widgetLoadingScreen->show()://a widget containing a spinner for example
    threads[0]->start();//I want to launch the other thread here

    controller->openProject();

    threads[0]->exit(0);//end of thread so end of loading screen
}

MyThread.h

class MyThread : public QThread
{
    Q_OBJECT;
public:
    explicit MyThread(int interval, QObject* parent = 0);
    ~MyThread();

signals:
    void valueChanged(int);

private slots:
    void count(void);

protected:
    void run(void);

private:
    int i;
    int inc;
    int intvl;
    QTimer* timer;
};

MyThread.cpp

MyThread::MyThread(int interval, QObject* parent): QThread(parent), i(0), inc(-1), intvl(interval), timer(0)
{
}

void MyThread::run(void)
{
    if(timer == 0)
    {
        timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), this, SLOT(count()));
    }

    timer->start(intvl);
    exec();
}

void MyThread::count(void)
{
    if(i >= 100 || i <= 0)
        inc = -inc;
    i += inc;
    emit valueChanged(i);
}

When I execute the app, and click on open button which launches MainWindow::openProject(), I get :

QObject: Cannot create children for a parent that is in a different thread.
(Parent is MyThread(0x5463930), parent's thread is QThread(0x3cd1f80), current thread is MyThread(0x5463930)
MainWindow::animateLoadingScreen
MainWindow::animateLoadingScreen
....
MainWindow::animateLoadingScreen
MainWindow::animateLoadingScreen

(and here the controller outputs. and no MainWindow::animateLoadingScreen anymore so the widget loading screen is never animated during the opening of the project)

So what do I have to do, what do I have to put in MyThread class, how to link its signal to MainWindow to update the loading screen. And I think that there may be a problem with widgetLoadingScreen which is created in MainWindow so if MainWindow is blocked beacause of the opening, the widgetLoadingScreen can't be updated since it is in the thread of MainWindow which handles the GUI ?!

I read : http://www.qtcentre.org/wiki/index.php?title=Updating_GUI_from_QThread but with that one, I got error message at runtime, it's the one I use in the code I give above QObject: Cannot create children for a parent that is in a different thread. (Parent is MyThread(0x41938e0), parent's thread is QThread(0x1221f80), current thread is MyThread(0x41938e0)

I tried that too : How to emit cross-thread signal in Qt? but, even if I don't have the error message at runtime, it's the same for the animation which is not updated.

I am completely lost, and I don't think it's something difficult to do to have a loading screen in a thread while the main thread is opening a project?!

Answer 1

Qt has a QSplashScreen class which you could use for a loading screen.

Besides this, one of the problems you have is due to thread affinity (the thread in which an object is running) and the fact that you've decided to inherit from QThread.

In my opinion, QThread has a misleading name. It's more of a thread controller and unless you want to change how Qt handles threads, you really shouldn't inherit from it and many will tell you that "You're doing it Wrong!"

By inheriting QThread, your instance of MyThread is running on the main thread. However, when a call to exec() is made, it starts the event loop for the new thread and all its children, which includes the QTimer, and tries to move it to the new thread.

The correct way to solve this is not to inherit from QThread, but to create a worker object, derived from QObject and move it to the new thread. You can read about how to 'Really Truly Use QThread' here.

Answer 2

1st problem - runtime error with QTimer

Problem is in void MyThread::run(void), line timer = new QTimer(this);. The thread instance is created in (and so owned by) different (main) thread then it represents. For this reason, you cannot use thread as parent for object created inside the thread. In your case, solution is simple - create the timer on stack.

Example:

void MyThread::run(void)
{
    QTimer timer;
    connect(&timer, SIGNAL(timeout()), this, SLOT(count()));
    timer.start(intvl);

    // Following method start event loop which makes sure that timer
    // will exists. When this method ends, timer will be automatically
    // destroyed and thread ends.
    exec();
}

2nd problem - GUI not updating

Qt requires the GUI to be created and displayed from main application thread. This means that blocking main thread with big operation blocks whole GUI. There are only 2 possible solutions:

1. Move the heavy work to other (loading) thread. This is best solution and I believe it's worth the effort (I'm aware you wrote that this would be problematic).
2. During the heavy operation, call regularly QCoreApplication::processEvents() - each time you call this, events will be processed, which includes calling slots, key and mouse events, GUI redraw etc. The more often you call this, the more responsive GUI will be. This is simpler to implement (just put one line all over the code), but it's quite ugly and if the operation blocks on loading a file, the GUI will freeze for some time. That means that responsiveness of your GUI depends on interval between calls. (But if you call it too often, you will slow down the loading progress.) This technique is discouraged and it's best to avoid it...

Answer 3

The way I will do it based on the default example on Qthread Page:

1. Break the big controller->openProject(); such that it updates a variable
2. provide access to that variable using a signal ( like statusChanged(int)).
3. Do what you need to do once the signal is triggered.

The code looks like

class Worker : public QObject
 {
     Q_OBJECT
     QThread workerThread;

 private: 
    int status; //
    bool hasworktoDo();
    void doSmallWork();

 public slots:
     void doWork() {

         while(hasworktoDo())
         {
             doSmallWork(); // fragments of controller->openProject();
             ++status; //previously set to 0
             emit statusChanged(status);
         }
         emit resultReady(result);
     }


 signals:
     void resultReady(const QString &result);
     void statusChanged(int value);
 };

 class Controller : public QObject
 {
     Q_OBJECT
     QThread workerThread;
 public:
     Controller() {
         Worker *worker = new Worker;
         worker->moveToThread(&workerThread);
         connect(workerThread, SIGNAL(statusChanged(int)), this, SLOT(updateStatus(int)));
         connect(workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()));
         connect(this, SIGNAL(operate()), worker, SLOT(doWork()));
         connect(worker, SIGNAL(resultReady(QString)), this, SLOT(handleResults(QString)));
         workerThread.start();
     }
     ~Controller() {
         workerThread.quit();
         workerThread.wait();
     }
 public slots:
     void handleResults(const QString &);

     void updateStatus(int value)
     {
       int status = value;
       //now you have what to use to update the ui
     }
 signals:
     void operate(); //
 };

If you have trouble breaking the openProject operations in small parts, it just mean it is pointless to say on the UI that you are at 50%... Just say Loading... and make the code simpler. Note that you don't need a timer in my case, as the worker sends regular updates