common.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: common.h 13674 2010-12-06 06:45:01Z wanzheng $
 *
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks,
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 *
 *      The definitions of some data types and byte order macros
 *      borrowed from LGPL'ed SDL by Sam Lantinga.
 *
 *      Fix point math routines come from Allegro (a gift software)
 *      by Shawn Hargreaves and others.
 */

#ifndef _MGUI_COMMON_H

#define _MGUI_COMMON_H

#ifndef MINIGUI_MAJOR_VERSION
#   undef PACKAGE
#   undef VERSION
#   undef PACKAGE_BUGREPORT
#   undef PACKAGE_NAME
#   undef PACKAGE_STRING
#   undef PACKAGE_TARNAME
#   undef PACKAGE_VERSION
#   ifdef __MINIGUI_LIB__
#       ifdef _FOR_DATANG
#           ifdef WIN32
#               include <config-win32/mgconfig.h>
#           elif defined (__THREADX__)
#               include "config-threadx/mgconfig.h"
#           elif defined (__NUCLEUS__)
#               include "config-nucleus/mgconfig.h"
#           endif
#       else
#           if  defined(__CMAKE_PROJECT__) || defined(WIN32)
#               include "mgconfig.h"
#           else
#               include "../mgconfig.h"
#           endif
#       endif
#   else
#       include "mgconfig.h"
#   endif
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdarg.h>
#include <errno.h>
#include <assert.h>

#define _VERSION_CODE(major, minor, micro)  (((major)<<16) | ((minor)<<8) | (micro))

#define _MINIGUI_VERSION_CODE \
        ((MINIGUI_MAJOR_VERSION << 16) | (MINIGUI_MINOR_VERSION << 8) | MINIGUI_MICRO_VERSION)

typedef unsigned char   Uint8;
typedef signed char     Sint8;
typedef unsigned short  Uint16;
typedef signed short    Sint16;
typedef unsigned int    Uint32;
typedef signed int      Sint32;

/* Figure out how to support 64-bit datatypes */
#if !defined(__STRICT_ANSI__)
#   if defined(__GNUC__)
#       define MGUI_HAS_64BIT_TYPE    long long
#   endif
#   if defined(__CC_ARM)
#       define MGUI_HAS_64BIT_TYPE    long long
#   endif
#   if defined(_MSC_VER)
#       define MGUI_HAS_64BIT_TYPE __int64
#   endif
#endif /* !__STRICT_ANSI__ */

/* The 64-bit datatype isn't supported on all platforms */
#ifdef MGUI_HAS_64BIT_TYPE

typedef unsigned MGUI_HAS_64BIT_TYPE Uint64;
typedef signed MGUI_HAS_64BIT_TYPE Sint64;
#else
/* This is really just a hack to prevent the compiler from complaining */
typedef struct {
    Uint32 hi;
    Uint32 lo;
} Uint64, Sint64;
#endif

/* Make sure the types really have the right sizes */
#define MGUI_COMPILE_TIME_ASSERT(name, x)               \
       typedef int MGUI_dummy_ ## name[(x) * 2 - 1]

MGUI_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
MGUI_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
MGUI_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
MGUI_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
MGUI_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
MGUI_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
MGUI_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
MGUI_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);

#undef MGUI_COMPILE_TIME_ASSERT

/* Here we provide MG_GNUC_EXTENSION as an alias for __extension__,
 * where this is valid. This allows for warningless compilation of
 * "long long" types even in the presence of '-ansi -pedantic'. 
 */
#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
#define MG_GNUC_EXTENSION __extension__
#else
#define MG_GNUC_EXTENSION
#endif

/*
 * The MG_LIKELY and MG_UNLIKELY macros let the programmer give hints to
 * the compiler about the expected result of an expression. Some compilers
 * can use this information for optimizations.
 */
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
#define _MG_BOOLEAN_EXPR(expr)                  \
 MG_GNUC_EXTENSION ({                           \
   int _g_boolean_var_;                         \
   if (expr)                                    \
      _g_boolean_var_ = 1;                      \
   else                                         \
      _g_boolean_var_ = 0;                      \
   _g_boolean_var_;                             \
})
#define MG_LIKELY(expr) (__builtin_expect (_MG_BOOLEAN_EXPR(expr), 1))
#define MG_UNLIKELY(expr) (__builtin_expect (_MG_BOOLEAN_EXPR(expr), 0))
#else
#define MG_LIKELY(expr) (expr)
#define MG_UNLIKELY(expr) (expr)
#endif

#define MGUI_LIL_ENDIAN  1234

#define MGUI_BIG_ENDIAN  4321

/* Pardon the mess, I'm trying to determine the endianness of this host.
 *    I'm doing it by preprocessor defines rather than some sort of configure
 *    script so that application code can use this too.  The "right" way would
 *    be to dynamically generate this file on install, but that's a lot of work.
 */

#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__) || defined(__amd64) || \
        (defined(__alpha__) || defined(__alpha)) || \
        defined(__arm__) || defined(__aarch64__) || \
        defined(__riscv) || \
        (defined(__CC_ARM) && !defined(__BIG_ENDIAN)) || \
        (defined(__mips__) && defined(__MIPSEL__)) || \
        defined(__LITTLE_ENDIAN__) || \
        defined(WIN32)
#   define MGUI_BYTEORDER   MGUI_LIL_ENDIAN
#else
#   define MGUI_BYTEORDER   MGUI_BIG_ENDIAN
#endif

typedef void *PVOID;

#ifndef BOOL
typedef int BOOL;
#endif

#ifndef FALSE
    #define FALSE       0
#endif

#ifndef TRUE
    #define TRUE        1
#endif

#ifndef NULL
#   ifdef __cplusplus
#       define NULL            (0)
#   else
#       define NULL            ((void *)0)
#   endif
#endif

#define INV_PTR                ((void *)-1)

#define GUIAPI

#if !defined(__NODLL__) && (defined (WIN32) || defined (__NUCLEUS_MNT__))
#   if defined(__MINIGUI_LIB__)
#       define MG_EXPORT       __declspec(dllexport)
#   else
#       define MG_EXPORT       __declspec(dllimport)
#   endif
#else
#   define MG_EXPORT
#endif

typedef PVOID GHANDLE;
typedef GHANDLE HWND;
typedef GHANDLE HDC;
typedef GHANDLE HPALETTE;
typedef GHANDLE HCURSOR;
typedef GHANDLE HICON;
typedef GHANDLE HMENU;
typedef GHANDLE HACCEL;
typedef GHANDLE HDLG;
typedef GHANDLE HHOOK;

typedef unsigned char   BYTE;

typedef signed char     SBYTE;

#if defined(_WIN64)
#   define SIZEOF_PTR   8
#   define SIZEOF_HPTR  4
#elif defined(__LP64__)
#   define SIZEOF_PTR   8
#   define SIZEOF_HPTR  4
#else
#   define SIZEOF_PTR   4
#   define SIZEOF_HPTR  2
#endif

