how to emit signal in a static function ?

[cxl2253]

yes, .it works well.

[wysota]

yes, .it works well.

Can we see the code? Based on my knowledge you can't rely on "this" pointer in a static method as the static method is not part of any object...

[cxl2253]

of course,the following is code.but i still cannot decalre the static variable in class scope,when i do it ,the VC7 always report various error.either not define the variable or cannot be interped by metaobject.

///////////////////////storescpThread.h
typedef (*STORESCPCALLBACK)(void *callbackData, char* statusDetail);
static unsigned long classAddress;
class storescpThread:public QThread
{
Q_OBJECT
public:
    storescpThread(QTextEdit *txtEdit,QObject *parent = 0)
    ~storescpThread();
protected:
     void run();
     static void emitMsg( unsigned long user_value,char  * filename)
     {
        storescpThread* pthis = (storescpThread*)user_value; // 
        pthis->setText(state,filename);		
     }
   void mycallback();
private :
    QTextEdit * textEdit;	 
    static void storeSCPCallback(void *callbackData, char* statusDetail);	
    void setText(char * state,char * name);
};
 
///////////////////////storeScpThread.cpp
storescpThread::storescpThread(QTextEdit *txtEdit,QObject *parent): QThread(parent)
{
    textEdit=txtEdit;
   classAddress =(unsigned long)this ;
}
void storescpThread:: storeSCPCallback(void *callbackData, char* statusDetail)
{
    emitMsg(classAddress,statusDetail);
    return ;
}
void  storescpThread::mycallback()
{
   myThirdCallFunction(storeSCPCallback);   //the third party function, which used callback as param
 
}

///////////////////////storescpThread.h
typedef (*STORESCPCALLBACK)(void *callbackData, char* statusDetail);
static unsigned long classAddress;
class storescpThread:public QThread
{
Q_OBJECT
public:
    storescpThread(QTextEdit *txtEdit,QObject *parent = 0)
    ~storescpThread();
protected:
     void run();
     static void emitMsg( unsigned long user_value,char  * filename)
     {
        storescpThread* pthis = (storescpThread*)user_value; // 
        pthis->setText(state,filename);		
     }
   void mycallback();
private :
    QTextEdit * textEdit;	 
    static void storeSCPCallback(void *callbackData, char* statusDetail);	
    void setText(char * state,char * name);
};

///////////////////////storeScpThread.cpp
storescpThread::storescpThread(QTextEdit *txtEdit,QObject *parent): QThread(parent)
{
    textEdit=txtEdit;
   classAddress =(unsigned long)this ;
}
void storescpThread:: storeSCPCallback(void *callbackData, char* statusDetail)
{
    emitMsg(classAddress,statusDetail);
    return ;
}
void  storescpThread::mycallback()
{
   myThirdCallFunction(storeSCPCallback);   //the third party function, which used callback as param
   
}

To copy to clipboard, switch view to plain text mode 

[wysota]

Oh God.... This is some kind of madness... I won't even ask what happens if you have two instances of the thread class or what happens if you delete the object without unregistering the callback...

Why don't you move the callback method outside the class so that it's a standalone function instead? You can't call any of the nonstatic class member anyway, so what's the point of having this static method part of the thread class?

[captainst]

Implementing some Win32 Callback is quite necessary in some cases to make *good* use of Win32 API.

Found this old thread on google. What I did is to add a global pointer to the current class, like this:

in the header file

class MyClass {
public:
    MyClass ();
    ~MyClass ();
private:  
    static void CALLBACK MyCallback (int nMsg);
    void emitMySignal (int nMsg);
signals:
    mySignal (int nMsg);
}

class MyClass {
public:
    MyClass ();
    ~MyClass ();
private:  
    static void CALLBACK MyCallback (int nMsg);
    void emitMySignal (int nMsg);
signals:
    mySignal (int nMsg);
}

To copy to clipboard, switch view to plain text mode 

in the cpp file, at the beginning define a global pointer to the current class

MyClass* pThis;
 
MyClass:MyClass ()
{
    pThis = this;
}
 
void MyClass::MyCallback (int nMsg)
{
    pThis->emitMySignal(nMsg);
}
 
void MyClass::emitMySignal (int nMsg)
{
    emit mySignal (nMsg);
}

