mcomponent.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_CMPT_H
#define _MGUI_NCSCTRL_CMPT_H

#ifdef __cplusplus
extern "C"{
#endif

#include <stdarg.h>

#define MAXLEN_CLASSNAME    31

#define NCSCLASSNAME(name)     name _MGNCS_CLASS_SUFFIX

#define BEGIN_CMPT_CLASS(clss, superCls) \
        static const char comp_##clss##_class_name[] = (#clss _MGNCS_CLASS_SUFFIX) ; \
        BEGIN_MINI_CLASS(clss, superCls) \
        _class->className = comp_##clss##_class_name + 1; 

#define END_CMPT_CLASS END_MINI_CLASS

#ifndef BIND_PROP
#define BIND_PROP
typedef struct _mBindProp mBindProp;
#endif

typedef void (*PFreeSpecificData)(DWORD key, DWORD value);

#define MAX_USER_SPECIAL_KEY   0x80000000L

typedef struct _mComponentClass mComponentClass;
typedef struct _mComponent mComponent;

#define mComponentClassHeader(clss, superCls) \
        mObjectClassHeader(clss, superCls) \
        const char* className; \
        clss * (*createComponent)(mComponent* parent, ClassType(clss)*, DWORD addValue); \
        WNDPROC _window_proc ; \
        BOOL (*setProperty)(clss *self, int id, DWORD value); \
        DWORD (*getProperty)(clss *self, int id); \
        int (*setId)(clss *self, int id); \
        int (*getId)(clss *self); \
        mComponent* (*getReleated)(clss*self, int releated); \
        mComponent* (*setReleated)(clss *self, mComponent* comp,  int releated); \
        mComponent* (*getChild)(clss* self, int id);  \
        void        (*removeChild)(clss* self, mComponent* child);  \
        PUBLIC DWORD (*getPropertyByPath)(clss* self, int *id_path); \
        PUBLIC BOOL  (*setPropertyByPath)(clss* self, int *id_path, DWORD value); \
        PUBLIC BOOL  (*addEventListenerByPath)(clss* self, int *id_path, mObject* listener, NCS_CB_ONOBJEVENT on_event); \
        PUBLIC BOOL  (*addBindPropByPath)(clss* self, int *id_path, int event_id, int prop_type, int flags, mBindProp *prop, int bind_type); \
        PUBLIC BOOL  (*queryByPath)(clss* self, int *id_path, DWORD *pret, ...); \
        PUBLIC BOOL  (*vqueryByPath)(clss* self, int *id_path, DWORD* pret, va_list va); \
        PUBLIC BOOL  (*isMainObj)(clss* self);  \
        BOOL  (*setSpecificData)(clss* self, DWORD key, DWORD value, PFreeSpecificData freeSpecific); \
        DWORD (*getSpecificData)(clss* self, DWORD key, BOOL *pOk);

enum ncsComponentReleated{
        NCS_CMPT_NEXT = 0,
        NCS_CMPT_PREV,
        NCS_CMPT_PARENT,
        NCS_CMPT_CHILDREN
};
enum mComponentQueryCmd{
        QPC_SET_PROP = 0,
        QPC_GET_PROP,
        QPC_ADD_EVENT,
        QPC_ADD_BIND,
        QPC_USER
};

struct _mComponentClass {
        mComponentClassHeader(mComponent, mObject)
};

MGNCS_EXPORT mComponent *ncsCompGetMainParent(mComponent*self);

MGNCS_EXPORT mComponent *ncsCompGetRoot(mComponent* self);

#define IDPATH_END -1

#define IDPATH_ME     -2
#define IDPATH_PARENT -3
#define IDPATH_MAINPARENT -4
#define IDPATH_ROOT -5

#define ISVALID_IDPATH(id_path) \
        ((id_path) && (id_path)[0] != IDPATH_END)

#define IDPATH_ISOBJ(id_path) \
        ((id_path)[1] != IDPATH_END)

#define BYPATHFUNCEX(baseclass, base_check, err_ret, func, finaly_func_ex, ...) do{ \
        mComponent* cmp; \
        if(!ISVALID_IDPATH(id_path)) \
                return 0;  \
        while(IDPATH_ISOBJ(id_path)) { \
                if(id_path[0] == IDPATH_ME){ \
                        id_path ++; \
                        continue; \
                } else if(id_path[0] == IDPATH_PARENT) \
                        cmp = _c(self)->getReleated(self, NCS_CMPT_PARENT); \
                else if(id_path[0] == IDPATH_MAINPARENT) \
                        cmp = ncsCompGetMainParent((mComponent*)self); \
                else if(id_path[0] == IDPATH_ROOT) \
                        cmp = ncsCompGetRoot((mComponent*)self); \
                else  \
                        cmp = _c(self)->getChild(self, id_path[0]); \
                if(!cmp && base_check(cmp,baseclass)) return err_ret; \
                return _c(baseclass*)->func((baseclass*)cmp, ++id_path, ##__VA_ARGS__); \
        } \
        finaly_func_ex(self, id_path[0], ##__VA_ARGS__); \
}while(0)

#define BYPATHFUNC(baseclass, base_check,err_ret, func, final_func, ...) \
        BYPATHFUNCEX(baseclass, base_check,err_ret, func, return (_c(self)->final_func), ##__VA_ARGS__)

#define IDPATH_NOBASECHECK(cmp, baseclass)   1

MGNCS_EXPORT extern mComponentClass g_stmComponentCls; //Class(mComponent);

typedef struct _NCS_EVENT_HANDLER_NODE {
        UINT message;
        void *handler;
        struct _NCS_EVENT_HANDLER_NODE *next;
}NCS_EVENT_HANDLER_NODE;

typedef struct _mSpecificDataNode {
        DWORD key;
        DWORD value;
        PFreeSpecificData freeSpecific;
        struct _mSpecificDataNode* next;
}mSpecificDataNode;

#define mComponentHeader(clss) \
        mObjectHeader(clss) \
        NCS_EVENT_HANDLER_NODE * event_handlers; \
        mSpecificDataNode* specificHead;

struct _mComponent {
        mComponentHeader(mComponent)
};


typedef struct _NCS_EVENT_HANDLER {
        UINT message;
        void *handler;
}NCS_EVENT_HANDLER;

MGNCS_EXPORT void * ncsSetComponentHandler(mComponent* comp, UINT message, void *handler);

MGNCS_EXPORT void ncsSetComponentHandlers(mComponent* comp, NCS_EVENT_HANDLER* handlers, int count);

MGNCS_EXPORT void* ncsGetComponentHandler(mComponent* comp, UINT message);

typedef struct _NCS_EVENT_CONNECT_INFO {
        int id_sender;
        int id_listener;
        int event_id;
        NCS_CB_ONOBJEVENT event;
}NCS_EVENT_CONNECT_INFO;

MGNCS_EXPORT BOOL ncsComponentConnectEvents(mComponent* comps, NCS_EVENT_CONNECT_INFO *connects, int counts/*=-1*/);

MGNCS_EXPORT BOOL ncsIsClass(const char* className, mComponentClass* clss);

#define ISCLASS(class_name, clssName) ncsIsClass((const char*)(class_name), (mComponentClass*)(&Class(clssName)))

MGNCS_EXPORT BOOL ncsIsChildClass(const char* childClassName, const char* parentClassName);

MGNCS_EXPORT BOOL ncsRegisterComponent(mComponentClass *compCls, DWORD dwStyle, DWORD dwExStyle, int idCursor, int idBkColor);

MGNCS_EXPORT mComponentClass * ncsGetComponentClass(const char* className, BOOL check);

MGNCS_EXPORT mComponentClass * ncsClassFromMagicNum(DWORD magic_num, BOOL check, const char* class_name);

#define MGNCS_REGISTER_COMPONENT_EX(className, dwStyle, dwExStyle, idCursor, idBkColor) \
        do {if(!ncsRegisterComponent((mComponentClass*)MGNCS_INIT_CLASS(className), \
                dwStyle, dwExStyle, idCursor, idBkColor)) \
                return FALSE;}while(0)

/* NOTE: use WE_BGC_WINDOW as the default background color instead of WE_MAINC_THREED_BODY */
#define MGNCS_REGISTER_COMPONENT(className) \
        MGNCS_REGISTER_COMPONENT_EX(className, \
                WS_NONE, WS_EX_NONE, IDC_ARROW, WE_BGC_WINDOW)

#define MGNCS_UNREG_COMPONENT(clssName) \
        UnregisterWindowClass(Class(clssName).className)        

#define NCS_SET_PROP(self, id, value) \
        _c(self)->setProperty(self, (id), (value))
#define NCS_GET_PROP(self, id)        \
        _c(self)->getProperty(self, (id))

#ifdef __cplusplus
}
#endif

#endif