#if SIZEOF_PTR == 8
#   define NR_BITS_BYTE      (8)
#   define NR_BITS_WORD      (32)
#   define NR_BITS_DWORD     (64)

#   define BITMASK_BYTE      (0xFF)
#   define BITMASK_WORD      (0xFFFFFFFF)
#   define BITMASK_DWORD     (0xFFFFFFFFFFFFFFFF)

#   define INT_PTR_MIN       (-9223372036854775807L-1)
#   define INT_PTR_MAX       (9223372036854775807L)
#   define UINT_PTR_MAX      (18446744073709551615UL)
#else
#   define NR_BITS_BYTE      (8)
#   define NR_BITS_WORD      (16)
#   define NR_BITS_DWORD     (32)

#   define BITMASK_BYTE      (0xFF)
#   define BITMASK_WORD      (0xFFFF)
#   define BITMASK_DWORD     (0xFFFFFFFF)

#   define INT_PTR_MIN       (-2147483647-1)
#   define INT_PTR_MAX       (2147483647)
#   define UINT_PTR_MAX      (4294967295U)
#endif

#if defined(_WIN64)
typedef unsigned int WORD_HPTR;
#elif defined(__LP64__)
typedef unsigned int WORD_HPTR;
#else
typedef unsigned short WORD_HPTR;
#endif

#if defined(_WIN64)
typedef signed int SWORD_HPTR;
#elif defined(__LP64__)
typedef signed int SWORD_HPTR;
#else
typedef signed short SWORD_HPTR;
#endif

typedef WORD_HPTR WORD;

typedef SWORD_HPTR SWORD;

typedef unsigned short WORD16;

typedef signed short SWORD16;

#if defined(_WIN64)
typedef __int64 LONG_PTR;
#elif defined(__LP64__)
typedef long LONG_PTR;
#else
typedef long LONG_PTR;
#endif

typedef LONG_PTR LINT;

typedef LONG_PTR LRESULT;

#if defined(_WIN64)
typedef unsigned __int64 DWORD_PTR;
#elif defined(__LP64__)
typedef unsigned long DWORD_PTR;
#else
typedef unsigned long DWORD_PTR;
#endif

typedef DWORD_PTR DWORD;

typedef unsigned int DWORD32;

#if defined(_WIN64)
typedef signed __int64 SDWORD_PTR;
#elif defined(__LP64__)
typedef signed long SDWORD_PTR;
#else
typedef signed long SDWORD_PTR;
#endif

typedef SDWORD_PTR SDWORD;

typedef signed int SDWORD32;

#if SIZEOF_PTR == 8
typedef unsigned short  QDWORD;
#define QDWORD_SHIFT    16
#else
typedef unsigned char   QDWORD;
#define QDWORD_SHIFT    8
#endif

#define MAKEDWORD(q1, q2, q3, q4) \
    ((DWORD)( \
        (((DWORD)(QDWORD)(q1))) | \
        (((DWORD)((QDWORD)(q2))) << QDWORD_SHIFT) | \
        (((DWORD)((QDWORD)(q3))) << (QDWORD_SHIFT*2)) | \
        (((DWORD)((QDWORD)(q4))) << (QDWORD_SHIFT*3)) \
    ))

#define FIRST_QDWORD(dw)    ((QDWORD)(((DWORD)(dw))))
#define SECOND_QDWORD(dw)   ((QDWORD)((((DWORD)(dw)) >> QDWORD_SHIFT)))
#define THIRD_QDWORD(dw)    ((QDWORD)((((DWORD)(dw)) >> (QDWORD_SHIFT*2))))
#define FOURTH_QDWORD(dw)   ((QDWORD)((((DWORD)(dw)) >> (QDWORD_SHIFT*3))))

typedef unsigned int UINT;

#if defined(_WIN64)
typedef __int64 INT_PTR;
#elif defined(__LP64__)
typedef long INT_PTR;
#else
typedef int INT_PTR;
#endif

#if defined(_WIN64)
typedef unsigned __int64 UINT_PTR;
#elif defined(__LP64__)
typedef unsigned long UINT_PTR;
#else
typedef unsigned long UINT_PTR;
#endif

typedef long LONG;

typedef unsigned long ULONG;

typedef UINT_PTR WPARAM;

typedef UINT_PTR LPARAM;

#define LOBYTE(w)           ((BYTE)(w))

#define HIBYTE(w)           ((BYTE)(((WORD)(w) >> NR_BITS_BYTE) & BITMASK_BYTE))

#define MAKEWORD(low, high) ((WORD)(((BYTE)(low)) | (((WORD)((BYTE)(high))) << NR_BITS_BYTE)))

#define MAKEWORD16(low, high) ((WORD16)(((BYTE)(low)) | (((WORD16)((BYTE)(high))) << 8)))

#define MAKEDWORD32(first, second, third, fourth) \
    ((DWORD32)( \
        ((BYTE)(first)) | \
        (((DWORD32)((BYTE)(second))) << 8) | \
        (((DWORD32)((BYTE)(third))) << 16) | \
        (((DWORD32)((BYTE)(fourth))) << 24) \
    ))

#define MAKEWPARAM(first, second, third, fourth) \
    ((WPARAM)( \
        ((BYTE)(first)) | \
        (((WPARAM)((BYTE)(second))) << 8) | \
        (((WPARAM)((BYTE)(third))) << 16) | \
        (((WPARAM)((BYTE)(fourth))) << 24) \
    ))

#define FIRSTBYTE(w)        ((BYTE)(w))

#define SECONDBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 8))

#define THIRDBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 16))

#define FOURTHBYTE(w)        ((BYTE)(((DWORD32)(w)) >> 24))

#define LOWORD(l)           ((WORD)(DWORD)(l))

#define HIWORD(l)           ((WORD)((((DWORD)(l)) >> NR_BITS_WORD) & BITMASK_WORD))

#define LOSWORD(l)          ((SWORD)(DWORD)(l))

#define HISWORD(l)          ((SWORD)((((DWORD)(l)) >> NR_BITS_WORD) & BITMASK_WORD))

#define MAKELONG32(low, high) ((DWORD32)(((WORD16)(low)) | (((DWORD32)((WORD16)(high))) << 16)))

#define MAKELONG(low, high) ((DWORD)(((WORD)(low)) | (((DWORD)((WORD)(high))) << NR_BITS_WORD)))

typedef DWORD32 RGBCOLOR;

#define GetRValue(rgba)      ((BYTE)(rgba))

#define GetGValue(rgba)      ((BYTE)(((DWORD32)(rgba)) >> 8))

#define GetBValue(rgba)      ((BYTE)((DWORD32)(rgba) >> 16))

#define GetAValue(rgba)      ((BYTE)((DWORD32)(rgba) >> 24))

