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_QUEUE_FULL          -1
 
#define ERR_INVALID_HANDLE      -2
 
#define ERR_INV_HWND            ERR_INVALID_HANDLE
 
#define ERR_INVALID_HMENU       ERR_INVALID_HANDLE
 
#define ERR_MSG_CANCELED        -3
 
#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 */