mobject.h

Go to the documentation of this file.

//
//                          IMPORTANT NOTICE
//
// The following open source license statement does not apply to any
// entity in the Exception List published by FMSoft.
//
// For more information, please visit:
//
// https://www.fmsoft.cn/exception-list
//

#ifndef _MGUI_NCSCTRL_OBJECT_H
#define _MGUI_NCSCTRL_OBJECT_H

#ifdef __cplusplus
extern "C"{
#endif

#define MGNCS_INIT_CLASS(clss) \
        Class(clss).classConstructor((mObjectClass*)(void*)(&(Class(clss))))

#define _c(ths)                 (ths)->_class
#define ClassType(className)    className##Class
#define Class(className)        g_st##className##Cls
#define ObjectType(className)   className

#ifdef  WIN32
#define _TYPEOF(x)  void* //__typeof(x)
#else 
#define _TYPEOF(x)  typeof(x)
#endif

#define BEGIN_MINI_CLASS(clss, superCls) \
static ClassType(clss) * clss##ClassConstructor(ClassType(clss)* _class); \
ClassType(clss) Class(clss) = { (PClassConstructor)clss##ClassConstructor }; \
static const char* clss##_type_name = #clss; \
static ClassType(clss) * clss##ClassConstructor(ClassType(clss)* _class) { \
        unsigned short * _pintfOffset = NULL; \
        _pintfOffset = (unsigned short *)((UINT_PTR)_pintfOffset ^ 0); /* VW: prevent unused-but-set-variable warning */ \
        _class = (ClassType(clss)*)((PClassConstructor)(Class(superCls).classConstructor))((mObjectClass*)_class); \
        _class->super = (superCls##Class*)&Class(superCls); \
        _class->typeName = clss##_type_name; \
        _class->objSize = sizeof(clss);      \
        _pintfOffset = &_class->intfOffset;

#define END_MINI_CLASS return _class; }

#define CLASS_METHOD_MAP(clss, name) \
                _class->name = (_TYPEOF(_class->name))(clss##_##name);


#define NEED_CHECK

#ifdef NEED_CHECK
#define CHECK_METHOD(cls, mth)  ((cls) && (cls)->mth)
#else
#define CHECK_METHOD(cls, mth)  (1)
#endif


#define PUBLIC
#define PRIVATE
#define PROTECTED
#define STATIC

#define _M(pobj, method, ...)  _c(pobj)->method((pobj), ##__VA_ARGS__)

#define DECLARE_CLASSEX(EXPORT, clss, clssSuper) \
        typedef struct _##clss##Class clss##Class; \
        typedef struct _##clss clss; \
        struct _##clss##Class{ \
                clss##ClassHeader(clss, clssSuper) \
        }; \
        struct _##clss { \
                clss##Header(clss) \
        }; \
        EXPORT extern clss##Class g_st##clss##Cls;

#define DECLARE_CLASS(clss, clssSuper) DECLARE_CLASSEX(MGNCS_EXPORT, clss, clssSuper)
#define NONE_EXPORT

#define _SUPER(super,self,method, ...)  Class(super).method((super*)(self), ##__VA_ARGS__)

#define DECLARE_OBJECT(Clss)  \
        typedef struct _##Clss##Class Clss##Class;  \
        typedef struct _##Clss Clss;  \
        MGNCS_EXPORT extern Clss##Class g_st##Clss##Cls;

#define DEFINE_OBJECT(Clss, ClssSuper)  \
        struct _##Clss##Class { Clss##ClassHeader(Clss, ClssSuper) }; \
        struct _##Clss { Clss##Header(Clss) };

#define INTERFACE(Interface)  \
        Interface##VTable * Interface##_; /*Interface vtable*/

#define DECLARE_INTERFACE(Interface)  \
        typedef struct _##Interface##VTable Interface##VTable; \
        typedef struct _##Interface Interface;

#define DEFINE_INTERFACE(Interface)          \
        struct _##Interface##VTable {                             \
                Interface##Header(Interface, Interface)         \
        };                                                        \
        struct _##Interface { Interface##VTable *_vtable; };

#define IMPLEMENT(Clss,Interface) \
        _class->_##Interface##_obj_offset = (UINT_PTR)(void*)&(((Clss*)0)->Interface##_); \
        _class->_##Interface##_next_offset = 0;                                                \
        *_pintfOffset =  (unsigned short)(UINT_PTR)(void*)&(((ClassType(Clss)*)0)->_##Interface##_obj_offset); \
        _pintfOffset = &_class->_##Interface##_next_offset;

#define INTERFACE_CAST(Interface, pobj)  \
        ((Interface*)((unsigned char*)(pobj) + (_c(pobj)->_##Interface##_obj_offset)))

//the basic interface
DECLARE_INTERFACE(IInterface)
struct _IInterfaceVTable{
        unsigned short _obj_offset;
        unsigned short _next_offset;
};

struct _IInterface {
        IInterfaceVTable * _vtable;
};

#define IInterfaceHeader(Interface, ClssImpl)  \
        unsigned short _##Interface##_obj_offset; \
        unsigned short _##Interface##_next_offset; \


#define INTEFACE_ADJUST(piobj)  (_TYPEOF(piobj))((unsigned char*)(piobj) -  \
                ((IInterfaceVTable*)((piobj))->_vtable)->_obj_offset)

#define INTERFACE2OBJECT(type, piobj)  (type*)((unsigned char*)(piobj) - ((IInterfaceVTable*)((piobj))->_vtable)->_obj_offset)

#define _IM(piobj, method, ...) \
        (piobj)->_vtable->method(INTEFACE_ADJUST(piobj), ##__VA_ARGS__)
#define _I(piobj)  (piobj)->_vtable



typedef struct _mObjectClass mObjectClass;
typedef struct _mObject mObject;

typedef mObjectClass* (*PClassConstructor)(mObjectClass *);

typedef void (*PCONSTRUCT_DWORD)(void* self, DWORD addData);
#include <stdarg.h>
typedef void (*PCONSTRUCT_VALIST)(void* self, va_list va);

#define mObjectClassHeader(clss, superCls) \
        PClassConstructor classConstructor; \
        ClassType(superCls) * super; \
        const char* typeName; \
        unsigned short objSize; \
        unsigned short intfOffset;  \
        void (*construct)(clss *self, DWORD addData); \
        void (*destroy)(clss *self); \
        DWORD (*hash)(clss *self); \
        const char* (*toString)(clss *self, char* str, int max);  \
    int (*addRef)(clss*); \
    int (*release)(clss*);




struct _mObjectClass {
        mObjectClassHeader(mObject, mObject)
};

MGNCS_EXPORT extern mObjectClass g_stmObjectCls; //Class(mObject);

enum mObjectStatus
{
    NCSF_OBJECT_TODEL = 0x1000,
};
#define NCS_OBJ_TODEL(self) (self->objStatus & NCSF_OBJECT_TODEL)

#define mObjectHeader(clss) \
        ClassType(clss) * _class; \
    short objRefCount; \
    short objStatus;

struct _mObject {
        mObjectHeader(mObject)
};


MGNCS_EXPORT void ncsRefObjFreeSpecificData(DWORD key, DWORD value);

MGNCS_EXPORT mObject* initObject(mObject* pobj, mObjectClass* _class);

static inline mObject* _initObject(mObject* pobj, mObjectClass* _class,DWORD param) {
        memset(pobj, 0, _class->objSize);
        initObject(pobj, _class);
        ((PCONSTRUCT_DWORD)(_class->construct))(pobj, param);
        return pobj;
}

static inline mObject* initObjectArgs(mObject* pobj, mObjectClass* _class, ...)
{
        va_list va;
        va_start(va, _class);
        memset(pobj, 0, _class->objSize);
        initObject(pobj, _class);
        ((PCONSTRUCT_VALIST)(_class->construct))(pobj, va);
        va_end(va);
        return pobj;
}

#define INIT_OBJEX(Clss, pobj, param)  ((Clss* )_initObject((mObject*)(pobj), (mObjectClass*)&Class(Clss), (DWORD)(param)))
#define INIT_OBJ(Clss, pobj)  INIT_OBJEX(Clss, pobj, 0)
#define INIT_OBJV(Clss, pobj, ...) ((Clss* )initObjectArgs((mObject*)(pobj), (mObjectClass*)&Class(Clss), ##__VA_ARGS__))
#define UNIT_OBJ(pobj)  (_c(pobj)->destroy(pobj))

MGNCS_EXPORT mObject * newObject(mObjectClass *_class);
static inline mObject * ncsNewObject(mObjectClass *_class,DWORD addData){
        mObject * obj = newObject(_class);
        if(!obj)
                return NULL;

        _class->construct(obj, addData);
        return obj;
}

#define NEWEX(classType, addData)  (classType*)(void*)ncsNewObject((mObjectClass*)(void *)(&Class(classType)), (DWORD)(addData))
#define NEW(classType)  NEWEX(classType, 0)
static inline mObject * _newobject_args(mObjectClass* _class, ...)
{
        va_list va;
        mObject * obj;
        va_start(va, _class);
        obj = newObject(_class);
        if(obj)
                ((PCONSTRUCT_VALIST)(_class->construct))(obj, va);
        va_end(va);
        return obj;
}
#define NEWV(Clss, ...)  ((Clss*)_newobject_args((mObjectClass*)&(Class(Clss)), ##__VA_ARGS__))

MGNCS_EXPORT void deleteObject(mObject *obj);
#define DELETE(obj)   deleteObject((mObject*)(obj))

#define TYPENAME(obj)  ((obj)?(((obj)->_class)?((obj)->_class)->typeName:""):"")


MGNCS_EXPORT BOOL ncsInstanceOf(mObject* object, mObjectClass* clss);

#define INSTANCEOF(obj, clss)  ncsInstanceOf((mObject*)(obj), (mObjectClass*)(void*)(&Class(clss)))

static inline mObject*  ncsIsValidObj(mObject* obj){
        return (INSTANCEOF(obj, mObject)?(obj):NULL);
}

#define CHECKOBJ(obj)  ncsIsValidObj((mObject*)obj)

MGNCS_EXPORT mObject* ncsSafeCast(mObject* obj, mObjectClass *clss);

#define TYPE_CAST(Type, obj)  ((Type*)(obj))

#define SAFE_CAST(Type, obj)  TYPE_CAST(Type, ncsSafeCast((mObject*)obj,(mObjectClass*)(void*)(&(Class(Type)))))

MGNCS_EXPORT mObjectClass *ncsSafeCastClass(mObjectClass* clss, mObjectClass* castCls);
#define SAFE_CAST_CLASS(Clss, ClssCast) ((ClassType(ClssCast)*)(ncsSafeCastClass((mObjectClass*)Clss, (mObjectClass*)(void*)(&Class(ClssCast)))))

int ncsParseConstructParams(va_list args, const char* signature, ...);

typedef BOOL (*NCS_CB_ONOBJEVENT)(mObject* self, mObject *sender, int eventId, DWORD param);

#define NCS_CB_ONPIECEEVENT NCS_CB_ONOBJEVENT

MGNCS_EXPORT BOOL ncsAddEventListener(mObject *sender,
        mObject* listener,
        NCS_CB_ONOBJEVENT eventProc,
        int eventId);

MGNCS_EXPORT BOOL ncsAddEventListeners(mObject *sender,
        mObject* listener,
        NCS_CB_ONOBJEVENT eventProc,
        int* eventIds);

MGNCS_EXPORT BOOL ncsRemoveEventListener(mObject * listener);

MGNCS_EXPORT BOOL ncsRemoveEventConnect(mObject* listener, mObject* source, int eventId);

MGNCS_EXPORT BOOL ncsRemoveEventSource(mObject *sender);

MGNCS_EXPORT void ncsRaiseEvent(mObject *sender, int eventId, DWORD param);


#ifdef __cplusplus
}
#endif


#endif