#define MakeRGBA(r, g, b, a)    \
                (((DWORD32)((BYTE)(r))) \
                | ((DWORD32)((BYTE)(g)) << 8) \
                | ((DWORD32)((BYTE)(b)) << 16) \
                | ((DWORD32)((BYTE)(a)) << 24))

#define MakeRGB(r, g, b) MakeRGBA((r), (g), (b), 255)

typedef struct _RECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;
typedef RECT* PRECT;

typedef struct _POINT
{
    int x;
    int y;
} POINT;
typedef POINT* PPOINT;

typedef struct _SIZE
{
    int cx;
    int cy;
} SIZE;
typedef SIZE* PSIZE;

typedef struct _RGB
{
    BYTE r;
    BYTE g;
    BYTE b;
    BYTE a;
} RGB;

typedef RGB* PRGB;

typedef Sint8       gal_sint8;
typedef Uint8       gal_uint8;

typedef Sint16      gal_sint16;
typedef Uint16      gal_uint16;

typedef Sint32      gal_sint32;
typedef Uint32      gal_uint32;

typedef signed int      gal_sint;
typedef unsigned int    gal_uint;

typedef Uint32          gal_pixel;
typedef Uint32          gal_attr;

typedef long fixed;

typedef struct _GAL_Color
{
    gal_uint8 r;
    gal_uint8 g;
    gal_uint8 b;
    gal_uint8 a;
} GAL_Color;

typedef struct _GAL_Palette
{
    int        ncolors;
    GAL_Color* colors;
} GAL_Palette;

typedef struct _GAL_Rect {
    Sint32      x, y;
    Sint32      w, h;
} GAL_Rect;

#define MGUI_NR_KEYS                    255

#ifndef NR_KEYS
#define NR_KEYS                         250
#endif

#define SCANCODE_USER                   (NR_KEYS + 1)

#define SCANCODE_RESERVED               0
#define SCANCODE_ESCAPE                 1
    #define SCANCODE_ESC                    SCANCODE_ESCAPE

#define SCANCODE_1                      2
#define SCANCODE_2                      3
#define SCANCODE_3                      4
#define SCANCODE_4                      5
#define SCANCODE_5                      6
#define SCANCODE_6                      7
#define SCANCODE_7                      8
#define SCANCODE_8                      9
#define SCANCODE_9                      10
#define SCANCODE_0                      11

#define SCANCODE_MINUS                  12
#define SCANCODE_EQUAL                  13

#define SCANCODE_BACKSPACE              14
#define SCANCODE_TAB                    15

#define SCANCODE_Q                      16
#define SCANCODE_W                      17
#define SCANCODE_E                      18
#define SCANCODE_R                      19
#define SCANCODE_T                      20
#define SCANCODE_Y                      21
#define SCANCODE_U                      22
#define SCANCODE_I                      23
#define SCANCODE_O                      24
#define SCANCODE_P                      25
#define SCANCODE_BRACKET_LEFT           26
    #define SCANCODE_LEFTBRACE              SCANCODE_BRACKET_LEFT
#define SCANCODE_BRACKET_RIGHT          27
    #define SCANCODE_RIGHTBRACE             SCANCODE_BRACKET_RIGHT

#define SCANCODE_ENTER                  28

#define SCANCODE_LEFTCONTROL            29
    #define SCANCODE_LEFTCTRL               SCANCODE_LEFTCONTROL

#define SCANCODE_A                      30
#define SCANCODE_S                      31
#define SCANCODE_D                      32
#define SCANCODE_F                      33
#define SCANCODE_G                      34
#define SCANCODE_H                      35
#define SCANCODE_J                      36
#define SCANCODE_K                      37
#define SCANCODE_L                      38
#define SCANCODE_SEMICOLON              39
#define SCANCODE_APOSTROPHE             40
#define SCANCODE_GRAVE                  41
#define SCANCODE_LEFTSHIFT              42
#define SCANCODE_BACKSLASH              43

#define SCANCODE_Z                      44
#define SCANCODE_X                      45
#define SCANCODE_C                      46
#define SCANCODE_V                      47
#define SCANCODE_B                      48
#define SCANCODE_N                      49
#define SCANCODE_M                      50
#define SCANCODE_COMMA                  51
#define SCANCODE_PERIOD                 52
    #define SCANCODE_DOT                    SCANCODE_PERIOD
#define SCANCODE_SLASH                  53
#define SCANCODE_RIGHTSHIFT             54
#define SCANCODE_KEYPADMULTIPLY         55
    #define SCANCODE_KPASTERISK             SCANCODE_KEYPADMULTIPLY
#define SCANCODE_LEFTALT                56
#define SCANCODE_SPACE                  57
#define SCANCODE_CAPSLOCK               58

#define SCANCODE_F1                     59
#define SCANCODE_F2                     60
#define SCANCODE_F3                     61
#define SCANCODE_F4                     62
#define SCANCODE_F5                     63
#define SCANCODE_F6                     64
#define SCANCODE_F7                     65
#define SCANCODE_F8                     66
#define SCANCODE_F9                     67
#define SCANCODE_F10                    68

#define SCANCODE_NUMLOCK                69
#define SCANCODE_SCROLLLOCK             70

#define SCANCODE_KEYPAD7                71
    #define SCANCODE_KP7                    SCANCODE_KEYPAD7
#define SCANCODE_CURSORUPLEFT           71
#define SCANCODE_KEYPAD8                72
    #define SCANCODE_KP8                    SCANCODE_KEYPAD8
#define SCANCODE_CURSORUP               72
#define SCANCODE_KEYPAD9                73
    #define SCANCODE_KP9                    SCANCODE_KEYPAD9
#define SCANCODE_CURSORUPRIGHT          73
#define SCANCODE_KEYPADMINUS            74
    #define SCANCODE_KPMINUS                SCANCODE_KEYPADMINUS
#define SCANCODE_KEYPAD4                75
    #define SCANCODE_KP4                    SCANCODE_KEYPAD4
#define SCANCODE_CURSORLEFT             75
#define SCANCODE_KEYPAD5                76
    #define SCANCODE_KP5                    SCANCODE_KEYPAD5
#define SCANCODE_KEYPAD6                77
    #define SCANCODE_KP6                    SCANCODE_KEYPAD6
#define SCANCODE_CURSORRIGHT            77
#define SCANCODE_KEYPADPLUS             78
    #define SCANCODE_KPPLUS                 SCANCODE_KEYPADPLUS
#define SCANCODE_KEYPAD1                79
    #define SCANCODE_KP1                    SCANCODE_KEYPAD1
#define SCANCODE_CURSORDOWNLEFT         79
#define SCANCODE_KEYPAD2                80
    #define SCANCODE_KP2                    SCANCODE_KEYPAD2
#define SCANCODE_CURSORDOWN             80
#define SCANCODE_KEYPAD3                81
    #define SCANCODE_KP3                    SCANCODE_KEYPAD3
