minigui.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
//

/*
 * $Id: minigui.h 13674 2010-12-06 06:45:01Z wanzheng $
 *
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks,
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 */

#ifndef _MGUI_MINIGUI_H
  #define _MGUI_MINIGUI_H

#include <stdio.h>
#include <sys/types.h>

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

#define ZOF_STATUS_MASK         0x0000000F
#define ZOF_VISIBLE             0x00000001
#define ZOF_DISABLED            0x00000002
#define ZOF_MAXIMIZED           0x00000004  // Since 5.0.0
#define ZOF_MINIMIZED           0x00000008  // Since 5.0.0

/* Since 5.0.0 */
#define ZOF_INTERNAL_FLAGS_MASK 0X000F0000
#define ZOF_IF_REFERENCE        0x00010000
#define ZOF_IF_ALWAYSTOP        0x00020000

#define ZOF_TW_FLAG_MASK        0x00F00000
#define ZOF_TW_TROUNDCNS        0x00100000
#define ZOF_TW_BROUNDCNS        0x00200000
#define ZOF_TW_TBROUNDCNS       0x00300000

#define ZOF_TYPE_FLAG_MASK      0xFF000000

#define ZOF_TYPE_MASK           0xF0000000
#define ZOF_TYPE_NULL           0x00000000
#define ZOF_TYPE_DESKTOP        0x10000000  // fixed and only one.
#define ZOF_TYPE_LAUNCHER       0x20000000  // Since 5.0.0
#define ZOF_TYPE_NORMAL         0x30000000
#define ZOF_TYPE_HIGHER         0x40000000
#define ZOF_TYPE_DOCKER         0x50000000  // Since 5.0.0
#define ZOF_TYPE_SCREENLOCK     0x60000000  // Since 5.0.0;
#define ZOF_TYPE_GLOBAL         0x70000000
#define ZOF_TYPE_TOOLTIP        0x80000000  // Since 5.0.0; fixed and only one.
#define ZOF_TYPE_POPUPMENU      0x90000000

#define ZOF_TYPE_BOTTOMMOST     ZOF_TYPE_LAUNCHER
#define ZOF_TYPE_TOPMOST        ZOF_TYPE_TOOLTIP

#define ZOF_TF_FLAG_MASK        0x0F000000
#define ZOF_TF_MAINWIN          0x01000000
#define ZOF_TF_TOOLWIN          0x02000000
#define ZOF_TF_CONTROL          0x04000000

#define ZNIT_NULL               (ZOF_TYPE_NULL)
#define ZNIT_POPUPMENU          (ZOF_TYPE_POPUPMENU)
#define ZNIT_TOOLTIP            (ZOF_TYPE_TOOLTIP | ZOF_TF_MAINWIN)

#define ZNIT_GLOBAL_MAINWIN     (ZOF_TYPE_GLOBAL | ZOF_TF_MAINWIN)
#define ZNIT_GLOBAL_TOOLWIN     (ZOF_TYPE_GLOBAL | ZOF_TF_TOOLWIN)
#define ZNIT_GLOBAL_CONTROL     (ZOF_TYPE_GLOBAL | ZOF_TF_CONTROL)

#define ZNIT_SCREENLOCK_MAINWIN (ZOF_TYPE_SCREENLOCK | ZOF_TF_MAINWIN)
#define ZNIT_SCREENLOCK_TOOLWIN (ZOF_TYPE_SCREENLOCK | ZOF_TF_TOOLWIN)
#define ZNIT_SCREENLOCK_CONTROL (ZOF_TYPE_SCREENLOCK | ZOF_TF_CONTROL)

#define ZNIT_DOCKER_MAINWIN     (ZOF_TYPE_DOCKER | ZOF_TF_MAINWIN)
#define ZNIT_DOCKER_TOOLWIN     (ZOF_TYPE_DOCKER | ZOF_TF_TOOLWIN)
#define ZNIT_DOCKER_CONTROL     (ZOF_TYPE_DOCKER | ZOF_TF_CONTROL)

#define ZNIT_HIGHER_MAINWIN     (ZOF_TYPE_HIGHER | ZOF_TF_MAINWIN)
#define ZNIT_HIGHER_TOOLWIN     (ZOF_TYPE_HIGHER | ZOF_TF_TOOLWIN)
#define ZNIT_HIGHER_CONTROL     (ZOF_TYPE_HIGHER | ZOF_TF_CONTROL)

#define ZNIT_NORMAL_MAINWIN     (ZOF_TYPE_NORMAL | ZOF_TF_MAINWIN)
#define ZNIT_NORMAL_TOOLWIN     (ZOF_TYPE_NORMAL | ZOF_TF_TOOLWIN)
#define ZNIT_NORMAL_CONTROL     (ZOF_TYPE_NORMAL | ZOF_TF_CONTROL)

#define ZNIT_LAUNCHER_MAINWIN   (ZOF_TYPE_LAUNCHER | ZOF_TF_MAINWIN)
#define ZNIT_LAUNCHER_TOOLWIN   (ZOF_TYPE_LAUNCHER | ZOF_TF_TOOLWIN)
#define ZNIT_LAUNCHER_CONTROL   (ZOF_TYPE_LAUNCHER | ZOF_TF_CONTROL)

