Sending signal from static class method in Qt

Question

I am trying to code a static callback function that is called frequently from another static function within the same class. My callback function needs to emit a signal but for some reason it simply fails to do so. I have put it under a debugger and the slot never gets called. However when I place the code I used to emit the data in a non-static function it works. Is there a reason I cannot emit a signal from a static function? I have tried declaring a new instance of the class and calling the emit function but with no luck.

class Foo
{
signals:
    emitFunction(int);
private:
    static int callback(int val)
    {
        /* Called multiple times (100+) */
        Foo *foo = new Foo;
        foo.emitFunction(val);
    }
    void run()
    {
        callback(percentdownloaded);
    }
};

I have posted some basic code that demonstrates what I am attempting to do. I will post full code upon request.

Edit: I am posting the full code since this is kind of an odd scenario. http://pastebin.com/6J2D2hnM

Ujiji

Where do you connect the SIGNAL and the SLOT? – Receptive

I connect them in a separate .cpp file that is called on a button press. void MainWindow::on_pushButton_clicked() { tProc = new Foo(this); connect(tProc, SIGNAL(ValChanged(int)), this, SLOT(onNumberChanged(int))); tProc->start(); } it then creates a new instance of my Foo class and starts the thread that calls the callback function. – Ujiji

In your static callback function you create a new Foo instance and call the signal on it. I suppose this is the point where you want to emit the signal. How do you connect this instance to the slot you want to address? – Receptive

I am not completely sure what you mean, but I am assuming I connected it correctly in the MainWindow::on_pushButton_clicked() function. Do I need to somehow re-connect it in the static function? – Ujiji

In clicked function you connected your slot to one Foo, but in callback you created another separate Foo that knows nothing about first foo. And you emit signal of this new Foo, but signals of new Foo are not connected to any slots. – Ivatts

Gotcha. It boils down to my first problem then. Calling the emit from my static callback function. The compiler won't let me call a non-static function (the emit) from a static function (callback). I tried to solve it by creating the new class. – Ujiji

Answer 1

That is not going to work, because you are creating a new Foo every time you enter that static function, and you do not connect a signal to a slot.

So, the fix would be to pass the object to that function :

class Foo
{
signals:
    emitFunction(int);
private:
    static int callback(int val, Foo &foo)
    {
        /* Called multiple times (100+) */
        foo.emitFunction(val);
    }
    void run()
    {
        callback(percentdownloaded, *this);
    }
};

Another option is to use postEvent, but I wouldn't recommend it.

---

Since you can not modify callback's signature, you can do it like this :

class Foo
{
signals:
    emitFunction(int);
private:
    static int callback(int val)
    {
        /* Called multiple times (100+) */
        theFoo->emitFunction(val);
    }
    static Foo *theFoo;
    void run()
    {
        callback(percentdownloaded, *this);
    }
};

but you'll have to initialize that static variable somewhere.

Visayan

This would work, but the problem is my static callback function is being called by another function that is from the libCURL library and I cannot pass arguments to it. I am not sure how to implement your method in this case. – Ujiji

@Ujiji add a static variable, which is used in the callback. I'll edit the answer – Caret

Thanks. I ended up using your static variable and initialized it by passing the current class instance as a parameter to the thread. I used that parameter to initialize the class and it worked. – Ujiji

Thanks so much! I wasted hours on trying to get it to work, your second suggestion was great! – Insist

@Visayan I tried the second approach but it says undefined reference to `Foo ::theFoo' when I want to initialize it in contractor. – Overhead

@MajidHojati What is "contractor"? See #4548160 – Caret

Answer 2

in case someone still finding the solution, here is what I did, it works in my project. 1. make your class to be a singleton 2. in static cb function , load emitFunction from the your singleton class

    static int callback(int val)
   {
   /* Called multiple times (100+) */
   MYClass::getInstance()->emitFunction(val);
   }

Blodgett

nice approach and simple, it is even thread safe since signal emit is. +1 – Misprize

Answer 3

There is an elegant solution. You can emit a signal in a static member function like this:

emit (instance().newMessage(message));

Celery

Answer 4

You must provide a pointer to the class instance in order to make it work.

Notice however that in general it is not advised to emit signals from static functions. Static functions can be called without creating an instance of the class, which means that (if you do not provide as argument the sender and use it explicitely), you will not have a "sender" object for the emited signals.

For these cases as Lol4t0 suggests I also prefer callbacks.

Demodulate