#define SCANCODE_CURSORDOWNRIGHT        81
#define SCANCODE_KEYPAD0                82
    #define SCANCODE_KP0                    SCANCODE_KEYPAD0
#define SCANCODE_KEYPADPERIOD           83
    #define SCANCODE_KPDOT                  SCANCODE_KEYPADPERIOD

#define SCANCODE_ZENKAKUHANKAKU         85

#define SCANCODE_LESS                   86
#define SCANCODE_102ND                      SCANCODE_LESS

#define SCANCODE_F11                    87
#define SCANCODE_F12                    88

#define SCANCODE_RO                     89
#define SCANCODE_KATAKANA               90
#define SCANCODE_HIRAGANA               91
#define SCANCODE_HENKAN                 92
#define SCANCODE_KATAKANAHIRAGANA       93
#define SCANCODE_MUHENKAN               94
#define SCANCODE_KPJPCOMMA              95

#define SCANCODE_KEYPADENTER            96
    #define SCANCODE_KPENTER                SCANCODE_KEYPADENTER
#define SCANCODE_RIGHTCONTROL           97
    #define SCANCODE_RIGHTCTRL              SCANCODE_RIGHTCONTROL
#define SCANCODE_CONTROL                97
#define SCANCODE_KEYPADDIVIDE           98
    #define SCANCODE_KPSLASH                SCANCODE_KEYPADDIVIDE
#define SCANCODE_PRINTSCREEN            99
    #define SCANCODE_SYSRQ                  SCANCODE_PRINTSCREEN
#define SCANCODE_RIGHTALT               100
#define SCANCODE_LINEFEED               101

#define SCANCODE_HOME                   102
#define SCANCODE_CURSORBLOCKUP          103    /* Cursor key block */
    #define SCANCODE_UP                     SCANCODE_CURSORBLOCKUP
#define SCANCODE_PAGEUP                 104
#define SCANCODE_CURSORBLOCKLEFT        105    /* Cursor key block */
    #define SCANCODE_LEFT                   SCANCODE_CURSORBLOCKLEFT
#define SCANCODE_CURSORBLOCKRIGHT       106    /* Cursor key block */
    #define SCANCODE_RIGHT                  SCANCODE_CURSORBLOCKRIGHT
#define SCANCODE_END                    107
#define SCANCODE_CURSORBLOCKDOWN        108    /* Cursor key block */
    #define SCANCODE_DOWN                   SCANCODE_CURSORBLOCKDOWN
#define SCANCODE_PAGEDOWN               109
#define SCANCODE_INSERT                 110
#define SCANCODE_REMOVE                 111
    #define SCANCODE_DELETE                 SCANCODE_REMOVE

#define SCANCODE_MACRO                  112
#define SCANCODE_MUTE                   113
#define SCANCODE_VOLUMEDOWN             114
#define SCANCODE_VOLUMEUP               115
#define SCANCODE_POWER                  116     /* SC System Power Down */
#define SCANCODE_KPEQUAL                117
#define SCANCODE_KPPLUSMINUS            118
#define SCANCODE_BREAK                  119
    #define SCANCODE_BREAK_ALTERNATIVE      SCANCODE_BREAK
    #define SCANCODE_PAUSE                  SCANCODE_BREAK

#define SCANCODE_SCALE                  120    /* AL Compiz Scale (Expose) */
#define SCANCODE_KPCOMMA                121
#define SCANCODE_HANGEUL                122
#define SCANCODE_HANJA                  123
#define SCANCODE_YEN                    124
#define SCANCODE_LEFTWIN                125
    #define SCANCODE_LEFTMETA               SCANCODE_LEFTWIN
#define SCANCODE_RIGHTWIN               126
    #define SCANCODE_RIGHTMETA              SCANCODE_RIGHTWIN
#define SCANCODE_COMPOSE                127
#define SCANCODE_STOP                   128    /* AC Stop */
#define SCANCODE_AGAIN                  129
#define SCANCODE_PROPS                  130    /* AC Properties */
#define SCANCODE_UNDO                   131    /* AC Undo */
#define SCANCODE_FRONT                  132
#define SCANCODE_COPY                   133    /* AC Copy */
#define SCANCODE_OPEN                   134    /* AC Open */
#define SCANCODE_PASTE                  135    /* AC Paste */
#define SCANCODE_FIND                   136    /* AC Search */
#define SCANCODE_CUT                    137    /* AC Cut */
#define SCANCODE_HELP                   138    /* AL Integrated Help Center */
#define SCANCODE_MENU                   139    /* Menu (show menu) */
#define SCANCODE_CALC                   140    /* AL Calculator */
#define SCANCODE_SETUP                  141
#define SCANCODE_SLEEP                  142    /* SC System Sleep */
#define SCANCODE_WAKEUP                 143    /* System Wake Up */
#define SCANCODE_FILE                   144    /* AL Local Machine Browser */
#define SCANCODE_SENDFILE               145
#define SCANCODE_DELETEFILE             146
#define SCANCODE_XFER                   147
#define SCANCODE_PROG1                  148
#define SCANCODE_PROG2                  149
#define SCANCODE_WWW                    150    /* AL Internet Browser */
#define SCANCODE_MSDOS                  151
#define SCANCODE_COFFEE                 152    /* AL Terminal Lock/Screensaver */
    #define SCANCODE_SCREENLOCK             SCANCODE_COFFEE
#define SCANCODE_ROTATE_DISPLAY         153    /* Display orientation for e.g. tablets */
    #define SCANCODE_DIRECTION              SCANCODE_ROTATE_DISPLAY
#define SCANCODE_CYCLEWINDOWS           154
#define SCANCODE_MAIL                   155
#define SCANCODE_BOOKMARKS              156    /* AC Bookmarks */
#define SCANCODE_COMPUTER               157
#define SCANCODE_BACK                   158    /* AC Back */
#define SCANCODE_FORWARD                159    /* AC Forward */
#define SCANCODE_CLOSECD                160
#define SCANCODE_EJECTCD                161
#define SCANCODE_EJECTCLOSECD           162
#define SCANCODE_NEXTSONG               163
#define SCANCODE_PLAYPAUSE              164
#define SCANCODE_PREVIOUSSONG           165
#define SCANCODE_STOPCD                 166
#define SCANCODE_RECORD                 167
#define SCANCODE_REWIND                 168
#define SCANCODE_PHONE                  169    /* Media Select Telephone */
#define SCANCODE_ISO                    170
#define SCANCODE_CONFIG                 171    /* AL Consumer Control Configuration */
#define SCANCODE_HOMEPAGE               172    /* AC Home */
#define SCANCODE_REFRESH                173    /* AC Refresh */
#define SCANCODE_EXIT                   174    /* AC Exit */
#define SCANCODE_MOVE                   175
#define SCANCODE_EDIT                   176
#define SCANCODE_SCROLLUP               177
#define SCANCODE_SCROLLDOWN             178
#define SCANCODE_KPLEFTPAREN            179
#define SCANCODE_KPRIGHTPAREN           180
#define SCANCODE_NEW                    181    /* AC New */
#define SCANCODE_REDO                   182    /* AC Redo/Repeat */
#define SCANCODE_F13                    183
#define SCANCODE_F14                    184
#define SCANCODE_F15                    185
#define SCANCODE_F16                    186
#define SCANCODE_F17                    187
#define SCANCODE_F18                    188
#define SCANCODE_F19                    189
#define SCANCODE_F20                    190
#define SCANCODE_F21                    191
#define SCANCODE_F22                    192
#define SCANCODE_F23                    193
#define SCANCODE_F24                    194

