mwidget.h

//
//                          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
//
/*
 * \file mwidget.h
 * \author ChaiPeng
 * \date 2009/01/01
 *
 * This file include the base widget control definition.
 *
 \verbatim

    This file is part of mGNCS, a component for MiniGUI.

    Copyright (C) 2008~2018, Beijing FMSoft Technologies Co., Ltd.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Or,

    As this program is a library, any link to this program must follow
    GNU General Public License version 3 (GPLv3). If you cannot accept
    GPLv3, you need to be licensed from FMSoft.

    If you have got a commercial license of this program, please use it
    under the terms and conditions of the commercial license.

    For more information about the commercial license, please refer to
    <http://www.minigui.com/blog/minigui-licensing-policy/>.

 \endverbatim
 */

#ifndef _MGUI_NCSCTRL_WIDGET_H
#define _MGUI_NCSCTRL_WIDGET_H
 
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */


#define TOWIDGET(x)    ((mWidget *)x)
#define TOWIDGETCLASS(x)    ((mWidgetClass *)x)

#define RendererType(className) className##Renderer


#define NCSCTRL_WIDGET  NCSCLASSNAME("widget")

typedef struct _mWidgetClass mWidgetClass;
typedef struct _mWidget mWidget;

typedef struct _NCS_WND_TEMPLATE NCS_WND_TEMPLATE;




typedef struct _mWidgetRenderer mWidgetRenderer;

#define mWidgetRendererHeader(clsName, parentClass)                         \
    const char* rdr_name;                                                   \
    /*renderer private method and data * every class must set NULL or it's ownd data */ \
    void (*class_init)(RendererType(clsName)* rdr);                         \
    RendererType(parentClass) *ptrParentClass;                              \
    BOOL (*init_self)(RendererType(clsName) *rdr);                          \
    void (*uninit_self)(RendererType(clsName) *rdr);                        \
    void * prv_data;                                                        \
    /*renderer drivedable method and data, * these data can be used directly by drived class */ \
    void (*drawFocusFrame)(clsName*, HDC, const RECT* );                    \
    BOOL (*drawBkground)(clsName*, HDC, const RECT*);                       \
    void (*draw3dbox)(clsName*, HDC, const RECT*, DWORD,DWORD);             \
    void (*drawCheckbox)(clsName*, HDC, const RECT*, DWORD);                \
    void (*drawRadio)(clsName*, HDC, const RECT*, DWORD);                   \
    void (*drawArrow)(clsName*, HDC, const RECT*, int arrow,DWORD, DWORD);  \
    void (*drawItem)(clsName*, HDC, const RECT*, DWORD); 

enum ncsRendererState{
        NCSRS_NORMAL = 0x00,
        NCSRS_HIGHLIGHT = 0x01,
        NCSRS_SIGNIFICANT = 0x02,
        NCSRS_SELECTED = 0x04,
        NCSRS_HALFSELECTED = 0x10, 
        NCSRS_DISABLE = 0x08
};
#define NCSR_STATUS(flag)  ((flag)&0xFFFF)

enum ncsRendererFlag{
        NCSRF_INNERFRAME = 0x010000,
        NCSRF_FILL       = 0x020000,
        NCSRF_FRAME      = 0x040000,
};
enum ncsRDRArrow {
        NCSR_ARROW_LEFT = 0,
        NCSR_ARROW_RIGHT,
        NCSR_ARROW_UP,
        NCSR_ARROW_DOWN
};
struct _mWidgetRenderer {
        mWidgetRendererHeader(mWidget, mWidget)
};


#define NCSSPEC_OBJ_CONTENT  MAX_USER_SPECIAL_KEY + 1

#define mWidgetHeader(clsName)                  \
        mComponentHeader(clsName)                   \
        HWND hwnd;                                  \
        RendererType(clsName) *renderer;            \
        mComponent* comps;                          \
        ImageDrawInfo  bkimg;                       \
        mObject *body;

struct _mWidget
{
        mWidgetHeader(mWidget)
};

