Question

I am doing one web related project. Recently I hit on this situation. This is just a stub

Class My_Class
{
public:
    My_Class();
    void start();
public slots():
    void after_Load_Function();
}

My_Class::My_Class()
{
    //Some initializations
    connect(WebPage,SIGNAL(finished()),this,SLOTS(after_Load_Function()));
}

void My_Class::start()
{
    WebPage->load();
}

void My_Class::after_Load_Function()
{
    //Do something with the finished WebPage
}

int main(int argc,char * argv[])
{
    //Some Qt things

    My_Class a;
    a.start();
}

“WebPage” emits the signal “finished” when it loaded fully.
Now the problem is before the “webPage” got loaded the “start” is returning. Thereby the control reaches the “main”. So, now the control should return from “start” only after “after_Load_Function” finishes it’s job. Thereby I want the below sequence,

1. main creates the My_Class object A.
2. main calls “start” from A.
3. start calls load from “WebPage” and it waits untill the “WebPage” emits “finished”,
   and that emit in turn calls the “after_Load_Function”, and “after_Load_Function”
   finishes it’s job.
4. now, the “start” returns
5. main returns

But, I don’t know how to make this kind of wait condition. How can I go about it?

Answer 1

You can do this by running a local event loop, letting the components process network income and load the page. When they emit the signal, you execute a slot on the event loop to quit it.

void My_Class::start()
{
    QEventLoop qel;
    QObject::connect(WebPage, SIGNAL(finished()), &qel, SLOT(quit()));

    WebPage->load();
    qel.exec();
}

I’ve been using this before and it works fine. I don’t advice to use this too often though, because it will process events, including those that the caller of start might not be expecting to be processed during the call to start, so you need to document this to its callers. You can prevent the processing of some events by passing certain flags to QEventLoop::exec, like preventing to process user interface events.