#define SCANCODE_PLAYCD                 200
#define SCANCODE_PAUSECD                201
#define SCANCODE_PROG3                  202
#define SCANCODE_PROG4                  203
#define SCANCODE_DASHBOARD              204    /* AL Dashboard */
#define SCANCODE_SUSPEND                205
#define SCANCODE_CLOSE                  206    /* AC Close */
#define SCANCODE_PLAY                   207
#define SCANCODE_FASTFORWARD            208
#define SCANCODE_BASSBOOST              209
#define SCANCODE_PRINT                  210    /* AC Print */
#define SCANCODE_HP                     211
#define SCANCODE_CAMERA                 212
#define SCANCODE_SOUND                  213
#define SCANCODE_QUESTION               214
#define SCANCODE_EMAIL                  215
#define SCANCODE_CHAT                   216
#define SCANCODE_SEARCH                 217
#define SCANCODE_CONNECT                218
#define SCANCODE_FINANCE                219    /* AL Checkbook/Finance */
#define SCANCODE_SPORT                  220
#define SCANCODE_SHOP                   221
#define SCANCODE_ALTERASE               222
#define SCANCODE_CANCEL                 223    /* AC Cancel */
#define SCANCODE_BRIGHTNESSDOWN         224
#define SCANCODE_BRIGHTNESSUP           225
#define SCANCODE_MEDIA                  226
#define SCANCODE_SWITCHVIDEOMODE        227    /* Cycle between available video outputs (Monitor/LCD/TV-out/etc) */
#define SCANCODE_KBDILLUMTOGGLE         228
#define SCANCODE_KBDILLUMDOWN           229
#define SCANCODE_KBDILLUMUP             230
#define SCANCODE_SEND                   231    /* AC Send */
#define SCANCODE_REPLY                  232    /* AC Reply */
#define SCANCODE_FORWARDMAIL            233    /* AC Forward Msg */
#define SCANCODE_SAVE                   234    /* AC Save */
#define SCANCODE_DOCUMENTS              235
#define SCANCODE_BATTERY                236
#define SCANCODE_BLUETOOTH              237
#define SCANCODE_WLAN                   238
#define SCANCODE_UWB                    239
#define SCANCODE_UNKNOWN                240
#define SCANCODE_VIDEO_NEXT             241    /* drive next video source */
#define SCANCODE_VIDEO_PREV             242    /* drive previous video source */
#define SCANCODE_BRIGHTNESS_CYCLE       243    /* brightness up, after max is min */
#define SCANCODE_BRIGHTNESS_AUTO        244    /* Set Auto Brightness: manual brightness control is off, rely on ambient */
    #define SCANCODE_BRIGHTNESS_ZERO        SCANCODE_BRIGHTNESS_AUTO
#define SCANCODE_DISPLAY_OFF            245    /* display device to off state */
#define SCANCODE_WWAN                   246    /* Wireless WAN (LTE, UMTS, GSM, etc.) */
    #define SCANCODE_WIMAX                  SCANCODE_WWAN
#define SCANCODE_RFKILL                 247    /* Key that controls all radios */
#define SCANCODE_MICMUTE                248    /* Mute / unmute the microphone */

#define SCANCODE_LEFTBUTTON             0x1000
#define SCANCODE_RIGHTBUTTON            0x2000
#define SCANCODE_MIDDLBUTTON            0x4000

#define KS_LEFTMETA                    0x00002000

#define KS_RIGHTMETA                   0x00001000

#define KS_META                        0x00003000

#define KS_REPEATED                     0x00000800

#define KS_CAPTURED                     0x00000400

#define KS_IMEPOST                      0x00000200

#define KS_CAPSLOCK                     0x00000100

#define KS_NUMLOCK                      0x00000080

#define KS_SCROLLLOCK                   0x00000040

#define KS_LEFTCTRL                     0x00000020

#define KS_RIGHTCTRL                    0x00000010

#define KS_CTRL                         0x00000030

#define KS_LEFTALT                      0x00000008

#define KS_RIGHTALT                     0x00000004

#define KS_ALT                          0x0000000C

#define KS_LEFTSHIFT                    0x00000002

#define KS_RIGHTSHIFT                   0x00000001

#define KS_SHIFT                        0x00000003

#define MASK_KS_SHIFTKEYS               0x0000FFFF

#define KS_LEFTBUTTON                   0x00010000

#define KS_RIGHTBUTTON                  0x00020000

#define KS_MIDDLEBUTTON                 0x00040000

#define MASK_KS_BUTTONS                 0x000F0000

#define ERR_OK                   0

#define ERR_INV_HWND            -1

#define ERR_QUEUE_FULL          -2

#define ERR_INVALID_HANDLE      -3

#define ERR_INVALID_HMENU       -4

#define ERR_INVALID_POS         -5

#define ERR_INVALID_ID          -6

#define ERR_RES_ALLOCATION      -7

#define ERR_CTRLCLASS_INVNAME   -8

#define ERR_CTRLCLASS_INVLEN    -9

#define ERR_CTRLCLASS_MEM       -10

#define ERR_CTRLCLASS_INUSE     -11

#define ERR_ALREADY_EXIST       -12

#define ERR_NO_MATCH            -13

#define ERR_BAD_OWNER           -14

#define ERR_IME_TOOMUCHIMEWND   -15

#define ERR_IME_NOSUCHIMEWND    -16

#define ERR_IME_NOIMEWND        -17

#define ERR_CONFIG_FILE         -18

#define ERR_FILE_IO             -19

#define ERR_GFX_ENGINE          -20

#define ERR_INPUT_ENGINE        -21

#define ERR_NO_ENGINE           -22

#define ERR_INVALID_ARGS        -23

#define TABLESIZE(table)    (sizeof(table)/sizeof(table[0]))

/* MAX/MIN/ABS macors */
#ifndef MAX
#define MAX(x, y)           (((x) > (y))?(x):(y))
#endif

#ifndef MIN
#define MIN(x, y)           (((x) < (y))?(x):(y))
#endif

#ifndef ABS
#define ABS(x)              (((x)<0) ? -(x) : (x))
#endif

/* Commonly used definitions */
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif

#ifndef PATH_MAX
#   define PATH_MAX    256
#endif

#ifndef NAME_MAX
#   define NAME_MAX    64
#endif


