PostThreadMessage just gets last message

Hi there.. i have a strange problem with PostThreadMessage (a
feature? ;-) and perhaps someone can jump in....

I wrote a threading-helper that *should* give an object of a derived
class a worker-thread. That thread is started in the ctor (works) and
killed in the dtor (works, too). The delete in method ThreadPost()
marked with "* MARK *" is not executed, so it seems that
PostThreadMessage works. Unfortunately, when i consecutively call
ThreadPost(), only the last message arrives in _ThreadRun().

Perhaps someone can tell me whats going wrong here?

TIA, .rhavin;)

________________________________________________________
// header file

struct SQTrdMsg {
    QUAD qCommand;
    QUAD qParam;
    QUAD qAux;
    void* pBody;
    BYTE bFlags;
};

class CQThreader {
public:
    CQThreader();
    virtual ~CQThreader();
    bool ThreadPost(QUAD qCmd, QUAD qParam = 0, QUAD qAux = 0,
        PCVOID pBody = NULL, BYTE bFlags = QTMF_DELETEBODY);
    bool ThreadPost(SQTrdMsg const* pTrdMsg);
    virtual inline bool ThreadOnReceived(SQTrdMsg* pMsg) {return false;};
    inline bool ThreadIsRunning() const {return m_fTreadRunning;};
    inline void _ThreadRunning(bool fRunning) {m_fTreadRunning =
fRunning;};
    static CWinThread* _ThreadStart(void* pThis);
    static bool _ThreadStop(CWinThread* pThread);
    static UINT _ThreadRun(void* pThis);
private:
    CWinThread* m_pThread;
    bool m_fTreadRunning;
};
________________________________________________________
// implementation file

//-----------------------------------------------------------------------------
CQThreader::CQThreader() {
    _ThreadRunning(false);
    m_pThread = _ThreadStart(this);
    while (!ThreadIsRunning()) {
        Sleep(0);
    }
}

//-----------------------------------------------------------------------------
CQThreader::~CQThreader() {
    if (_ThreadStop(m_pThread)) {
        while (ThreadIsRunning()) {
            Sleep(0);
        }
    }
}

//-----------------------------------------------------------------------------
bool CQThreader::_ThreadStop(CWinThread* pThread) {
    if (pThread == NULL)
        return false;
    pThread->PostThreadMessage(WM_QUIT, 0, 0);
    return true;
}

//-----------------------------------------------------------------------------
bool CQThreader::ThreadPost(QUAD qCmd, QUAD qParam, QUAD qAux, PCVOID
pBody,
                           BYTE bFlags)
{
    SQTrdMsg QTMsg;
    QTMsg.qCommand = qCmd;
    QTMsg.qParam = qParam;
    QTMsg.qAux = qAux;
    QTMsg.pBody = const_cast<void*>(pBody);
    QTMsg.bFlags = bFlags;
    bool bRet = ThreadPost(&QTMsg);
    return bRet;
}

//-----------------------------------------------------------------------------
bool CQThreader::ThreadPost(SQTrdMsg const* pTrdMsg) {
    if (pTrdMsg == NULL)
        return false;
    SQTrdMsg* pM = new SQTrdMsg;
    if (pM == NULL)
        return false;
    *pM = *pTrdMsg;
    ThreadOnReceived(pM);
    delete pM;
    return true;
    if (m_pThread->PostThreadMessage(QT_QTRDMSG, 0, (LPARAM) pM) !=
FALSE)
        return true;
    delete pM; // <-- * MARK *
    return false;
}

//-----------------------------------------------------------------------------
CWinThread* CQThreader::_ThreadStart(void* pThis) {
    CWinThread* pThread = AfxBeginThread(_ThreadRun, pThis,
        THREAD_PRIORITY_NORMAL,0, CREATE_SUSPENDED);
    if (pThread == NULL)
        return NULL;

    pThread->ResumeThread();
    return pThread;
}

//-----------------------------------------------------------------------------
// static
UINT CQThreader::_ThreadRun(void* pThis) {
    // note: GetMessage returns -1 on error, 0 on WM_QUIT
    // or on no message available, and 1 on all others
    MSG msg;
    int iRet;
    SQTrdMsg* pFzMsg;
    if (pThis == NULL)
        return -1;

    CQThreader* pThreader = (CQThreader*) pThis;
    pThreader->_ThreadRunning(true);

    while (true) {
        iRet = GetMessage(&msg, (HWND) 0, 0, 0);
        switch (iRet) {
        case -1:
            //error
            break;
        case 1:
            if (msg.message == QT_QTRDMSG) {
                if (msg.lParam == NULL)
                    break;
                pFzMsg = (SQTrdMsg*) msg.lParam;
                pThreader->ThreadOnReceived(pFzMsg);
                delete pFzMsg;
            } else {
                ::TranslateMessage(&msg);
                ::DispatchMessage(&msg);
            }
            break;
        case 0:
            if (msg.message == WM_QUIT) {
                pThreader->_ThreadRunning(false);
                return 0;
            }
        }
        Sleep(0);
    }
    pThreader->_ThreadRunning(false);
    return 0;
}