#define ZNIT_DESKTOP            (ZOF_TYPE_DESKTOP)

#define ZNIF_VISIBLE            (ZOF_VISIBLE)
#define ZNIF_DISABLED           (ZOF_DISABLED)
#define ZNIF_MAXIMIZED          (ZOF_MAXIMIZED) /* Since 5.2.0 */
#define ZNIF_MINIMIZED          (ZOF_MINIMIZED) /* Since 5.2.0 */

/* definitions for backward compatibility */
#define ZNIT_TOPMOST_MAINWIN    (ZNIT_HIGHER_MAINWIN)
#define ZNIT_TOPMOST_TOOLWIN    (ZNIT_HIGHER_TOOLWIN)
#define ZNIT_TOPMOST_CONTROL    (ZNIT_HIGHER_CONTROL)

typedef struct _CalcPosInfo {
    DWORD style;
    DWORD ex_style;
    RECT  rc;
} CALCPOSINFO;

MG_EXPORT RECT GUIAPI GetScreenRect (void);

#define g_rcScr (GetScreenRect())

#define g_rcDesktop     g_rcScr

#ifdef _MGRM_PROCESSES

MG_EXPORT BOOL GUIAPI IsServer(void);

#define mgIsServer (IsServer())

extern MG_EXPORT void* mgSharedRes;

extern MG_EXPORT size_t mgSizeRes;

#define LEN_LAYER_NAME      15

#define LEN_CLIENT_NAME     15

#define INV_LAYER_HANDLE    0

struct _MG_Layer;

typedef struct _MG_Client
{
    char    name [LEN_CLIENT_NAME + 1];

    pid_t   pid;
    uid_t   uid;
    int     fd;

    BOOL    has_dirty;
    DWORD   last_live_time;
    DWORD   dwAddData;

    struct  _MG_Client* next;
    struct  _MG_Client* prev;

    struct  _MG_Layer* layer;

    struct GlobalRes* global_res;
} MG_Client;

typedef struct _MG_Layer
{
    char    name [LEN_LAYER_NAME + 1];

    DWORD   dwAddData;

    MG_Client* cli_head;
    MG_Client* cli_active;

    struct _MG_Layer* next;
    struct _MG_Layer* prev;

    void* zorder_info;
    int   zorder_shmid;
} MG_Layer;

extern MG_EXPORT int mgClientSize;

extern MG_EXPORT MG_Client* mgClients;

extern MG_EXPORT MG_Layer* mgTopmostLayer;

extern MG_EXPORT MG_Layer* mgLayers;

#endif /* _MGRM_PROCESSES */

MG_EXPORT int GUIAPI InitGUI (int argc, const char *argv[]);

MG_EXPORT void GUIAPI TerminateGUI (int not_used);

MG_EXPORT void GUIAPI MiniGUIPanic (int exitcode);

#define NAME_SELF_LAYER         ""

#define NAME_TOPMOST_LAYER      ""

#define NAME_DEF_LAYER          "mginit"

#ifdef _MGRM_PROCESSES

MG_EXPORT GHANDLE GUIAPI JoinLayer (const char* layer_name,
                const char* client_name,
                int max_nr_highers, int max_nr_normals);

MG_EXPORT GHANDLE GUIAPI GetLayerInfo (const char* layer_name,
                int* nr_clients, BOOL* is_topmost, int* cli_active);

MG_EXPORT BOOL GUIAPI SetTopmostLayer (BOOL handle_name,
                GHANDLE layer_handle, const char* layer_name);

MG_EXPORT BOOL GUIAPI DeleteLayer (BOOL handle_name,
                        GHANDLE layer_handle, const char* layer_name);

MG_EXPORT BOOL GUIAPI MoveToLayer (BOOL handle_name,
                        GHANDLE layer_handle, const char* layer_name);

typedef int (* ON_LOCK_CLIENT_REQ) (void);

typedef int (* ON_TRYLOCK_CLIENT_REQ) (void);

typedef void (* ON_UNLOCK_CLIENT_REQ) (void);

extern MG_EXPORT ON_LOCK_CLIENT_REQ  OnLockClientReq;

extern MG_EXPORT ON_TRYLOCK_CLIENT_REQ  OnTrylockClientReq;
extern MG_EXPORT ON_UNLOCK_CLIENT_REQ  OnUnlockClientReq;

#define LCO_NEW_CLIENT      1
#define LCO_DEL_CLIENT      2

typedef void (* ON_NEW_DEL_CLIENT) (int op, int cli);

#define LCO_NEW_LAYER       1
#define LCO_DEL_LAYER       2
#define LCO_JOIN_CLIENT     3
#define LCO_REMOVE_CLIENT   4
#define LCO_TOPMOST_CHANGED 5
#define LCO_ACTIVE_CHANGED  6

typedef void (* ON_CHANGE_LAYER) (int op, MG_Layer* layer,
                MG_Client* client);