MyClass* pThis;

MyClass:MyClass ()
{
    pThis = this;
}

void MyClass::MyCallback (int nMsg)
{
    pThis->emitMySignal(nMsg);
}

void MyClass::emitMySignal (int nMsg)
{
    emit mySignal (nMsg);
}

To copy to clipboard, switch view to plain text mode 

[Goddard]

I had a very similar situation with the libusb library. If I wanted to have callbacks and use the async model they have laid out I couldn't figure out a better way.

Is this the best way still, at least when using existing c libraries?

[jefftee]

In my experience with callbacks from various libraries, there's usually a method for storing a pointer or user data that is presented to the callback. I've used that capability in the past to pass a pointer to the class instance, so that even though the static member callback function doesn't have a "this" pointer, the method would be able to execute any class functions or class data, etc.

[Goddard]

In my experience with callbacks from various libraries, there's usually a method for storing a pointer or user data that is presented to the callback. I've used that capability in the past to pass a pointer to the class instance, so that even though the static member callback function doesn't have a "this" pointer, the method would be able to execute any public class functions or public class data, etc.

So basically sharing the class instance pointer to the static function? Then just making sure it is only used within a class instance and dealing with removing the reference with what ever means the library offers.

[jefftee]

So basically sharing the class instance pointer to the static function? Then just making sure it is only used within a class instance and dealing with removing the reference with what ever means the library offers.

Easier to give you an example. Here's what I've used for libCurl when I've used its callback functions.

header file that declares the static member function:

private:
  static size_t       write_function( void *ptr, size_t size, size_t nmemb, void *stream);

private:
  static size_t       write_function( void *ptr, size_t size, size_t nmemb, void *stream);

To copy to clipboard, switch view to plain text mode 

cpp file that implements the static member functiion:

size_t libFlickr::write_function( void *ptr, size_t size, size_t nmemb, void *stream)
{
  size_t total = size * nmemb;
 
  libFlickr* pFlickr = reinterpret_cast<libFlickr*>(stream);
 
  if (pFlickr)
  {
    pFlickr->some_public_method();
    return total;
  }
  else
  {
    return 0;
  }
 
}

size_t libFlickr::write_function( void *ptr, size_t size, size_t nmemb, void *stream)
{
  size_t total = size * nmemb;

  libFlickr* pFlickr = reinterpret_cast<libFlickr*>(stream);

  if (pFlickr)
  {
    pFlickr->some_public_method();
    return total;
  }
  else
  {
    return 0;
  }

}

To copy to clipboard, switch view to plain text mode 

and finally the cpp code that invokes libcurl, specifies the callback, and sets the user data pointer, etc:

m_code = curl_easy_setopt(m_pCurl, CURLOPT_WRITEFUNCTION, libFlickr::write_function);                                                     
m_code = curl_easy_setopt(m_pCurl, CURLOPT_WRITEDATA, (void*)this);
m_code = curl_easy_perform(m_pCurl);

m_code = curl_easy_setopt(m_pCurl, CURLOPT_WRITEFUNCTION, libFlickr::write_function);                                                     
m_code = curl_easy_setopt(m_pCurl, CURLOPT_WRITEDATA, (void*)this);
m_code = curl_easy_perform(m_pCurl);

To copy to clipboard, switch view to plain text mode 

In the case of libcurl, it passes the CURLOPT_WRITEDATA value to the callback function as the void* stream argument. Every other use I've had for callback functions has provided a way to pass data that is given back to the callback function, so passing the "this" pointer results in the callback receiving the instance pointer.

Hope that helps.

[anda_skoa]

the method would be able to execute any public class functions or public class data, etc.

Any method or data, even private.
The static method is in the same class context.

Cheers,
_

[jefftee]

Any method or data, even private.
The static method is in the same class context.

Thanks, I'll edit my post so that I don't mislead anyone that runs across this thread on the future.

Edit: For some reason, I don't see an option to edit my prior post...

[anda_skoa]

Strange, I edited it for you.

Cheers,
_

[Goddard]

Good stuff. I'm just learning working with this type of library. Appreciate that. I now noticed it does indeed offer a void* user_data parameter in the function to pass through. I just overlooked that completely.