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.6 */
#define ZOF_GESTURE_FLAGS_MASK  0X000000F0
#define ZOF_GF_SWIPE_HORZ       0x00000010
#define ZOF_GF_SWIPE_VERT       0x00000020
 
/* Since 5.0.0 */
#define ZOF_INTERNAL_FLAGS_MASK 0X000F0000
#define ZOF_IF_REFERENCE        0x00010000
#define ZOF_IF_ALWAYSTOP        0x00020000
#define ZOF_IF_SPECIAL          0x00040000  // Since 5.0.6
 
#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
#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* mgDefaultLayer;
 
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
#define ZNOP_ICONCHANGED        18  /* reserved for future */
 
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 ServerGetTopmostZNodeOfType (MG_Layer* layer, DWORD type,
                int* cli);
 
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, int cli, 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);
 
    unsigned int (*composite_layers) (CompositorCtxt* ctxt, MG_Layer* layers[],
            int nr_layers, void* combine_param);
 
    void (*transit_to_layer) (CompositorCtxt* ctxt, MG_Layer* to_layer);
 
    void (*on_maximizing_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);
 
    void (*on_minimizing_win) (CompositorCtxt* ctxt, MG_Layer* layer, int zidx);
 
} CompositorOps;
 
#define FCM_HORIZONTAL      0x0000
#define FCM_VERTICAL        0x0001
#define FCM_METHOD_MASK     0x00FF
#define FCM_SCALE           0x0100
 
typedef struct _CombParamsFallback {
    unsigned int method;
 
    float percent;
 
    float scale;
} COMBPARAMS_FALLBACK;
 
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);
 
MG_EXPORT const char* GUIAPI ServerGetCurrentCompositor (
        const CompositorOps** ops, CompositorCtxt** ctxt);
 
#define COMPSOR_OPS_VERSION  2
 
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 */