#ifndef MAX_PATH
#   define MAX_PATH        PATH_MAX
#endif

#ifndef MAX_NAME
#   define MAX_NAME        NAME_MAX
#endif

#ifdef HAVE_TIME
#include <time.h>
#else
typedef unsigned long time_t;

struct tm {
    int    tm_sec;   /* seconds [0,61] */
    int    tm_min;   /* minutes [0,59] */
    int    tm_hour;  /* hour [0,23] */
    int    tm_mday;  /* day of month [1,31] */
    int    tm_mon;   /* month of year [0,11] */
    int    tm_year;  /* years since 1900 */
    int    tm_wday;  /* day of week [0,6] (Sunday = 0) */
    int    tm_yday;  /* day of year [0,365] */
    int    tm_isdst; /* daylight savings flag */
};
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if defined (__THREADX__) && defined (__TARGET_VFANVIL__)
#include  "fx_api.h"
#include  "tx_api.h"
#include  "os_type.h"
#include  "os_file_api.h"

#define fopen     tp_fopen
#define fclose     tp_fclose
#define fwrite     tp_fwrite
#define fread    tp_fread
#define fseek    tp_fseek
#define feof    tp_feof

#undef assert
#define _HAVE_ASSERT 1

#define assert(e) do {          \
                         e;     \
                     } while (0)

#undef stdin
#undef stdout
#undef stderr

#define stdin ((FILE*)0)
#define stdout ((FILE*)1)
#define stderr ((FILE*)2)
void Comm_Lock_Screen (void);
void Comm_Unlock_Screen (void);

#endif

#ifdef __UCOSII__

/* use our own implementation of strdup */
#undef HAVE_STRDUP
#undef strdup
#define strdup own_strdup

#endif /* __UCOSII__ */

#ifndef HAVE_STRDUP
MG_EXPORT char *strdup(const char *s);
#endif

#ifndef HAVE_STRCASECMP
MG_EXPORT int strcasecmp(const char *s1, const char *s2);
#endif

#ifndef HAVE_STRNCASECMP
MG_EXPORT int strncasecmp(const char *s1, const char *s2, unsigned int n);
#endif

#ifdef _MGUSE_OWN_MALLOC

int init_minigui_malloc (unsigned char* heap, unsigned int heap_size,
                int (*lock_heap) (void), int (*unlock_heap) (void));

#define USE_DL_PREFIX

#include "own_malloc.h"

/* wrappers for malloc functions */
#define calloc      dlcalloc
#define free        dlfree
#define malloc      dlmalloc
#define memalign    dlmemalign
#define realloc     dlrealloc
#define valloc      dlvalloc

#endif

/* Do not use the alloca of ARMCC */
#if defined(__CC_ARM)
#   undef HAVE_ALLOCA
#   undef HAVE_ALLOCA_H
#endif

#ifdef HAVE_ALLOCA_H
#   include <alloca.h>
#   define ALLOCATE_LOCAL(size)    alloca((int)(size))
#   define DEALLOCATE_LOCAL(ptr)   /* as nothing */
#else
#   define ALLOCATE_LOCAL(size)    malloc((int)(size))
#   define DEALLOCATE_LOCAL(ptr)   free(ptr)
#endif

#ifdef _MGUSE_OWN_STDIO

int init_minigui_printf (int (*output_char) (int ch),
                int (*input_char) (void));

#if defined (__UCOSII__) || defined (__VXWORKS__) || defined (__NUCLEUS__) || defined (__PSOS__)
#   undef _PRINTF_FLOATING_POINT
#   undef _SCANF_FLOATING_POINT
#else
#   ifdef HAVE_MATH_H
#       define _PRINTF_FLOATING_POINT      1
#       define _SCANF_FLOATING_POINT       1
#   endif
#endif

#ifdef WIN32
#   include <float.h>
#   define isnan    _isnan
#   define finite   _finite
#endif

#undef _I18N_MB_REQUIRED

#if defined(__VXWORKS__) || defined(WIN32) || defined (__NUCLEUS_MNT__) || defined (__PSOS__)
  #define _MGUSE_OWN_SNPRINTF
  #define _MGUSE_OWN_VSNPRINTF
  #define _MGUSE_OWN_VFNPRINTF
#else
  #define _MGUSE_OWN_PRINTF
  #define _MGUSE_OWN_FPRINTF
  #define _MGUSE_OWN_SPRINTF
  #define _MGUSE_OWN_FNPRINTF
  #define _MGUSE_OWN_SNPRINTF
  #define _MGUSE_OWN_VPRINTF
  #define _MGUSE_OWN_VFPRINTF
  #define _MGUSE_OWN_VSPRINTF
  #define _MGUSE_OWN_VFNPRINTF
  #define _MGUSE_OWN_VSNPRINTF
  #define _MGUSE_OWN_SCANF
  #define _MGUSE_OWN_FSCANF
  #define _MGUSE_OWN_SSCANF
  #define _MGUSE_OWN_VSCANF
  #define _MGUSE_OWN_VFSCANF
  #define _MGUSE_OWN_VSSCANF
#endif

#include "own_stdio.h"

/* wrappers for stdio functions */
#ifdef _MGUSE_OWN_PRINTF
  #define printf      own_printf
#endif

#ifdef _MGUSE_OWN_FPRINTF
  #define fprintf     own_fprintf
#endif

#ifdef _MGUSE_OWN_SPRINTF
  #define sprintf     own_sprintf
#endif

#ifdef _MGUSE_OWN_FNPRINTF
  #define fnprintf    own_fnprintf
#endif

#ifdef _MGUSE_OWN_SNPRINTF
  #define snprintf    own_snprintf
#endif

#ifdef _MGUSE_OWN_VPRINTF
  #define vprintf     own_vprintf
#endif

#ifdef _MGUSE_OWN_VFPRINTF
  #define vfprintf    own_vfprintf
#endif

#ifdef _MGUSE_OWN_VSPRINTF
  #define vsprintf    own_vsprintf
#endif

#ifdef _MGUSE_OWN_VFNPRINTF
  #define vfnprintf   own_vfnprintf
#endif

#ifdef _MGUSE_OWN_VSNPRINTF
  #define vsnprintf   own_vsnprintf
#endif

#ifdef _MGUSE_OWN_SCANF
  #define scanf       own_scanf
#endif

#ifdef _MGUSE_OWN_FSCANF
  #define fscanf      own_fscanf
#endif

#ifdef _MGUSE_OWN_SSCANF
  #define sscanf      own_sscanf
#endif

#ifdef _MGUSE_OWN_VSCANF
  #define vscanf      own_vscanf
#endif

#ifdef _MGUSE_OWN_VFSCANF
  #define vfscanf     own_vfscanf
#endif

#ifdef _MGUSE_OWN_VSSCANF
  #define vsscanf     own_vsscanf
#endif

#endif /* _MGUSE_OWN_STDIO */

