CODEWITHSUNDEEP
c++qtuser-interface
minomic
minomic

Reputation: 665

Qt - GUI freezing

I wrote in C++ a solver for the 8-puzzle game, and now I'm trying to use Qt to give it a GUI.

Basically I have an underlying object of type "Board" which represents the board of the puzzle, and I have organized the GUI as a grid of QPushButton. Then I have a method updateUI which associates to every button the correct text, based on the Board. Something like

    for(int i=0; i<Board::MATRIX_DIM * Board::MATRIX_DIM; i++)
    {
        m_buttons[i]->setText(m_values[i]);
    }

In another method (solveGUI) I have

void MainWindow::solveGUI()
{
    m_game->solve();
    int solutionDepth = m_game->getSolutionDepth();
    Move *solutionMoves = m_game->getSolutionMoves();
    for(int i=0; i<solutionDepth; i++)
    {
        Move m = solutionMoves[i];
        m_board.performMove(m);     /* perform the move on the Board object */
        updateUI();       /* should update the GUI so that it represents the Board */
        Sleep(1000);
    }
}

where the first line (m_game->solve) takes some time. Then I obtain a list of the moves performed, in solutionMoves, and what I would like to do is showing this moves on the board, with some delay between a move and the next one. This method is called by my main, which looks like this:

QApplication app(argc, argv);
MainWindow w;
w.show();
w.solveGUI();

return app.exec();

The result is that the GUI hangs and, after some time, it displays only the solution, completely skipping the moves.

What am I missing? Thank you!

P.S. I don't think I need a different Thread for the solver because I want the solver to run before the solution is displayed. Is it right?

Upvotes: 1

Views: 6828

Answers (4)

Ensai Tankado
Ensai Tankado

Reputation: 343

try the following:

void MainWindow::Wait(int interval ) {

    QTime timer = new QTime;
    timer.restart();

    while(timer.elapsed() < interval) {
        QApplication::processEvents();
    }

}

...
 
for(...) { 

//wait 1 second (1000 milliseconds) between each loop run at first
Wait(1000);
...

}
...

not tested yet - but should work (maybe there is some cpu load)!

Upvotes: 0

Yahya Tawil
Yahya Tawil

Reputation: 415

There is a nice article of methods to keep the GUI responsive during processing loops. if it's not a complicated case I think, just insert QCoreApplication::processEvents(); inside the long processing loops.

Upvotes: 1

Sergei Tachenov
Sergei Tachenov

Reputation: 24869

It's app.exec() that actually runs the main loop which handles all events, including displaying GUI. If you want to call solve() before that, it's OK, but if you want to actually display and update GUI before exec(), it's wrong. I'm not sure if it's totally impossible, but it's definitely not the right way to do it.

There are two ways around it. The more canonical way is to redesign a program using a QTimer. Then everything will be smooth and responsive. But that can be tedious sometimes. In your case it should be quite easy, though. Just save the results somewhere, and call a slot using a QTimer object every 1000 seconds - it will have the same effect as your Sleep(), but will keep everything responsive.

The other solution is to call your solveGUI() method after exec() starts its job. It can be done, for example, using QTimer::singleShot():

QTimer::singleShot(0, &w, SLOT(showGUI()));
return app.exec();

Then, before each Sleep(), you should call QApplication::processEvents(), which basically allows you to temporary yield control, processing all pending events, including GUI updates. This approach is somewhat easier, but it's inferior since the GUI still freezes at each Sleep(). For example, if the user wants to exit the application, or if the window is needed to be repainted, it will cause uncomfortable GUI lags.

Upvotes: 1

Marco A.
Marco A.

Reputation: 43662

You're stalling the main thread (which also does the event processing) and rendering it uncapable of responding to keyboard/mouse/window messages.

You should use an asynchronous timer operation instead of the sleep function: use a QTimer to delay showing the next solution and avoid messages being left unanswered for too long.

Upvotes: 1

Related Questions