TnbTimerDispatch.h

[詳解]

#pragma once
#include "TnbThreadDispatch.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTimerDispatch
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnTimer(UINT_PTR uTimerId, LPARAM lParam, const CTimerDispatch& timer) = 0;
 
        virtual void OnSetup(void) {}
    };
 
private:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    enum
    {
        WMTT_SETTIMER   = WM_APP,       
        WMTT_KILLTIMER  = WM_APP + 1,   
    };
 
    struct TParam
    {
        UINT_PTR    uTimerId;       
        UINT        uElapse;        
        LPARAM      lParam;         
        CSyncEvent  eventSuccess;   
        TParam(UINT uEla, LPARAM lp) : uTimerId(0), uElapse(uEla), lParam(lp)
        {
            eventSuccess.ToLock();
        }
    };
 
    class CListener : public CThreadDispatch::IListener
    {
        DEFPARENTLISTENER(CTimerDispatch, IParentListener);
    public:
 
        void Set(CTimerDispatch* P, IParentListener* I)
        {
            m_pcTimer    = P;
            m_piListener = I;
        }
 
    private:
        virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam)
        {
            switch ( nMsg )
            {
            case WMTT_SETTIMER:
                {
                    TParam* P = reinterpret_cast<TParam*>(lParam);
                    UINT_PTR i = ::SetTimer(NULL, 0, P->uElapse, reinterpret_cast<TIMERPROC>(P->lParam));
                    ASSERT(i != 0);
                    P->uTimerId = i;
                    P->eventSuccess.Unlock();
                }
                break;
            case WMTT_KILLTIMER:
                ::KillTimer(NULL, lParam);
                break;
            case WM_TIMER:
                ASSERTLIB(m_piListener != NULL);
                ASSERTLIB(m_pcTimer != NULL);
                return m_piListener->OnTimer(wParam, lParam, *m_pcTimer);
                break;
            default:
                break;
            }
            return true;
        }
        virtual void OnThreadDispatchSetup(void)
        {
            ASSERTLIB(m_piListener != NULL);
            m_piListener->OnSetup();
        }
        IParentListener*    m_piListener;   
        CTimerDispatch*     m_pcTimer;      
    };
 
    friend class CTimerDispatch::CListener; 
    CThreadDispatch     m_dispatch;         
    CListener           m_listener;         
 
    struct TDefaultListener : IListener
    {
        virtual bool OnTimer(UINT_PTR uTimerId, LPARAM lParam, const CTimerDispatch& timer)
        {
            return const_cast<CTimerDispatch&>(timer).OnTimer(uTimerId, lParam);
        }
    } m_lisDef;
 
    #endif //_TnbDOXYGEN
 
public:
 
    CTimerDispatch(void)
    {
        m_listener.Set(this, &m_lisDef);
        m_dispatch.SetListener(&m_listener);
    }
 
    virtual ~CTimerDispatch(void)
    {
        Stop();
    }
 
    void SetListener(IListener* P)
    {
        m_listener.Set(this, (P != NULL) ? P : &m_lisDef);
    }
 
    bool Start(LPCTSTR lpszName = NULL)
    {
        #ifdef _DEBUG
            if ( lpszName == NULL) { lpszName = _T("TimerDispatch:MessagePump"); }
        #endif
        return m_dispatch.Start(lpszName);
    }
 
    bool Stop(void)
    {
        return m_dispatch.Stop();
    }
 
    UINT_PTR SetTimer(UINT uElapse, LPARAM lParam = 0) const
    {
        if ( m_dispatch.GetThreadId() == ::GetCurrentThreadId() )
        {
            return ::SetTimer(NULL, 0, uElapse, reinterpret_cast<TIMERPROC>(lParam));
        }
        TParam t(uElapse, lParam);
        if ( m_dispatch.PostMessage(WMTT_SETTIMER, 0, reinterpret_cast<LPARAM>(&t)) )
        {
            t.eventSuccess.Lock();  //Post先の処理が終わるのを待つ
            return t.uTimerId;      //Post先で値を入れてくれている
        }
        return 0;
    }
 
    bool KillTimer(UINT_PTR uTimerId) const
    {
        if ( m_dispatch.GetThreadId() == ::GetCurrentThreadId() )
        {
            return !! ::KillTimer(NULL, uTimerId);
        }
        return m_dispatch.PostMessage(WMTT_KILLTIMER, 0, uTimerId);
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_dispatch.ReferThreadStatus();
    }
 
    virtual bool OnTimer(UINT_PTR uTimerId, LPARAM lParam)
    {
        ASSERT0(false, "CTimerDispatch", "継承もリスナ登録も行われずに使用されています。");
        return false;
    }
 
private:
    friend class CTimerDispatchTest;
};
 
 
 
};//TNB