#define ZNOP_ALLOCATE   1
#define ZNOP_FREE       2
#define ZNOP_MOVE2TOP   3
#define ZNOP_SHOW       4
#define ZNOP_HIDE       5
#define ZNOP_MOVEWIN    6
#define ZNOP_SETACTIVE  7

#define ZNOP_ENABLEWINDOW        11
#define ZNOP_DISABLEWINDOW       12
#define ZNOP_STARTDRAG           13
#define ZNOP_CANCELDRAG          14
#define ZNOP_CHANGECAPTION       15
#define ZNOP_REGIONCHANGED       16
#define ZNOP_COMPOSITINGCHANGED  17

typedef void (* ON_ZNODE_OPERATION) (int op, int cli, int idx_znode);

extern MG_EXPORT ON_NEW_DEL_CLIENT OnNewDelClient;

extern MG_EXPORT ON_CHANGE_LAYER OnChangeLayer;

extern MG_EXPORT ON_ZNODE_OPERATION OnZNodeOperation;

MG_EXPORT BOOL GUIAPI ServerStartup (int nr_globals,
                int def_nr_highers, int def_nr_normals);

MG_EXPORT MG_Layer* GUIAPI ServerCreateLayer (const char* layer_name,
                int max_nr_highers, int max_nr_normals);

MG_EXPORT BOOL GUIAPI ServerSetTopmostLayer (MG_Layer* layer);

MG_EXPORT BOOL GUIAPI ServerDeleteLayer (MG_Layer* layer);

MG_EXPORT int GUIAPI ServerGetNextZNode (MG_Layer* layer, int idx_znode,
                int* cli);

MG_EXPORT int GUIAPI ServerGetPrevZNode (MG_Layer* layer, int idx_znode,
                int* cli);

typedef struct _ZNODEINFO {
    DWORD           type;

    DWORD           flags;

    const char*     caption;

    RECT            rc;

    HWND            hwnd;
    HWND            main_win;

    int             cli;

#ifdef _MGSCHEMA_COMPOSITING

    int             ct;
    DWORD           ct_arg;
#endif

    void*           priv_data;
} ZNODEINFO;

MG_EXPORT BOOL GUIAPI ServerGetZNodeInfo (MG_Layer* layer, int idx_znode,
                ZNODEINFO* znode_info);

typedef struct _ZNODEHEADER {
    DWORD           flags;

    const char*     caption;

    HWND            hwnd;

    HWND            main_win;

    RECT            rc;

    int             cli;

    int             lock_count;

#ifdef _MGSCHEMA_COMPOSITING

    unsigned int    changes;
    int             ct;
    DWORD           ct_arg;

    HDC             mem_dc;

    unsigned int    dirty_age;

    int             nr_dirty_rcs;

    const RECT*     dirty_rcs;
#else

    unsigned int    age;
    RECT            dirty_rc;
#endif
} ZNODEHEADER;

MG_EXPORT const ZNODEHEADER* GUIAPI ServerGetWinZNodeHeader (
                MG_Layer* layer, int idx_znode, void** priv_data, BOOL lock);

#ifdef _MGSCHEMA_COMPOSITING
MG_EXPORT BOOL GUIAPI ServerReleaseWinZNodeHeader (MG_Layer* layer,
        int idx_znode);
#else   /* not defined _MGSCHEMA_COMPOSITING */
static inline BOOL GUIAPI ServerReleaseWinZNodeHeader (MG_Layer* layer,
        int idx_znode)
{
    return TRUE;
}
#endif  /* not defined _MGSCHEMA_COMPOSITING */

MG_EXPORT int GUIAPI ServerGetPopupMenusCount (void);

MG_EXPORT const ZNODEHEADER* GUIAPI ServerGetPopupMenuZNodeHeader (
                int idx_znode, void** priv_data, BOOL lock);

#ifdef _MGSCHEMA_COMPOSITING
MG_EXPORT BOOL GUIAPI ServerReleasePopupMenuZNodeHeader (int idx_znode);
#else   /* not defined _MGSCHEMA_COMPOSITING */
static inline BOOL GUIAPI ServerReleasePopupMenuZNodeHeader (int idx_znode)
{
    return TRUE;
}
#endif  /* not defined _MGSCHEMA_COMPOSITING */

typedef struct _CLIPRGN CLIPRGN;

#define RGN_OP_MASK         0x000F
#define RGN_OP_SET          0x0000
#define RGN_OP_INCLUDE      0x0001
#define RGN_OP_EXCLUDE      0x0002
#define RGN_OP_FLAG_ABS     0x0010

MG_EXPORT BOOL GUIAPI ServerGetWinZNodeRegion (MG_Layer* layer, int idx_znode,
                DWORD rgn_ops, CLIPRGN* dst_rgn);

MG_EXPORT BOOL GUIAPI ServerGetPopupMenuZNodeRegion (int idx_znode,
        DWORD rgn_ops, CLIPRGN* dst_rgn);

MG_EXPORT BOOL GUIAPI ServerSetWinZNodePrivateData (MG_Layer* layer,
        int idx_znode, void* priv_data);

