medit.h

Go to the documentation of this file.

#ifndef _MGUI_NCSCTRL_EDIT_H
#define _MGUI_NCSCTRL_EDIT_H
 
#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

/* structure to represent a text string */
typedef struct strbuffer_s
{
    unsigned char *string;     /* text string content */
    unsigned int  txtlen;      /* text len or buffer used size */
    unsigned int  blocksize;   /* block size, a block is an allocate unit */
    unsigned int  buffsize;    /* buffer size */
} StrBuffer;

/* ------------------------- memory and struct alloc ------------------------ */

#define te_alloc                         malloc
#define te_free                          free
#define te_realloc(ptr, size, cpysize)   realloc(ptr, size)

/* alloc with a unit of blocksize */
static inline void* testr_alloc (StrBuffer *txtbuff, size_t len, size_t blocksize)
{
    txtbuff->buffsize = (len + 1) + (blocksize - (len + 1)%blocksize);
    txtbuff->string = (unsigned char *)te_alloc (txtbuff->buffsize);
    txtbuff->blocksize = blocksize;
    //txtbuff->txtlen = len;
    return txtbuff->string;
}

static inline void* testr_realloc (StrBuffer *txtbuff, size_t len)
{
    if (len + 1 > txtbuff->buffsize || 
             len + 1 < txtbuff->buffsize - txtbuff->blocksize) {
        /* really realloc */
        size_t old_size;
        old_size  = txtbuff->buffsize;
        txtbuff->buffsize = (len + 1) + (txtbuff->blocksize - 
                            (len + 1)%txtbuff->blocksize);
        txtbuff->string = (unsigned char *)te_realloc (txtbuff->string, txtbuff->buffsize, old_size);
    }

    return txtbuff->string;
}

static inline void testr_free (StrBuffer *txtbuff)
{
    if (txtbuff) {
        te_free (txtbuff->string);
    }
}

static inline void testr_setstr (StrBuffer *txtbuff, const char *newstring, unsigned int len)
{
    int datalen;

    if (len < 0 && !newstring) return;

    datalen = MIN(len, txtbuff->buffsize-1);
    memcpy (txtbuff->string, newstring, datalen);
    txtbuff->string[datalen] = '\0';
    txtbuff->txtlen = datalen;
}

/* copy a string buffer */
static inline StrBuffer* testr_copy (StrBuffer *des, StrBuffer *src)
{
    if (!des || !src)
        return NULL;

    testr_free (des);
    testr_alloc (des, src->txtlen, des->blocksize);
    testr_setstr (des, (const char *)src->string, src->txtlen);
    return des;
}

/* duplicates a string buffer */
static inline StrBuffer* testr_dup (StrBuffer *s1)
{
    StrBuffer *s2;

    if (!s1)
        return NULL;

    s2 = (StrBuffer *)malloc (sizeof(s1));
    if (s2) {
        testr_alloc (s2, s1->txtlen, s1->blocksize);
        testr_setstr (s2, (const char *)s1->string, s1->txtlen);
    }
    return s2;
}

/* duplicates a string buffer */
static inline StrBuffer* testr_dup2 (StrBuffer *s2, StrBuffer *s1)
{
    if (!s1 || !s2)
        return NULL;

    testr_alloc (s2, s1->txtlen, s1->blocksize);
    testr_setstr (s2, (const char *)s1->string, s1->txtlen);
    return s2;
}

/* -------------------------------------------------------------------------- */


/*
 * \def NCSCTRL_EDIT
 * \brief the name of edit control
*/
#define NCSCTRL_EDIT   NCSCLASSNAME("edit")

#ifdef _MGNCS_USE_DBEDIT
#define DOUBLE_DC HDC   db_dc;
#else
#define DOUBLE_DC 
#endif

typedef struct _mEdit mEdit;
typedef struct _mEditClass mEditClass;
typedef struct _mEditRenderer    mEditRenderer;

#define mEditHeader(Class)   \
    mScrollViewHeader(Class) \
        DOUBLE_DC

struct _mEdit
{
    mEditHeader(mEdit)
};


typedef struct _TextAttribute
{
    struct _TextAttribute* (*clone)(void);
    void (*destroy)(void);
}TextAttribute;

typedef struct _PasteInfo {
    char          *str;
    int            len;
    TextAttribute *attr;
    void          *user_info;
    struct _PasteInfo *next;
}PasteInfo;

typedef struct _TextCopyPaste
{
    void (*addCopyInfo)(const char* str, int len, TextAttribute *atrr, void *user_info);
    void (*endCopyInfo)(void);
    BOOL (*isEmpty)(void);
    PasteInfo* (*getPasteInfo)(void);
}TextCopyPaste;

typedef struct _UndoRedoInfo
{
    char           *text;
    int             start;
    int             end;
    TextAttribute  *attr;
    void           *user_data;
    struct _UndoRedoInfo * next;
} UndoRedoInfo;