#ifdef __LINUX__
    #define TCS_NONE(fp)            fprintf (fp, "\e[0m")
    #define TCS_BLACK(fp)           fprintf (fp, "\e[0;30m")
    #define TCS_BOLD_BLACK(fp)      fprintf (fp, "\e[1;30m")
    #define TCS_RED(fp)             fprintf (fp, "\e[0;31m")
    #define TCS_BOLD_RED(fp)        fprintf (fp, "\e[1;31m")
    #define TCS_GREEN(fp)           fprintf (fp, "\e[0;32m")
    #define TCS_BOLD_GREEN(fp)      fprintf (fp, "\e[1;32m")
    #define TCS_BROWN(fp)           fprintf (fp, "\e[0;33m")
    #define TCS_YELLOW(fp)          fprintf (fp, "\e[1;33m")
    #define TCS_BLUE(fp)            fprintf (fp, "\e[0;34m")
    #define TCS_BOLD_BLUE(fp)       fprintf (fp, "\e[1;34m")
    #define TCS_PURPLE(fp)          fprintf (fp, "\e[0;35m")
    #define TCS_BOLD_PURPLE(fp)     fprintf (fp, "\e[1;35m")
    #define TCS_CYAN(fp)            fprintf (fp, "\e[0;36m")
    #define TCS_BOLD_CYAN(fp)       fprintf (fp, "\e[1;36m")
    #define TCS_GRAY(fp)            fprintf (fp, "\e[0;37m")
    #define TCS_WHITE(fp)           fprintf (fp, "\e[1;37m")
    #define TCS_BOLD(fp)            fprintf (fp, "\e[1m")
    #define TCS_UNDERLINE(fp)       fprintf (fp, "\e[4m")
    #define TCS_BLINK(fp)           fprintf (fp, "\e[5m")
    #define TCS_REVERSE(fp)         fprintf (fp, "\e[7m")
    #define TCS_HIDE(fp)            fprintf (fp, "\e[8m")
    #define TCS_CLEAR(fp)           fprintf (fp, "\e[2J")
    #define TCS_CLRLINE(fp)         fprintf (fp, "\e[1K\r")
#else
    #define TCS_NONE(fp)
    #define TCS_BLACK(fp)
    #define TCS_BOLD_BLACK(fp)
    #define TCS_RED(fp)
    #define TCS_BOLD_RED(fp)
    #define TCS_GREEN(fp)
    #define TCS_BOLD_GREEN(fp)
    #define TCS_BROWN(fp)
    #define TCS_YELLOW(fp)
    #define TCS_BLUE(fp)
    #define TCS_BOLD_BLUE(fp)
    #define TCS_PURPLE(fp)
    #define TCS_BOLD_PURPLE(fp)
    #define TCS_CYAN(fp)
    #define TCS_BOLD_CYAN(fp)
    #define TCS_GRAY(fp)
    #define TCS_WHITE(fp)
    #define TCS_BOLD(fp)
    #define TCS_UNDERLINE(fp)
    #define TCS_BLINK(fp)
    #define TCS_REVERSE(fp)
    #define TCS_HIDE(fp)
    #define TCS_CLEAR(fp)
    #define TCS_CLRLINE(fp)
#endif

