---

spl_event_mgr.h

Go to the documentation of this file.

// ----------------------------------------------------------------------- //
//
// MODULE  : spl_event_mgr.h
//
// PURPOSE : CSplEventMgr class - Definition
//
// CREATED : 04/07/01
//
// (c) 2001 LithTech, Inc.  All Rights Reserved
//
// ----------------------------------------------------------------------- //

#ifndef __SPL_EVENT_MGR_H__
#define __SPL_EVENT_MGR_H__

#include "i_spl_event_mgr.h"

const float FLOAT_EPSILON = 5e-6f;

class CCallbackRecord
{
public:
    CCallbackRecord(IEventCallback* pEC, ECallbackType eCT, uint8 nCount,
        float fTime, uint8 nPriority, IEventData *pEventData) : m_pEC(pEC), m_eCT(eCT),
        m_nCountRemaining(nCount), m_fTimeRemaining(fTime),
        m_fLoopTime(fTime), m_nPriority(nPriority), m_pEventData(pEventData),
        m_pNext(NULL) {}
    
    CCallbackRecord() : m_pEC(NULL), m_eCT(CBT_INVALID),
        m_nCountRemaining(0), m_pEventData(NULL),
        m_fTimeRemaining(0.0f), m_fLoopTime(0.0f), m_nPriority(0),
        m_pNext(NULL) {}

    IEventCallback* m_pEC;
    ECallbackType   m_eCT;
    uint8           m_nCountRemaining;
    float           m_fTimeRemaining;
    float           m_fLoopTime;
    uint8           m_nPriority;
    IEventData*     m_pEventData;
    CCallbackRecord* m_pNext;
};

class CCallbackRequest
{
public:
    CCallbackRequest(IEventCallback* pEC, uint8 nEvent, uint8 nPriority,
        ECallbackType eCT, uint8 nCount, float fTime) :
    m_bAddRequest(true),
        m_pEC(pEC), m_eCT(eCT), m_nCount(nCount),
        m_nEvent(nEvent), m_nPriority(nPriority),
        m_fTime(fTime), m_pNext(NULL) {}
    
    CCallbackRequest(IEventCallback* pEC, uint8 nEvent, uint8 nPriority) :
    m_bAddRequest(false),
        m_pEC(pEC), m_eCT(CBT_INVALID), m_nCount(0),
        m_nEvent(nEvent), m_nPriority(nPriority),
        m_fTime(0.0f), m_pNext(NULL) {}
    
    CCallbackRequest() : m_pEC(NULL), m_eCT(CBT_INVALID), m_nCount(0),
        m_fTime(0.0f), m_nEvent(0), m_nPriority(0), m_pNext(NULL) {}
    
    bool            m_bAddRequest;
    IEventCallback* m_pEC;
    ECallbackType   m_eCT;
    uint8           m_nCount;
    float           m_fTime;
    uint8           m_nEvent;
    uint8           m_nPriority;
    CCallbackRequest* m_pNext;
};

class CEventClass
{
public:

    CEventClass(uint32 nEvent) : m_nEvent(nEvent),
        m_pCallbackHead(NULL), m_pNext(NULL) {}


    uint32          m_nEvent;
    CCallbackRecord* m_pCallbackHead;
    CEventClass*    m_pNext;
};


class CEventProcessingState
{
public:
    CEventProcessingState() : m_pPrevEvent(NULL), m_pCurEvent(NULL),
        m_pPrevCallbackRec(NULL), m_pCurCallbackRec(NULL),
        m_pNextCallbackRec(NULL) {}

    CEventClass     *m_pPrevEvent;
    CEventClass     *m_pCurEvent;
    CCallbackRecord *m_pPrevCallbackRec;
    CCallbackRecord *m_pCurCallbackRec;
    CCallbackRecord *m_pNextCallbackRec;
};

class CCallbackData
{
public:
    CCallbackData() : 
        m_nEvent(EVENTMGR_EVENT_ANY), m_fFrameTime(0.0f), m_fGameTime(0.0f),
        m_nPriority(EVENTMGR_PRIORITY_ANY), m_pEventData(NULL) {}
    uint8           m_nEvent;
    float           m_fFrameTime;
    float           m_fGameTime;
    IEventData      *m_pEventData;
    uint8           m_nPriority;
};

/*
nEvent - list of uint32 registered priorities

nPriority - list of IEventCallback*
*/

class CSplEventMgr : public ISplEventMgr
{
public:
    CSplEventMgr();
    ~CSplEventMgr();
    
    
    declare_interface(CSplEventMgr);
    
    interface_version(CSplEventMgr, 0);
    
    virtual LTRESULT Event(uint8 nEvent, float fFrameTime, float fGameTime,
        IEventData *pEventData = NULL,
        uint8 nPriority = EVENTMGR_PRIORITY_ANY);
    
    virtual LTRESULT AddCallback(IEventCallback *pEC, uint8 nEvent,
                       ECallbackType eCT, uint8 nCount, float fTime,
                       uint8 nPriority = EVENTMGR_PRIORITY_DEFAULT);
    
    virtual LTRESULT RemoveCallback(IEventCallback *pEC,
        uint8 nEvent = EVENTMGR_EVENT_ANY,
        uint8 nPriority = EVENTMGR_PRIORITY_ANY);
    
    virtual LTRESULT GetCallbackInfo(IEventCallback *pEC, uint8 nEvent,
        uint8 nPriority, ECallbackType &eCT, uint8 &nCountRemaining,
        float &fLoopTime, float &fTimeRemaining);
    
    virtual void DumpData(printf_fn pPrintfFn);
    
    virtual void DebugSpew(printf_fn pPrintfFn);
    
private:
    
    LTRESULT    EventTopLoop(CEventProcessingState *pState,
                    CCallbackData *pData);
    LTRESULT    EventLoop(CEventProcessingState *pState,
                    CCallbackData *pData);

    LTRESULT    EventCallbackLoop(CEventProcessingState *pState,
                    CCallbackData *pData);
    LTRESULT    Callback(CEventProcessingState *pState,
                    CCallbackData *pData);
    LTRESULT    RetireCallback(CEventProcessingState *pState);

    void        ProcessRequests();
    
    void        InsertCallback(CEventClass *&pEvent, uint8 nEvent,
                    CCallbackRecord *pNewCallback);
    void        InsertCallback(CEventClass *pEvent, 
                    CCallbackRecord *pNewCallback);
    void        InsertCallback(CCallbackRecord *pAfterThis,
                    CCallbackRecord *pNewCallback);
    void        InsertHead(CEventClass *pEvent, 
                    CCallbackRecord *pNewCallback);

    LTRESULT    DeleteCallback(CEventClass *&pEvent, uint8 nEvent,
                    CCallbackRequest *pDeleteRequest);
    LTRESULT    DeleteCallback(CEventClass *pEvent,
                    CCallbackRequest *pDeleteRequest);
    void        DeleteCallback(CCallbackRecord *pAfterThis);
    void        DeleteHead(CEventClass *pEvent);
    
    void        DeleteEvent(CEventClass *pAfterThis);
    void        DeleteHeadEvent(CEventClass *&pEventHead);

    void        DumpRecord(printf_fn pPrintfFn, CCallbackRecord &cbRec);
    
    printf_fn           m_pPrintfFn;

    CEventClass         *m_pEventList;
    CCallbackRequest    *m_pCBRequestList;
    
    bool                m_bProcessingEvent;
    
};

#endif // __SPL_EVENT_MGR_H__

---