extern "C" {

    void notifyGUI()

    {

        QCoreApplication::postEvent(g_ui, new YourEvent());

    }

}

typedef void (*NotifyFn)();

void registerNotifyFunction(NotifyFn fn);

registerNotifyFunction(notifyGUI);

class customEvent : public QEvent

{

public:

    static const QEvent::Type MyEventType;

    customEvent():QEvent(customEvent::MyEventType){

        qDebug()<<"construct customEvent MyEventType is "<<MyEventType;

    }

};

class MySender:public QCoreApplication

{

public:

    MySender(int argc, char *argv[]):QCoreApplication(argc, argv) {}

    bool notify(QObject *r, QEvent *e);

    static bool sendEvent(QObject *r, QEvent *e);

    static void postEvent(QObject *receiver, QEvent *event);

};

const QEvent::Type customEvent::MyEventType = (QEvent::Type)QEvent::registerEventType(QEvent::User+100);



bool MySender::notify(QObject *r, QEvent *e)

{

    qDebug()<<"notify got event MyEventType !\n";

    if(e->type() == customEvent::MyEventType){

        qDebug()<<"MyEventType is coming!\n";

        //return false;

    }

    return QCoreApplication::notify(r, e);

}



bool MySender::sendEvent(QObject *r, QEvent *e)

{

    qDebug()<<"sendEvent got event MyEventType !";

    qDebug()<<"e->type() == "<<e->type();

    qDebug()<<"MyEventType is "<<customEvent::MyEventType;

    if(e->type() == customEvent::MyEventType){

        qDebug()<<"MyEventType is coming!\n";

        //return false;

    }

    return QCoreApplication::sendEvent(r, e);

}



void MySender::postEvent(QObject *r, QEvent *e)

{

    qDebug()<<"postEvent got event MyEventType!\n";

    if(e->type() == customEvent::MyEventType){

        qDebug()<<"MyEventType is coming!\n";

        //return false;

    }

    QCoreApplication::postEvent(r, e);

}

class MyArmy:public QObject

{

public:

    MyArmy() {}

    void MyEventHandler(QEvent *e);

    bool event(QEvent *e);

};

//

class MyWatcher:public QObject

{

public:

    MyWatcher() {}

    bool eventFilter(QObject *r, QEvent *e);

};



MySender *psender;

MyArmy army;

customEvent customE;

MyWatcher wathcer;



extern "C" {

    void notifyGUI()

    {

        //QCoreApplication::postEvent(&army, &customE);

        //QCoreApplication::sendEvent(&army, &customE);

        //psender->notify(&army, &customE);

        psender->sendEvent(&army, &customE);

        //psender->postEvent(&army, new customEvent);



    }

}

int main(int argc, char *argv[])

{

    //QCoreApplication a(argc, argv);

    MySender sender(argc, argv);

    psender = &sender;

//    MyArmy army;

//    customEvent customE(MyEventType);

//    MyWatcher wathcer;



    registerNotifyFunction(notifyGUI);

    army.installEventFilter(&wathcer);



    //sender.notify(&army, &customE);



    //sender.sendEvent(&army, &customE);

    //sender.postEvent(&army, &customE);



    return sender.exec();



    //return a.exec();

}





void MyArmy::MyEventHandler(QEvent *e)

{

    qDebug()<<"Event being handled!";

    e->accept();

}



bool MyArmy::event(QEvent *e)

{

    if(e->type() == customEvent::MyEventType){

        qDebug()<<"event is MyEventType";

        this->MyEventHandler(e);

        if(e->isAccepted()){

            qDebug()<<"The event is handled!";

            qDebug()<<"e->type() == "<<e->type();



            return true;

        }

    }

    return QObject::event(e);

}





bool MyWatcher::eventFilter(QObject *r, QEvent *e)

{

    if(e->type() == customEvent::MyEventType){

        qDebug()<<"I DO NOT WANNA FILTER";

        //return false;

    }

    return QObject::eventFilter(r, e);

}

typedef void (*c_NotifyFn)();

void registerNotifyFunction(c_NotifyFn fn);

c_NotifyFn c_fun;

void *thr_fun()

{

    sleep(3);

    c_fun();

    return NULL;

}



int createthread()

{

    int ret;

    pthread_t pid;

    ret = pthread_create(&pid, NULL, thr_fun, NULL);

    if(ret != 0){

        printf("Create pthread failed!\n");

        return -1;

    }

    return 0;

}



void registerNotifyFunction(c_NotifyFn fn)

{

    c_fun = fn;

    createthread();

}