cXObjEventSink.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXObjEventSink_H
#define _INC_cXObjEventSink_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cXObjPackChild.h"
#include "../Scriptable/cScriptableEventsMask.h"        // EVENTX_TYPE
 
namespace GrayLib
{
        class GRAYLIB_LINK cScriptContext;
        class GRAYLIB_LINK cXObjScript;
 
        enum EVENTPRI_TYPE
        {
                EVENTPRI_FIRST = 0,     
                EVENTPRI_HIGH = 32,     //
                EVENTPRI_MEDIUM = 64,   //
                EVENTPRI_LOW = 128,     //
                EVENTPRI_DEFAULT = 255, 
        };
 
        enum EVENTRET_TYPE
        {
 
                EVENTRET_Failed = HRESULT_WIN32_C(ERROR_INVALID_FUNCTION), 
 
                EVENTRET_Handled = S_OK,                        
                EVENTRET_NotHandled = S_FALSE,          
 
                EVENTRET_HandledNoDefault,      
                EVENTRET_HandledExclusive,      
        };
 
        class GRAYLIB_LINK cXObjEventSink
        : public cXObjPackChild
        {
 
                friend class cXObjEventSinks;
                typedef cXObjPackChild SUPER_t;
 
        public:
                cXObjEventSink(UID_t rid, cAtomRef aSymName, EVENTPRI_TYPE ePriorityLevel = EVENTPRI_MEDIUM);
                virtual ~cXObjEventSink();
 
                static inline bool IsHandledEvent(EVENTRET_TYPE hRes) noexcept
                {
                        // Do we need to call more handlers ?
                        // EVENTRET_IsHandled(hRes)
                        return (hRes == EVENTRET_Handled || hRes >= EVENTRET_HandledNoDefault);
                }
 
                EVENTPRI_TYPE get_SortValue() const noexcept
                {
                        return m_ePriorityLevel;        
                }
 
                virtual void CopyXObject(const cXObjDef* pDef);
 
                // What interface do we want to consume the events? so we can have other higher interfaces that do not!
                virtual const cScriptableInterfaceDef* get_EventSinkInterfaceDef() const = 0;
 
                // Dispatch/Invoke.
                STDMETHOD(s_PropPut)(const cScriptableProp* pProp, const cVariant& vVal) override;
                STDMETHOD(s_PropGet)(const cScriptableProp* pProp, OUT cVariant& vValRet) override;
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, OUT cVariant& vValRet) override;
 
                HRESULT FindEventHandlerN(const ATOMCHAR_t* pszEventName) const;
                HRESULT RegisterEventHandlerN(const ATOMCHAR_t* pszEventName);
                bool UnregisterEventHandlerN(const ATOMCHAR_t* pszEventName);
 
                void InitEventHandlers()
                {
                        // Assume we handle no events yet.
                        m_EventsHandled.ClearEventHandlers();
                }
                void RegisterEventHandler(EVENTX_TYPE eEvent)
                {
                        // Say we handle a method from get_EventSinkInterfaceDef
                        m_EventsHandled.AddEventHandler(eEvent);
                }
                void UnregisterEventHandler(EVENTX_TYPE eEvent)
                {
                        m_EventsHandled.RemoveEventHandler(eEvent);
                }
                bool HasEventHandler(EVENTX_TYPE eEvent) const
                {
                        return m_EventsHandled.HasEventHandler(eEvent);
                }
#if 0
                void RegisterAllEventHandlers()
                {
                        // Assume all methods in the interface are desired.
                        return m_EventsHandled.AddAllEventHandlers();
                }
#endif
 
        public:
                CHEAPOBJECT_IMPL;
                CSCRIPT_CLASS_DEF1(XObjEventSink, cXObjDef);
                enum P_TYPE_
                {
#define cXObjEventSinkProp(a,b,c) P_##a,
#include "cXObjEventSinkProps.tbl"
#undef cXObjEventSinkProp
                        P_QTY,
                };
                static cScriptableProp sm_Props[P_QTY + 1];
 
        protected:
                EVENTPRI_TYPE m_ePriorityLevel;                 
                cScriptableEventsMask m_EventsHandled;  
        };
 
        typedef cRefPtr<cXObjEventSink> cXObjEventSinkPtr;
};
#endif