#define mWidgetClassHeader(clsName, parentClass)                                    \
        mComponentClassHeader(clsName, parentClass)                                     \
        DWORD dlgCode;                                                                  \
        mObject * (*createBody)(clsName*);                                              \
        LRESULT (*wndProc)(clsName* , UINT, WPARAM, LPARAM);                                 \
        BOOL (*callUserHandler)(clsName* self, void *handler,                          \
                UINT message, WPARAM wParam, LPARAM lParam, LRESULT *pRet);                      \
        BOOL (*onCreate)(clsName*, LPARAM);                                             \
        BOOL (*addChildren)(clsName*, NCS_WND_TEMPLATE* children,int count);           \
        void (*onPaint)(clsName*, HDC, const PCLIPRGN pClip);                           \
        int (*onLButtonDown)(clsName*, int x, int y, DWORD keyFlags);                  \
        int (*onLButtonUp)(clsName*, int x, int y, DWORD keyFlags);                    \
        int (*onMouseMove)(clsName*, int x, int y, DWORD keyFlags);                    \
        int (*onKeyDown)(clsName*, int scancode, DWORD keyFlags);                      \
        int (*onKeyUp)(clsName*, int scancode, DWORD keyFlags);                        \
        int (*onSizeChanged)(clsName*, RECT* rtClient);                                 \
        BOOL (*onEraseBkgnd)(clsName*, HDC hdc, const RECT* invRect);                  \
                               \
        BOOL (*refresh)(clsName *);                                                    


struct _mWidgetClass
{
        mWidgetClassHeader(mWidget, mComponent)
};

#define SET_DLGCODE(code)  _class->dlgCode = (code);

MGNCS_EXPORT extern mWidgetClass g_stmWidgetCls;


/* property support */

enum mWidgetProp{
        NCSP_WIDGET_RDR = 1,
        NCSP_WIDGET_TEXT,
        NCSP_WIDGET_BKIMAGE,
        NCSP_WIDGET_BKIMAGE_MODE,
        NCSP_WIDGET_BKIMAGE_FILE,
        NCSP_WIDGET_MAX
};
#define NCSS_NOTIFY (0x1)

#define IsNotify(self) \
        (GetWindowStyle(self->hwnd)&NCSS_NOTIFY)

#define NCSS_WIDGET_SHIFT 1

/*
 * \def NCSS_EX_UNNEEDIME
 * \brief the edit uneed ime or not
 */
#define NCSS_EX_UNNEEDIME  0x1 

enum mWidgetNotify {
        NCSN_WIDGET_CLICKED = 1,
        NCSN_WIDGET_DBCLICKED,
        NCSN_WIDGET_ENABLED,
        NCSN_WIDGET_DISABLED,
        NCSN_WIDGET_MAX
};

#define NCSR_CONTINUE_MSG  FALSE

#define NCSR_STOP_MSG     TRUE

typedef void (*NCS_CB_ONNCCREATE)(mWidget*);

typedef BOOL (*NCS_CB_ONCREATE)(mWidget*, DWORD dwAddData);

typedef BOOL (*NCS_CB_ONINITDLG)(mWidget*, HWND hFocus, DWORD dwAddData);

typedef BOOL (*NCS_CB_ONVOID)(mWidget*, UINT message);
typedef void (*NCS_CB_ONSZCHGING)(mWidget*, const PRECT prcExpect, PRECT prcResult);

typedef BOOL (*NCS_CB_ONSZCHGED)(mWidget*,PRECT prcClient);
//MSG_CSIZECHANGED
typedef void (*NCS_CB_ONCSZCHGED)(mWidget*, int clientWidth, int clientHeight);

typedef BOOL (*NCS_CB_ONFONTCHGING)(mWidget*, PLOGFONT logFont);
typedef BOOL (*NCS_CB_ONERASEBKGND)(mWidget*, HDC hdc, const PRECT clip);
typedef void (*NCS_CB_ONPAINT)(mWidget*, HDC hdc, const PCLIPRGN clipRgn);
typedef BOOL (*NCS_CB_ONCLOSE)(mWidget*);

typedef BOOL (*NCS_CB_ONKEY)(mWidget*, UINT message, int code, DWORD keyStatus);

typedef BOOL(*NCS_CB_ONMOUSE)(mWidget*, UINT message, int x, int y, DWORD keyStatus);
typedef BOOL (*NCS_CB_ONNCMOUSE)(mWidget*, UINT message, int x, int y, int  hitCode);
typedef int (*NCS_CB_ONHITTEST)(mWidget*, UINT message,int x, int y);