#define _MG_PRINTF(fmt, ...)                    \
    do {                                        \
        TCS_GREEN (stdout);                     \
        fprintf (stdout, fmt, ##__VA_ARGS__);   \
        TCS_NONE (stdout);                      \
    } while (0)

#define _WRN_PRINTF(fmt, ...)                   \
    do {                                        \
        TCS_BROWN (stderr);                    \
        fprintf (stderr, "%s: ", __FUNCTION__); \
        fprintf (stderr, fmt, ##__VA_ARGS__);   \
        TCS_NONE (stderr);                      \
    } while (0)

#define _ERR_PRINTF(fmt, ...)                   \
    do {                                        \
        TCS_RED (stderr);                       \
        fprintf (stderr, fmt, ##__VA_ARGS__);   \
        TCS_NONE (stderr);                      \
    } while (0)

#if defined(_DEBUG)
#   define _DBG_PRINTF(fmt, ...)                \
    do {                                        \
        TCS_YELLOW (stderr);                    \
        fprintf (stderr, "%s: ", __FUNCTION__); \
        fprintf (stderr, fmt, ##__VA_ARGS__);   \
        TCS_NONE (stderr);                      \
    } while (0)
# else
#   define _DBG_PRINTF(fmt, ...) do { } while (0)
#endif

#ifdef _MGRM_THREADS

#ifdef _MGUSE_OWN_PTHREAD

#define MAIN_PTH_MIN_STACK_SIZE (1024)
#define MAIN_PTH_DEF_STACK_SIZE (1024*4)

int start_minigui_pthread (int (* pth_entry) (int argc, const char* argv []),
                int argc, const char* argv[],
                char* stack_base, unsigned int stack_size);

#ifndef ESRCH
#   define ESRCH      3
#endif

#ifndef EAGAIN
#   define EAGAIN     11
#endif

#ifndef ENOMEM
#   define ENOMEM     12
#endif

#ifndef EBUSY
#   define EBUSY      16
#endif

#ifndef EINVAL
#   define EINVAL     22
#endif

#ifndef EDEADLK
#   define EDEADLK    35
#endif

#ifndef ENOSYS
#   define ENOSYS     38
#endif

#ifndef ENOTSUP
#   define ENOTSUP    95
#endif

#ifdef __VXWORKS__

#define pthread_create vxworks_pthread_create
#define pthread_self   vxworks_pthread_self
#define pthread_equal  vxworks_pthread_equal
#define pthread_exit   vxworks_pthread_exit
#define pthread_join   vxworks_pthread_join
#define pthread_detach vxworks_pthread_detach
#define pthread_cancel vxworks_pthread_cancel
#define pthread_once   vxworks_pthread_once
#define pthread_key_create vxworks_pthread_key_create
#define pthread_key_delete vxworks_pthread_key_delete
#define pthread_setspecific vxworks_pthread_setspecific
#define pthread_getspecific vxworks_pthread_getspecific
#define pthread_setcancelstate vxworks_pthread_setcancelstate
#define pthread_setcanceltype vxworks_pthread_setcanceltype
#define pthread_testcancel vxworks_pthread_testcancel

#define pthread_attr_init    vxworks_pthread_attr_init
#define pthread_attr_destroy vxworks_pthread_attr_destroy
#define pthread_attr_setdetachstate vxworks_pthread_attr_setdetachstate
#define pthread_attr_getdetachstate vxworks_pthread_attr_getdetachstate
#define pthread_attr_setscope vxworks_pthread_attr_setscope
#define pthread_attr_getscope vxworks_pthread_attr_getscope
#define pthread_attr_setinheritsched vxworks_pthread_attr_setinheritsched
#define pthread_attr_getinheritsched vxworks_pthread_attr_getinheritsched
#define pthread_attr_setschedpolicy vxworks_pthread_attr_setschedpolicy
#define pthread_attr_getschedpolicy vxworks_pthread_attr_getschedpolicy
#define pthread_attr_setschedparam vxworks_pthread_attr_setschedparam
#define pthread_attr_getschedparam vxworks_pthread_attr_getschedparam
#define pthread_attr_setstackaddr vxworks_pthread_attr_setstackaddr
#define pthread_attr_getstackaddr vxworks_pthread_attr_getstackaddr
#define pthread_attr_setstacksize vxworks_pthread_attr_setstacksize
#define pthread_attr_getstacksize vxworks_pthread_attr_getstacksize
#define pthread_setschedparam vxworks_pthread_setschedparam
#define pthread_getschedparam vxworks_pthread_getschedparam

#define pthread_mutex_init  vxworks_pthread_mutex_init
#define pthread_mutex_destroy vxworks_pthread_mutex_destroy
#define pthread_mutex_lock  vxworks_pthread_mutex_lock
#define pthread_mutex_unlock vxworks_pthread_mutex_unlock
#define pthread_mutex_trylock vxworks_pthread_mutex_trylock
#define pthread_mutexattr_init vxworks_pthread_mutexattr_init
#define pthread_mutexattr_destroy vxworks_pthread_mutexattr_destroy
#define pthread_mutexattr_setpriorityinherit vxworks_pthread_mutexattr_setpriorityinherit
#define pthread_mutexattr_getpriorityinherit vxworks_pthread_mutexattr_getpriorityinherit

#ifdef _MGUSE_OWN_SEMAPHORE

#define sem_t vxworks_sem_t

#define sem_init vxworks_sem_init
#define sem_destroy vxworks_sem_destroy
#define sem_wait vxworks_sem_wait
#define sem_trywait vxworks_sem_trywait
#define sem_post vxworks_sem_post
#define sem_getvalue vxworks_sem_getvalue

#endif /* _MGUSE_OWN_SEMAPHORE */

#endif /* __VXWORKS__ */

#ifdef __MINIGUI_LIB__

#ifdef __UCOSII__
#   include "ucos2_pthread.h"
#   include "ucos2_semaphore.h"
#elif defined (__THREADX__)
#   include "threadx_pthread.h"
#   include "threadx_semaphore.h"
#elif defined (__NUCLEUS__)
#   include "nucleus_pthread.h"
#   include "nucleus_semaphore.h"
#elif defined (__VXWORKS__)
#   include "vxworks_pthread.h"
#   ifdef _MGUSE_OWN_SEMAPHORE
#       include "vxworks_semaphore.h"
#   else
#       include "semaphore.h"
#   endif
#elif defined (__OSE__)
#   include "pthread.h"
#   include "ose_semaphore.h"
#elif defined (__PSOS__)
#   include "psos_pthread.h"
#   include "psos_semaphore.h"
#elif defined (WIN32)
#   include "win32_pthread.h"
#   include "win32_semaphore.h"
#else
#   error No own pthread implementation for this OS!
#endif

#else

#   include <pthread.h>
#   include <semaphore.h>

#endif /* __MINIGUI_LIB__ */

#else /* _MGUSE_OWN_PTHREAD */

#include <pthread.h>
#include <semaphore.h>

#endif /* !_MGUSE_OWN_PTHREAD */

#ifdef __DARWIN__

#define _USE_SEM_ON_SYSVIPC     1

#endif

#if defined (_USE_MUTEX_ON_SYSVIPC) || defined (_USE_SEM_ON_SYSVIPC)

int _sysvipc_mutex_sem_init (void);
int _sysvipc_mutex_sem_term (void);

#endif

#ifdef _USE_MUTEX_ON_SYSVIPC

#define pthread_mutex_t _sysvipc_pthread_mutex_t
#define pthread_mutexattr_t _sysvipc_pthread_mutexattr_t

#define pthread_mutexattr_init _sysvipc_pthread_mutexattr_init
#define pthread_mutexattr_destroy _sysvipc_pthread_mutexattr_destroy
#define pthread_mutexattr_settype _sysvipc_pthread_mutexattr_settype
#define pthread_mutexattr_gettype _sysvipc_pthread_mutexattr_gettype

#define pthread_init _sysvipc_pthread_init
#define pthread_mutex_init _sysvipc_pthread_mutex_init
#define pthread_mutex_destroy _sysvipc_pthread_mutex_destroy
#define pthread_mutex_lock _sysvipc_pthread_mutex_lock
#define pthread_mutex_trylock _sysvipc_pthread_mutex_trylock
#define pthread_mutex_unlock _sysvipc_pthread_mutex_unlock

typedef struct
{
    int kind;
    int semid;
    int sem_num;
    int locked_times;
} pthread_mutex_t;

#define SYSVIPC_PTHREAD_MUTEX_FAST_NP         0
#define SYSVIPC_PTHREAD_MUTEX_RECURSIVE_NP    1
#define SYSVIPC_PTHREAD_MUTEX_ERRORCHECK_NP   2

typedef struct
{
    int kind;
} pthread_mutexattr_t;

int pthread_mutexattr_init (pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy (pthread_mutexattr_t *attr);
int pthread_mutexattr_settype (pthread_mutexattr_t *attr, int type);
int pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int* type);

int pthread_mutex_init (pthread_mutex_t *mutex,
                                const pthread_mutexattr_t *mutex_attr);

int pthread_mutex_destroy (pthread_mutex_t *mutex);

int pthread_mutex_lock (pthread_mutex_t *mutex);
int pthread_mutex_trylock (pthread_mutex_t *mutex);
int pthread_mutex_unlock (pthread_mutex_t *mutex);

#endif /* _USE_MUTEX_ON_SYSVIPC */

#ifdef _USE_SEM_ON_SYSVIPC

#define sem_t _sysvipc_sem_t

#define sem_init _sysvipc_sem_init
#define sem_destroy _sysvipc_sem_destroy
#define sem_wait _sysvipc_sem_wait
#define sem_trywait _sysvipc_sem_trywait
#define sem_post _sysvipc_sem_post
#define sem_getvalue _sysvipc_sem_getvalue

#define SYSVIPC_SEM_VALUE_MAX   USHRT_MAX

/*-----------------------------------------------------------------------------
** Semaphore object definition
*/

typedef struct
{
    int semid;
    int sem_num;
} sem_t;

int sem_init (sem_t *sem, int pshared, unsigned int value);
int sem_destroy (sem_t *sem);
int sem_wait (sem_t *sem);
int sem_trywait (sem_t *sem);
int sem_post (sem_t *sem);
int sem_getvalue (sem_t *sem, int *sval);

#endif /* _USE_SEM_ON_SYSVIPC */

#endif /* _MGRM_THREADS */

#ifdef __cplusplus
}  /* end of extern "C" */
#endif

#endif /* _MGUI_COMMON_H */