typedef struct _TextUndoRedoInfo
{
    BOOL (*pushText)(const char* text, int start, int end, TextAttribute *attr, void *user_data);
    BOOL (*endPush)(void);

    UndoRedoInfo* (*getUndoTop)(void);
    UndoRedoInfo* (*getRedoTop)(void);

    void (*popUndo)(void);
    void (*popRedo)(void);

    BOOL (*isUndoEmpty)(void);
    BOOL (*isRedoEmpty)(void);

    void (*empty)(void);
}TextUndoRedoInfo;

#define mEditClassHeader(clsName, parentClass) \
    mScrollViewClassHeader(clsName, parentClass)    \
    int (*onChar)(clsName* self, int asciiCode, DWORD keyFlags);           \
    int (*setContent)(clsName *self, const char* str, int start, int len);   \
    void (*replaceText)(clsName *self, const char* str, int start, int len, int replaceStart, int replaceEnd);    \
    void (*insert)(clsName *self, const char* str, int start, int len, int insertStart);    \
    void (*append)(clsName *self, const char* str, int start, int len);            \
    int (*getTextLength)(clsName *self);                                           \
    int (*getContent)(clsName *self, char *strBuff, int bufLen, int start, int end); \
    int (*setTextAttr)(clsName *self, int start, int end, TextAttribute *attr);    \
    TextAttribute* (*getTextAttr)(clsName *self, int start, int end, int *pEnd);   \
    int (*setSel)(clsName *self, int start, int end);                              \
    int (*getSel)(clsName *self, int *pStart, int *pEnd);                          \
    void (*setMargin)(clsName *self, int left, int top, int right, int bottom);    \
    void (*copy)(clsName *self);                                                   \
    void (*cut)(clsName *self);                                                    \
    void (*paste)(clsName *self);                                                  \
    TextCopyPaste * (*setCopyPaste)(clsName *self, TextCopyPaste* cp);             \
    void (*undo)(clsName *self);                                                   \
    void (*redo)(clsName *self);                                                   \
    TextUndoRedoInfo * (*setUndoRedo)(clsName *self, TextUndoRedoInfo* ur);        \
    BOOL (*makevisible)(clsName *self, int pos);

struct _mEditClass
{
    mEditClassHeader(mEdit, mScrollView)
};

MGNCS_EXPORT extern mEditClass g_stmEditCls;


#define mEditRendererHeader(clsName, parentClass) \
        mScrollViewRendererHeader(clsName, parentClass)

struct _mEditRenderer
{
        mEditRendererHeader(mEdit, mScrollView)
};

#define NCSS_EDIT_LEFT        (0x0000L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_CENTER      (0x0001L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_RIGHT       (0x0002L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_UPPERCASE   (0x0004L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_LOWERCASE   (0x0008L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_NOHIDESEL   (0x0010L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_READONLY    (0x0020L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_BASELINE    (0x0040L<<NCSS_SCRLV_SHIFT)

#define NCSS_EDIT_SHIFT  (NCSS_SCRLV_SHIFT+8)



enum mEditProp 
{
    NCSP_EDIT_LIMITTEXT = NCSP_SCRLV_MAX + 1, 
    NCSP_EDIT_CARETPOS ,
    NCSP_EDIT_MAX
};


enum mEditNotify
{
    NCSN_EDIT_SETFOCUS = NCSN_ITEMV_SETFOCUS,                   
    NCSN_EDIT_KILLFOCUS = NCSN_ITEMV_KILLFOCUS,                  
    NCSN_EDIT_CHANGE = NCSN_SCRLV_MAX + 1, 
    NCSN_EDIT_CONTCHANGED,               
    NCSN_EDIT_UPDATE,                     
    NCSN_EDIT_SELCHANGED,                 
    NCSN_EDIT_MAXTEXT,                    
    NCSN_EDIT_MAX
};

#ifdef _MGNCS_USE_DBEDIT
static inline HDC mEdit_getDC(mEdit *self)
{
    if (self->db_dc) {
        SelectClipRect(self->db_dc, NULL);
                SelectFont(self->db_dc, GetWindowFont(self->hwnd));
        return self->db_dc;
    }
    else 
        return GetClientDC(self->hwnd);
}

static inline void mEdit_releaseDC(mEdit *self, HDC hdc) 
{
    if (self->db_dc == 0 || self->db_dc != hdc)
        ReleaseDC(hdc);
}
#else
static inline HDC mEdit_getDC(mEdit *self)
{
    return GetClientDC(self->hwnd);
}

static inline void mEdit_releaseDC(mEdit *self, HDC hdc) 
{
    ReleaseDC(hdc);
}
#endif
#define GETDC(self)             mEdit_getDC((mEdit*)self)
#define RELEASEDC(self, hdc)    mEdit_releaseDC((mEdit*)self, hdc)

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* _MGUI_NCSCTRL_EDIT_H */