typedef void (*NCS_CB_ONSCROLL)(mWidget*, UINT message, int code, int pos);
typedef BOOL (*NCS_CB_ONCMD)(mWidget*, int id, int nc, HWND hCtrl);
typedef void (*NCS_CB_WIDGET_ONTIMER)(mWidget*, int id, DWORD count);
typedef int (*NCS_CB_ONMSG)(mWidget*, UINT message, WPARAM wParam, LPARAM lParam);
typedef void (*NCS_CB_NOTIFY)(mWidget*, int id, int ncCode, DWORD addData);

#define NCS_NOTIFY_CODE(code)   (0xFFFF0000 | (code))

#define NCS_MAP_NOTIFY(code, handler) { NCS_NOTIFY_CODE(code), (void*)(handler) }


void mWidget_captureHotPiece(mWidget *self, mObject *hotpice);
mObject * mWidget_getCapturedHotPiece(mWidget *self);
void mWidget_releaseCapturedHotPiece(void);

void mWidget_setHoveringFocus(mWidget *self, mObject *hotpiece);
mObject * mWidget_getHoveringFocus(mWidget *self);
void mWidget_releaseHoveringFocus(void);

void mWidget_setInputFocus(mWidget *self, mObject *hotpiece);
mObject * mWidget_getInputFocus(mWidget *self);
void mWidget_releaseInputFocus(void);

#ifdef _MGNCS_GUIBUILDER_SUPPORT
//only for GUI Builder 
//used to create default content
#define NCSP_DEFAULT_CONTENT  10000
#endif


MGNCS_EXPORT BOOL ncsSetFont (HWND hWnd, const char *fontName);

MGNCS_EXPORT BOOL ncsSetProperty(HWND hWnd, int id, DWORD value);
MGNCS_EXPORT DWORD ncsGetProperty(HWND hWnd, int id);

typedef struct _NCS_PROP_ENTRY {
        int id;
        DWORD value;
}NCS_PROP_ENTRY;

typedef struct _NCS_RDR_ELEMENT {
        int id;
        DWORD value;
}NCS_RDR_ELEMENT;

typedef struct _NCS_RDR_INFO {
        const char* glb_rdr;
        const char* ctl_rdr;
        NCS_RDR_ELEMENT* elements;
}NCS_RDR_INFO;

typedef struct _NCS_CREATE_NOTIFY_INFO {
    BOOL (*onCreated)(struct _NCS_CREATE_NOTIFY_INFO*, mComponent*, DWORD special_id);
}NCS_CREATE_NOTIFY_INFO;

typedef struct _NCS_CREATE_INFO{
        NCS_PROP_ENTRY * props;
        NCS_RDR_INFO * rdr_info;
        NCS_EVENT_HANDLER *handlers;
        NCS_WND_TEMPLATE * ctrls;
        int ctrl_count;
        DWORD user_data;
        
        //FIXED ME Maybe I  should not put these two param here
        DWORD                           bk_color;
        const char*                     font_name;

    // don't use in the control, to make the NCS_MNWND_TEMPLATE and NCS_WND_TEMPLATE same
    HICON               hIcon;
    HMENU               hMenu;

    NCS_CREATE_NOTIFY_INFO * notify_info;
    DWORD                    special_id;

}NCS_CREATE_INFO;

MGNCS_EXPORT mWidget* ncsCreateWindow (const char *className, const char *caption, DWORD style, DWORD exStyle, \
        int id, int x, int y, int w, int h, HWND parent, \
        NCS_PROP_ENTRY * props, \
        NCS_RDR_INFO * rdrInfo, \
        NCS_EVENT_HANDLER * handlers, \
        DWORD addData);

typedef struct _NCS_MAIN_CREATE_INFO {
        const char* className;
        NCS_CREATE_INFO * create_info;
}NCS_MAIN_CREATE_INFO;

MGNCS_EXPORT mWidget* ncsCreateMainWindow (const char *className, const char *caption, 
        DWORD style, DWORD exStyle, \
        int id, int x, int y, int w, int h, HWND host, \
        HICON hIcon, HMENU hMenu,
        NCS_PROP_ENTRY * props, \
        NCS_RDR_INFO * rdrInfo, \
        NCS_EVENT_HANDLER * handlers, \
        DWORD addData);

struct _NCS_WND_TEMPLATE{
        const char*         class_name;
        intptr_t            id;
        int                 x, y, w, h;
        DWORD               style;
        DWORD               ex_style;
        const char*         caption;