MG_EXPORT BOOL GUIAPI ServerSetPopupMenuZNodePrivateData (int idx_znode,
        void* priv_data);

MG_EXPORT BOOL GUIAPI ServerDoZNodeOperation (MG_Layer* layer, int idx_znode,
                int op_code, void* op_data, BOOL notify);

MG_EXPORT BOOL GUIAPI ServerMoveClientToLayer (int cli, MG_Layer* dst_layer);

MG_EXPORT int GUIAPI GetClientByPID (int pid);

MG_EXPORT BOOL GUIAPI SetTopmostClient (int cli);

MG_EXPORT void GUIAPI DisableClientsOutput (void);

MG_EXPORT void GUIAPI UpdateTopmostLayer (const RECT* dirty_rc);

#ifdef _MGSCHEMA_COMPOSITING

struct _CompositorCtxt;
typedef struct _CompositorCtxt CompositorCtxt;

struct _CLIPRGN;
typedef struct _CLIPRGN CLIPRGN;

typedef struct _CompositorOps {
    CompositorCtxt* (*initialize) (const char* name);

    void (*terminate) (CompositorCtxt* ctxt);

    void (*refresh) (CompositorCtxt* ctxt);

    void (*purge_ppp_data) (CompositorCtxt* ctxt, int zidx, void* data);

    void (*purge_win_data) (CompositorCtxt* ctxt, MG_Layer* layer,
            int zidx, void* data);

    void (*calc_mainwin_pos) (CompositorCtxt* ctxt, MG_Layer* layer,
            DWORD zt_type, int first_for_type, CALCPOSINFO* info);

    void (*on_layer_op) (CompositorCtxt* ctxt, int layer_op,
            MG_Layer* layer, MG_Client* client);

    BOOL (*reset_dirty_region) (CompositorCtxt* ctxt, MG_Layer* layer);

    BOOL (*merge_dirty_ppp) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    BOOL (*merge_dirty_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    BOOL (*merge_dirty_wpp) (CompositorCtxt* ctxt, MG_Layer* layer);

    BOOL (*refresh_dirty_region) (CompositorCtxt* ctxt, MG_Layer* layer);

    void (*on_dirty_screen) (CompositorCtxt* ctxt, MG_Layer* layer,
            DWORD cause_type, const RECT* rc_dirty);

    void (*on_showing_ppp) (CompositorCtxt* ctxt, int zidx);

    void (*on_hiding_ppp) (CompositorCtxt* ctxt, int zidx);

    void (*on_closed_menu) (CompositorCtxt* ctxt, const RECT* rc_bound);

    void (*on_showing_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    void (*on_hiding_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    void (*on_raised_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    void (*on_changed_ct) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    void (*on_changed_rgn) (CompositorCtxt* ctxt, MG_Layer* layer,
            int zidx, const RECT* rc_org_bound);

    void (*on_moved_win) (CompositorCtxt* ctxt, MG_Layer* layer,
            int zidx, const RECT* rc_org);

    void (*on_maximizing_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

    void (*on_minimizing_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);

} CompositorOps;

MG_EXPORT const CompositorOps* GUIAPI ServerGetCompositorOps (const char* name);

MG_EXPORT BOOL GUIAPI ServerRegisterCompositor (
            const char* name, const CompositorOps* ops);

MG_EXPORT BOOL GUIAPI ServerUnregisterCompositor (const char* name);

#define LEN_COMPOSITOR_NAME         15
#define COMPSOR_NAME_DEFAULT        "default"
#define COMPSOR_NAME_FALLBACK       "fallback"

MG_EXPORT const CompositorOps* GUIAPI ServerSelectCompositor (
            const char* name, CompositorCtxt** ctxt);

#define COMPSOR_OPS_VERSION  1

const CompositorOps* __ex_compositor_get (const char* name,
            const CompositorOps* fallback_ops, int* version);

#endif /* defined _MGSCHEMA_COMPOSITING */

#define MAX_SYS_REQID           0x0023

#define MAX_REQID               0x0030

typedef struct _REQUEST {
    int id;
    const void* data;
    size_t len_data;
} REQUEST;
typedef REQUEST* PREQUEST;

MG_EXPORT int GUIAPI ClientRequestEx2 (const REQUEST* request,
                const void* ex_data, size_t ex_data_len, int fd_to_send,
                void* result, size_t len_rslt, int* fd_received);

static inline int GUIAPI ClientRequestEx (const REQUEST* request,
                const void* ex_data, int ex_data_len,
                void* result, int len_rslt)
{
    return ClientRequestEx2 (request, ex_data, ex_data_len, -1,
                result, len_rslt, NULL);
}

static inline int ClientRequest (const REQUEST* request,
                void* result, int len_rslt)
{
    return ClientRequestEx (request, NULL, 0, result, len_rslt);
}

MG_EXPORT int GUIAPI GetSockFD2Server (void);

MG_EXPORT int GUIAPI ServerSendReplyEx (int clifd,
                const void* reply, int len, int fd_to_send);

static inline int GUIAPI ServerSendReply (int clifd, const void* reply, int len)
{
    return ServerSendReplyEx (clifd, reply, len, -1);
}

typedef int (* REQ_HANDLER) (int cli, int clifd, void* buff, size_t len);

typedef int (* REQ_HANDLER_V1) (int cli, int clifd,
                void* buff, size_t len, int fd_received);

MG_EXPORT BOOL GUIAPI RegisterRequestHandler (int req_id,
        REQ_HANDLER your_handler);

MG_EXPORT BOOL GUIAPI RegisterRequestHandlerV1 (int req_id,
                REQ_HANDLER_V1 your_handler_v1);

MG_EXPORT REQ_HANDLER GUIAPI GetRequestHandler (int req_id);

MG_EXPORT REQ_HANDLER_V1 GUIAPI GetRequestHandlerV1 (int req_id);

MG_EXPORT void* GUIAPI GetRequestHandlerEx (int req_id, int* version);

MG_EXPORT int serv_listen (const char* name);

MG_EXPORT int serv_accept (int listenfd, pid_t *pidptr, uid_t *uidptr);

MG_EXPORT int cli_conn (const char* name, char project);

#define SOCKERR_IO          -1
#define SOCKERR_CLOSED      -2
#define SOCKERR_INVARG      -3
#define SOCKERR_TIMEOUT     -4
#define SOCKERR_OK          0

MG_EXPORT ssize_t sock_write_t (int fd, const void* buff, size_t count,
                DWORD timeout);

MG_EXPORT ssize_t sock_read_t (int fd, void* buff, size_t count,
                DWORD timeout);

#define sock_write(fd, buff, count) sock_write_t(fd, buff, count, 0)

#define sock_read(fd, buff, count) sock_read_t(fd, buff, count, 0)

#endif /* _MGRM_PROCESSES */

MG_EXPORT BOOL GUIAPI ReinitDesktopEx (BOOL init_sys_text);

#define ReinitDesktop()    ReinitDesktopEx (TRUE)

MG_EXPORT void GUIAPI ExitGUISafely (int exitcode);

#ifdef _USE_MINIGUIENTRY
  #define main_entry minigui_entry
  int minigui_entry (int args, const char* arg[]);
#else
  #define main_entry main
#endif /* _USE_MINIGUIENTRY */

#define MiniGUIMain                             \
MiniGUIAppMain (int args, const char* argv[]);  \
int main_entry (int args, const char* argv[])   \
{                                               \
    int iRet = 0;                               \
    if (InitGUI (args, argv) != 0) {            \
        return 1;                               \
    }                                           \
    iRet = MiniGUIAppMain (args, argv);         \
    TerminateGUI (iRet);                        \
    return iRet;                                \
}                                               \
int MiniGUIAppMain

#define IDM_DTI_FIRST   (300)

typedef struct _DESKTOPOPS {

    void* (*init) (HDC dc_desktop);

    void (*deinit) (void* context);

    void (*paint_desktop) (void* context,
            HDC dc_desktop, const RECT* inv_rc);

    void (*keyboard_handler) (void* context,
            int message, WPARAM wParam, LPARAM lParam);

    void (*mouse_handler) (void* context,
            int message, WPARAM wParam, LPARAM lParam);

    void (*customize_desktop_menu) (void* context,
                             HMENU hmenu, int start_pos);

    void (*desktop_menucmd_handler) (void* context, int id);
} DESKTOPOPS;

MG_EXPORT DESKTOPOPS* GUIAPI SetCustomDesktopOperationSet
                                       (DESKTOPOPS* usr_dsk_ops);

MG_EXPORT void GUIAPI DesktopUpdateAllWindow (void);

#ifndef _MGRM_PROCESSES

#define DUMMY_LAYER_HANDLE  (GHANDLE)(-1)

static inline GHANDLE GUIAPI JoinLayer (const char* layer_name,
        const char* client_name, int max_nr_highers, int max_nr_normals)
{
    return DUMMY_LAYER_HANDLE;
}

#endif  /* not defined _MGRM_PROCESSES */

#ifdef _MGHAVE_MOUSECALIBRATE

MG_EXPORT BOOL GUIAPI SetMouseCalibrationParameters (const POINT* src_pts,
                const POINT* dst_pts);

MG_EXPORT void GUIAPI GetOriginalMousePosition (int* x, int* y);

#endif /* _MGHAVE_MOUSECALIBRATE */

#ifdef _MGMISC_ABOUTDLG

#ifdef _MGRM_THREADS

MG_EXPORT void GUIAPI OpenAboutDialog (void);

#else /* _MGRM_THREADS */

MG_EXPORT HWND GUIAPI OpenAboutDialog (HWND hHosting);

#endif /* _MGRM_THREADS */

#endif /* _MGMISC_ABOUTDLG */

#define ETC_MAXLINE             1024

#define ETC_FILENOTFOUND        -1

#define ETC_SECTIONNOTFOUND     -2

#define ETC_KEYNOTFOUND         -3

#define ETC_TMPFILEFAILED       -4

#define ETC_FILEIOFAILED        -5

#define ETC_INTCONV             -6

#define ETC_INVALIDOBJ          -7

#define ETC_READONLYOBJ         -8

#define ETC_OK                  0

typedef struct _ETCSECTION
{
    int key_nr_alloc;
    int key_nr;
    char *name;
    char** keys;
    char** values;
} ETCSECTION;
typedef ETCSECTION* PETCSECTION;

typedef struct _ETC_S
{
    int sect_nr_alloc;
    int section_nr;
    PETCSECTION sections;
} ETC_S;

#ifndef _MGINCORE_RES

extern MG_EXPORT char ETCFILEPATH [];

#endif /* !_MGINCORE_RES */

MG_EXPORT int GUIAPI GetValueFromEtcFile (const char* pEtcFile,
        const char* pSection, const char* pKey, char* pValue, int iLen);

MG_EXPORT int GUIAPI GetIntValueFromEtcFile (const char* pEtcFile,
                const char* pSection, const char* pKey, int* value);

MG_EXPORT int GUIAPI SetValueToEtcFile (const char* pEtcFile,
                const char* pSection, const char* pKey, char* pValue);

MG_EXPORT int GUIAPI RemoveSectionInEtcFile (const char* pEtcFile,
                const char* pSection);

MG_EXPORT int GUIAPI SaveSectionToEtcFile (const char* pEtcFile,
                                           PETCSECTION psect);
MG_EXPORT GHANDLE GUIAPI LoadEtcFile (const char * pEtcFile);

MG_EXPORT int GUIAPI SaveEtcToFile (GHANDLE hEtc, const char* file_name);

MG_EXPORT int GUIAPI UnloadEtcFile (GHANDLE hEtc);

MG_EXPORT int GUIAPI GetValueFromEtc (GHANDLE hEtc, const char* pSection,
                const char* pKey, char* pValue, int iLen);

MG_EXPORT int GUIAPI GetIntValueFromEtc (GHANDLE hEtc, const char* pSection,
                const char* pKey, int* pValue);

#define SetValueToEtc(hEtc, pSection, pKey, pValue) \
        GetValueFromEtc(hEtc, pSection, pKey, pValue, -1)

MG_EXPORT GHANDLE GUIAPI FindSectionInEtc (GHANDLE hEtc,
                const char* pSection, BOOL bCreateNew);

MG_EXPORT int GUIAPI GetValueFromEtcSec (GHANDLE hSect,
                const char* pKey, char* pValue, int iLen);

MG_EXPORT int GUIAPI GetIntValueFromEtcSec (GHANDLE hSect,
                const char* pKey, int* pValue);

MG_EXPORT int GUIAPI SetValueToEtcSec (GHANDLE hSect,
                const char* pKey, char* pValue);

MG_EXPORT int GUIAPI RemoveSectionInEtc (GHANDLE hEtc, const char* pSection);

/* global MiniGUI etc file object */
extern MG_EXPORT GHANDLE hMgEtc;

static inline int GetMgEtcValue(const char* pSection,
                const char *pKey, char *pValue, int iLen)
{
#ifndef _MGINCORE_RES
    if (!hMgEtc)
        return GetValueFromEtcFile (ETCFILEPATH, pSection, pKey, pValue, iLen);
#endif /* !_MGINCORE_RES */

    return GetValueFromEtc (hMgEtc, pSection, pKey, pValue, iLen);
}

static inline int GetMgEtcIntValue (const char *pSection,
                const char* pKey, int *value)
{
#ifndef _MGINCORE_RES
    if (!hMgEtc)
        return GetIntValueFromEtcFile (ETCFILEPATH, pSection, pKey, value);
#endif /* !_MGINCORE_RES */

    return GetIntValueFromEtc (hMgEtc, pSection, pKey, value);
}

#ifdef _MGHAVE_CLIPBOARD

#define LEN_CLIPBOARD_NAME      15

#define NR_CLIPBOARDS           4

#define CBNAME_TEXT             ("text")

#define CBERR_OK        0

#define CBERR_BADNAME   1

#define CBERR_NOMEM     2

#define CBOP_NORMAL     0

#define CBOP_APPEND     1

MG_EXPORT int GUIAPI CreateClipBoard (const char* cb_name, size_t size);

MG_EXPORT int GUIAPI DestroyClipBoard (const char* cb_name);

MG_EXPORT int GUIAPI SetClipBoardData (const char* cb_name,
                void* data, size_t n, int cbop);

MG_EXPORT size_t GUIAPI GetClipBoardDataLen (const char* cb_name);

MG_EXPORT size_t GUIAPI GetClipBoardData (const char* cb_name,
                void* data, size_t n);

MG_EXPORT int GUIAPI GetClipBoardByte (const char* cb_name,
                int index, unsigned char* byte);

#endif /* _MGHAVE_CLIPBOARD */

MG_EXPORT DWORD GUIAPI GetTickCount (void);

MG_EXPORT void GUIAPI Ping (void);

#define Beep Ping

MG_EXPORT void GUIAPI Tone (int frequency_hz, int duration_ms);

MG_EXPORT void* GUIAPI GetOriginalTermIO (void);

MG_EXPORT char* GUIAPI FixStrAlloc (int len);

MG_EXPORT char* GUIAPI FixStrDup (const char* str);

MG_EXPORT void GUIAPI FreeFixStr (char* str);

#ifdef _MGHAVE_CURSOR

MG_EXPORT HCURSOR GUIAPI LoadCursorFromFile (const char* filename);

MG_EXPORT HCURSOR GUIAPI LoadCursorFromMem (const void* area);

#ifdef _MGSCHEMA_COMPOSITING

MG_EXPORT HCURSOR GUIAPI LoadCursorFromPNGFile (const char* filename,
        int hotspot_x, int hotspot_y);

MG_EXPORT HCURSOR GUIAPI LoadCursorFromPNGMem (const void* area, size_t size,
        int hotspot_x, int hotspot_y);

#endif /* _MGSCHEMA_COMPOSITING */

MG_EXPORT HCURSOR GUIAPI CreateCursor (int xhotspot, int yhotspot, int w, int h,
               const BYTE* pANDBits, const BYTE* pXORBits, int colornum);

MG_EXPORT HCURSOR GUIAPI CopyCursor (HCURSOR hcsr);

MG_EXPORT BOOL GUIAPI DestroyCursor (HCURSOR hcsr);

MG_EXPORT HCURSOR GUIAPI GetSystemCursor (int csrid);

MG_EXPORT HCURSOR GUIAPI GetCurrentCursor (void);

#else /* _MGHAVE_CURSOR */

static inline HCURSOR LoadCursorFromFile (const char* filename) {
    return (HCURSOR)0;
}

static inline HCURSOR GUIAPI LoadCursorFromMem (const void* area) {
    return (HCURSOR)0;
}

#ifdef _MGSCHEMA_COMPOSITING
static inline
HCURSOR LoadCursorFromPNGFile(const char* filename,
        int hotspot_x, int hotspot_y) {
    return (HCURSOR)0;
}

static inline
HCURSOR GUIAPI LoadCursorFromPNGMem(const void* area, size_t size,
        int hotspot_x, int hotspot_y) {
    return (HCURSOR)0;
}

#endif

static inline
HCURSOR CreateCursor (int xhotspot, int yhotspot, int w, int h,
        const BYTE* pANDBits, const BYTE* pXORBits, int colornum) {
    return (HCURSOR)0;
}

static inline HCURSOR GUIAPI CopyCursor (HCURSOR hcsr) {
    return (HCURSOR)0;
}

static inline BOOL DestroyCursor (HCURSOR hcsr) {
    return TRUE;
}

static inline HCURSOR GetSystemCursor (int csrid) {
    return (HCURSOR)0;
}

static inline HCURSOR GUIAPI GetCurrentCursor (void) {
    return (HCURSOR)0;
}

#endif /* !_MGHAVE_CURSOR */

#define MAX_SYSCURSORINDEX    22

/* System cursor index. */
#define IDC_ARROW       0

#define IDC_IBEAM       1

#define IDC_PENCIL      2

#define IDC_CROSS       3

#define IDC_MOVE        4

#define IDC_SIZENWSE    5

#define IDC_SIZENESW    6

#define IDC_SIZEWE      7

#define IDC_SIZENS      8

#define IDC_UPARROW     9

#define IDC_NONE        10

#define IDC_HELP        11

#define IDC_BUSY        12

#define IDC_WAIT        13

#define IDC_RARROW      14

#define IDC_COLOMN      15

#define IDC_ROW         16

#define IDC_DRAG        17

#define IDC_NODROP      18

#define IDC_HAND_POINT  19

#define IDC_HAND_SELECT 20

#define IDC_SPLIT_HORZ  21

#define IDC_SPLIT_VERT  22

MG_EXPORT void GUIAPI ClipCursor (const RECT* prc);

MG_EXPORT void GUIAPI GetClipCursor (RECT* prc);

MG_EXPORT void GUIAPI GetCursorPos (POINT* ppt);

MG_EXPORT void GUIAPI SetCursorPos (int x, int y);

#ifdef _MGHAVE_CURSOR

MG_EXPORT HCURSOR GUIAPI SetCursorEx (HCURSOR hcsr, BOOL set_def);

MG_EXPORT  HCURSOR GUIAPI GetDefaultCursor (void);

MG_EXPORT int GUIAPI ShowCursor (BOOL fShow);

#else /* _MGHAVE_CURSOR */

static inline HCURSOR SetCursorEx(HCURSOR hcsr, BOOL set_def) {
    return (HCURSOR)0;
}

static inline HCURSOR GetDefaultCursor(void) {
    return (HCURSOR)0;
}

static inline int GUIAPI ShowCursor (BOOL fShow) {
    return 0;
}

#endif /* !_MGHAVE_CURSOR */

#define SetCursor(hcsr) SetCursorEx (hcsr, FALSE)

#define SetDefaultCursor(hcsr) SetCursorEx (hcsr, TRUE)

MG_EXPORT BOOL GUIAPI GetKeyStatus (UINT uKey);

MG_EXPORT DWORD GUIAPI GetShiftKeyStatus (void);

MG_EXPORT void GUIAPI GetKeyboardState (BYTE* kbd_state);

#define IDS_MGST_WINDOW          0

#define IDS_MGST_START           1

#define IDS_MGST_REFRESH         2

#define IDS_MGST_CLOSEALLWIN     3

#define IDS_MGST_ENDSESSION      4

#define IDS_MGST_OPERATIONS      5

#define IDS_MGST_MINIMIZE        6

#define IDS_MGST_MAXIMIZE        7

#define IDS_MGST_RESTORE         8

#define IDS_MGST_CLOSE           9

#define IDS_MGST_OK              10

#define IDS_MGST_NEXT            11

#define IDS_MGST_CANCEL          12

#define IDS_MGST_PREV            13

#define IDS_MGST_YES             14

#define IDS_MGST_NO              15

#define IDS_MGST_ABORT           16

#define IDS_MGST_RETRY           17

#define IDS_MGST_IGNORE          18

#define IDS_MGST_ABOUTMG         19

#define IDS_MGST_OPENFILE        20

#define IDS_MGST_SAVEFILE        21

#define IDS_MGST_COLORSEL        22

#define IDS_MGST_SWITCHLAYER     23

#define IDS_MGST_DELLAYER        24

#define IDS_MGST_ERROR           25

#define IDS_MGST_LOGO            26

#define IDS_MGST_CURRPATH        27

#define IDS_MGST_FILE            28

#define IDS_MGST_LOCATION        29

#define IDS_MGST_UP              30

#define IDS_MGST_NAME            31

#define IDS_MGST_SIZE            32

#define IDS_MGST_ACCESSMODE      33

#define IDS_MGST_LASTMODTIME     34

#define IDS_MGST_OPEN            35

#define IDS_MGST_FILENAME        36

#define IDS_MGST_FILETYPE        37

#define IDS_MGST_SHOWHIDEFILE    38

#define IDS_MGST_NOTFOUND        39

#define IDS_MGST_NR              40

#define IDS_MGST_NW              41

#define IDS_MGST_INFO            42

#define IDS_MGST_R               43

#define IDS_MGST_W               44

#define IDS_MGST_WR              45

#define IDS_MGST_SAVE            46

#define IDS_MGST_FILEEXIST       47

#define IDS_MGST_MAXNUM          47

MG_EXPORT const char* GUIAPI GetSysText (unsigned int id);

extern MG_EXPORT const char* SysText [];

extern MG_EXPORT const char** local_SysText;

#ifdef _MGCHARSET_UNICODE

extern MG_EXPORT const char** GUIAPI GetSysTextInUTF8 (const char* language);

#endif /* _MGCHARSET_UNICODE */

MG_EXPORT char* strnchr (const char* s, size_t n, int c);

MG_EXPORT int substrlen (const char* text, int len, int delimiter,
                int* nr_delim);

MG_EXPORT char * strtrimall (char* src);

MG_EXPORT void *mg_slice_alloc(size_t block_size);

MG_EXPORT void *mg_slice_alloc0(size_t block_size);

MG_EXPORT void *mg_slice_copy(size_t block_size, const void *mem_block);

MG_EXPORT void mg_slice_free(size_t block_size, void *mem_block);

MG_EXPORT void mg_slice_free_chain_with_offset(size_t block_size,
        void *mem_chain, size_t next_offset);

#define mg_slice_new(type)       ((type*)mg_slice_alloc(sizeof (type)))

#define mg_slice_new0(type)      ((type*)mg_slice_alloc0(sizeof (type)))

/* MemoryBlockType *
 *       mg_slice_dup           (MemoryBlockType,
 *                               MemoryBlockType *mem_block);
 *       mg_slice_delete        (MemoryBlockType,
 *                               MemoryBlockType *mem_block);
 *       mg_slice_delete_chain  (MemoryBlockType,
 *                               MemoryBlockType *first_chain_block,
 *                               memory_block_next_field);
 * pseudo prototypes for the macro definitions following below.
 */

#define mg_slice_dup(type, mem)                             \
    (1 ? (type*) mg_slice_copy (sizeof (type), (mem))       \
    : ((void) ((type*) 0 == (mem)), (type*) 0))

#define mg_slice_delete(type, mem)                          \
    do {                                                    \
        if (1) mg_slice_free (sizeof (type), (mem));        \
        else   (void) ((type*) 0 == (mem));                 \
    } while(0)

#define mg_slice_delete_chain(type, mem_chain, next)            \
    do {                                                        \
        if (1) mg_slice_free_chain_with_offset (sizeof (type),  \
                (mem_chain), G_STRUCT_OFFSET (type, next));     \
        else   (void) ((type*) 0 == (mem_chain));               \
    } while(0)

#ifdef _MGDEVEL_MODE
MG_EXPORT void mg_slice_debug_tree_statistics(void);
#endif

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* _MGUI_MINIGUI_H */