An Implementation of inter-thread communication between UI thread and Worker threads with Qt

Introduction
The basic concept of this implementation is explained on my previous post.

Architecture

Implementation

Event Object

class QtITCEvent:public QEvent
{
public:
    QtITCEvent(BaseEventHandler& handler, int val)
        :QEvent(IPC_THREAD_EVENT),
        value(val),
        handler(receiver)
    {

    }
    int getValue() // NS
    {
        return value;
    }

    CPortalNetThreadChanger& getHandler() // NS
    {
        return handler;
    }

private:
    int value;
    BaseEventHandler& handler;
};

class QtEventHandler:public QObject, BaseEventHandler
{
public:
    static BaseEventHandler& getInstance() // NS
    {
        static QtEventHandler instance;
        return &instance;
    }

protected:
    virtual bool event ( QEvent * e ) // NS
    {
        if (e->type() == IPC_THREAD_EVENT)
        {
            QtITCEvent* myEvent = dynamic_cast(e);
            if (!myEvent)
            {
                return false;
            }
            myEvent->getHandler().onHandleEvent(myEvent->getValue());
            return true;
        }
        return false;

    }
private:
    QtEventHandler()
    {

    }
    QtEventHandler(QtEventHandler&);
    void operator=(QtEventHandler&);


};

QtEventTrigger::QtEventTrigger()
{
    if (IPC_THREAD_EVENT == QEvent::None)
    {
        IPC_THREAD_EVENT = static_cast(QEvent::registerEventType());
    }
}

QtEventTrigger::~QtEventTrigger()
{

}

void QtEventTrigger::fire(int value) // NS
{
    QtITCEvent * event = new QtITCEvent(this, value);
    QCoreApplication::postEvent(QtEventHandler::getInstance(), event);
}