        //same struct as NCS_CREATE_INFO
        NCS_PROP_ENTRY*     props;
        NCS_RDR_INFO*       rdr_info;
        NCS_EVENT_HANDLER*  handlers;
        NCS_WND_TEMPLATE*   ctrls;
        intptr_t            count;
        DWORD               user_data;

        //FIXED ME Maybe I  should not put these two param here
        DWORD                           bk_color;
        const char*             font_name;

    // don't use in the control, to make the NCS_MNWND_TEMPLATE and NCS_WND_TEMPLATE same
    HICON               hIcon;
    HMENU               hMenu;

    NCS_CREATE_NOTIFY_INFO * notify_info;
    DWORD                    special_id;
};

//create control window indirect
MGNCS_EXPORT mWidget* ncsCreateWindowIndirect( const NCS_WND_TEMPLATE* tmpl, HWND hParent);

typedef struct _NCS_MNWND_TEMPLATE{
        const char*         class_name;
        intptr_t            id;
        int                 x, y, w, h;
        DWORD               style;
        DWORD               ex_style;
        const char*         caption;

        NCS_PROP_ENTRY*     props;
        NCS_RDR_INFO*       rdr_info;
        NCS_EVENT_HANDLER*  handlers;
        NCS_WND_TEMPLATE*   ctrls;
        intptr_t            count;
        DWORD               user_data;

        //FIXED ME Maybe I  should not put these two param here
        DWORD                           bk_color;
        const char*                     font_name;

        HICON               hIcon;
        HMENU               hMenu;


    NCS_CREATE_NOTIFY_INFO * notify_info;
    DWORD                    special_id;

}NCS_MNWND_TEMPLATE;

MGNCS_EXPORT mWidget* ncsCreateMainWindowIndirect(const NCS_MNWND_TEMPLATE* tmpl, HWND hHost);

MGNCS_EXPORT mWidgetClass* ncsGetMainWndClass(const char* className);

MGNCS_EXPORT void ncsNotifyParentEx(mWidget * self, int code, DWORD addData);

#define ncsNotifyParent(self, code)  ncsNotifyParentEx((mWidget*)(self), code, 0)

static inline mWidget* ncsObjFromHandle(HWND hwnd)
{
        if(IsWindow(hwnd))
                return (mWidget*)(GetWindowAdditionalData2(hwnd));
        return NULL;
}

static inline mWidget* ncsGetChildObj(HWND hwnd, int id)
{
        mWidget * self = ncsObjFromHandle(hwnd);
        return (mWidget*)(self?_c(self)->getChild(self, id):NULL);
}

static inline mWidget* ncsGetParentObj(HWND hwnd)
{
        return ncsObjFromHandle(GetParent(hwnd));
}


static inline DWORD ncsGetDlgCode(HWND hwnd)
{

#if 0
        mWidget * widget;
        if((widget=ncsObjFromHandle(hwnd)))
        {
                return _c(widget)->dlgCode;
        }
        return 0;
#endif
        return (DWORD)SendMessage(hwnd, MSG_GETDLGCODE, 0, 0);
}

MGNCS_EXPORT void ncsDestroyWindow(mWidget* self, DWORD endCode);

#define ncsDeleteWidget(self) ncsDestroyWindow(self, 0)


#define NCS_FETCH_MSGBINDINFO(sender, param, lParam) do{ \
        void ** __tmp = (void**)(lParam);                    \
        if(__tmp){                                           \
                register DWORD* __param = (DWORD*)(void*)&(param);        \
                register void** __sender = (void**)(void*)&(sender);     \
                *__param  = (DWORD)__tmp[0];                       \
                *__sender = __tmp[1];                            \
                free(__tmp);                                     \
        }                                                    \
}while(0)

MGNCS_EXPORT BOOL ncsBindEventsToMessage(mObject *sender, HWND hwnd_listener, UINT message, int* event_ids);
MGNCS_EXPORT BOOL ncsBindEventToMessage(mObject* sender, HWND hwnd_listener, UINT message, int event_ids);
MGNCS_EXPORT void ncsRemoveBindWindow(HWND hwnd_listener);
MGNCS_EXPORT void ncsRemoveBindMessage(HWND hwnd_listener, UINT message, mObject* sender/*=NULL*/, int event_id/*=0*/);


#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* _MGUI_NCSCTRL_WIDGET_H */