gdi.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: gdi.h 13674 2010-12-06 06:45:01Z wanzheng $
 *
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks,
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 */
 
#ifndef _MGUI_GDI_H
    #define _MGUI_GDI_H
 
#include "common.h"
 
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
 
#include "endianrw.h"
 
#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */
 
extern MG_EXPORT gal_pixel SysPixelIndex [];
 
extern const MG_EXPORT RGB SysPixelColor [];
 
enum {
    IDX_COLOR_transparent = 0,
    IDX_COLOR_darkblue,
    IDX_COLOR_darkgreen,
    IDX_COLOR_darkcyan,
    IDX_COLOR_darkred,
    IDX_COLOR_darkmagenta,
    IDX_COLOR_darkyellow,
    IDX_COLOR_darkgray,
    IDX_COLOR_lightgray,
    IDX_COLOR_blue,
    IDX_COLOR_green,
    IDX_COLOR_cyan,
    IDX_COLOR_red,
    IDX_COLOR_magenta,
    IDX_COLOR_yellow,
    IDX_COLOR_lightwhite,
    IDX_COLOR_black,
};
 
#define PIXEL_invalid       0
 
#define PIXEL_transparent   SysPixelIndex[0]
 
#define PIXEL_darkblue      SysPixelIndex[1]
 
#define PIXEL_darkgreen     SysPixelIndex[2]
 
#define PIXEL_darkcyan      SysPixelIndex[3]
 
#define PIXEL_darkred       SysPixelIndex[4]
 
#define PIXEL_darkmagenta   SysPixelIndex[5]
 
#define PIXEL_darkyellow    SysPixelIndex[6]
 
#define PIXEL_darkgray      SysPixelIndex[7]
 
#define PIXEL_lightgray     SysPixelIndex[8]
 
#define PIXEL_blue          SysPixelIndex[9]
 
#define PIXEL_green         SysPixelIndex[10]
 
#define PIXEL_cyan          SysPixelIndex[11]
 
#define PIXEL_red           SysPixelIndex[12]
 
#define PIXEL_magenta       SysPixelIndex[13]
 
#define PIXEL_yellow        SysPixelIndex[14]
 
#define PIXEL_lightwhite    SysPixelIndex[15]
 
#define PIXEL_black         SysPixelIndex[16]
 
#define COLOR_invalid       PIXEL_invalid
 
#define COLOR_transparent   PIXEL_transparent
 
#define COLOR_darkred       PIXEL_darkred
 
#define COLOR_darkgreen     PIXEL_darkgreen
 
#define COLOR_darkyellow    PIXEL_darkyellow
 
#define COLOR_darkblue      PIXEL_darkblue
 
#define COLOR_darkmagenta   PIXEL_darkmagenta
 
#define COLOR_darkcyan      PIXEL_darkcyan
 
#define COLOR_lightgray     PIXEL_lightgray
 
#define COLOR_darkgray      PIXEL_darkgray
 
#define COLOR_red           PIXEL_red
 
#define COLOR_green         PIXEL_green
 
#define COLOR_yellow        PIXEL_yellow
 
#define COLOR_blue          PIXEL_blue
 
#define COLOR_magenta       PIXEL_magenta
 
#define COLOR_cyan          PIXEL_cyan
 
#define COLOR_lightwhite    PIXEL_lightwhite
 
#define COLOR_black         PIXEL_black
 
#define RGBA_transparent                                \
    (MakeRGBA(SysPixelColor[0].r, SysPixelColor[0].g,   \
              SysPixelColor[0].b, SysPixelColor[0].a))
 
#define RGBA_darkblue                                   \
    (MakeRGBA(SysPixelColor[1].r, SysPixelColor[1].g,   \
              SysPixelColor[1].b, SysPixelColor[1].a))
 
#define RGBA_darkgreen                                  \
    (MakeRGBA(SysPixelColor[2].r, SysPixelColor[2].g,   \
              SysPixelColor[2].b, SysPixelColor[2].a))
 
#define RGBA_darkcyan                                   \
    (MakeRGBA(SysPixelColor[3].r, SysPixelColor[3].g,   \
              SysPixelColor[3].b, SysPixelColor[3].a))
 
#define RGBA_darkred                                    \
    (MakeRGBA(SysPixelColor[4].r, SysPixelColor[4].g,   \
              SysPixelColor[4].b, SysPixelColor[4].a))
 
#define RGBA_darkmagenta                                \
    (MakeRGBA(SysPixelColor[5].r, SysPixelColor[5].g,   \
              SysPixelColor[5].b, SysPixelColor[5].a))
 
#define RGBA_darkyellow                                 \
    (MakeRGBA(SysPixelColor[6].r, SysPixelColor[6].g,   \
              SysPixelColor[6].b, SysPixelColor[6].a))
 
#define RGBA_darkgray                                   \
    (MakeRGBA(SysPixelColor[7].r, SysPixelColor[7].g,   \
              SysPixelColor[7].b, SysPixelColor[7].a))
 
#define RGBA_lightgray                                  \
    (MakeRGBA(SysPixelColor[8].r, SysPixelColor[8].g,   \
              SysPixelColor[8].b, SysPixelColor[8].a))
 
#define RGBA_blue                                       \
    (MakeRGBA(SysPixelColor[9].r, SysPixelColor[9].g,   \
              SysPixelColor[9].b, SysPixelColor[9].a))
 
#define RGBA_green                                      \
    (MakeRGBA(SysPixelColor[10].r, SysPixelColor[10].g, \
              SysPixelColor[10].b, SysPixelColor[10].a))
 
#define RGBA_cyan                                       \
    (MakeRGBA(SysPixelColor[11].r, SysPixelColor[11].g, \
              SysPixelColor[11].b, SysPixelColor[11].a))
 
#define RGBA_red                                        \
    (MakeRGBA(SysPixelColor[12].r, SysPixelColor[12].g, \
              SysPixelColor[12].b, SysPixelColor[12].a))
 
#define RGBA_magenta                                    \
    (MakeRGBA(SysPixelColor[13].r, SysPixelColor[13].g, \
              SysPixelColor[13].b, SysPixelColor[13].a))
 
#define RGBA_yellow                                     \
    (MakeRGBA(SysPixelColor[14].r, SysPixelColor[14].g, \
              SysPixelColor[14].b, SysPixelColor[14].a))
 
#define RGBA_lightwhite                                 \
    (MakeRGBA(SysPixelColor[15].r, SysPixelColor[15].g, \
              SysPixelColor[15].b, SysPixelColor[15].a))
 
#define RGBA_black                                      \
    (MakeRGBA(SysPixelColor[16].r, SysPixelColor[16].g, \
              SysPixelColor[16].b, SysPixelColor[16].a))
 
#define SysColorIndex       SysPixelColor
 
typedef struct _BLOCKHEAP {
#ifdef _MGRM_THREADS
    pthread_mutex_t lock;
#endif
 
    size_t          sz_block;
    size_t          sz_heap;
    size_t          nr_alloc;
    size_t          sz_usage_bmp;
 
    unsigned char*  heap;
    unsigned char*  usage_bmp;
} BLOCKHEAP;
 
typedef BLOCKHEAP* PBLOCKHEAP;
 
MG_EXPORT BOOL InitBlockDataHeap (PBLOCKHEAP heap,
                size_t bd_size, size_t heap_size);
 
MG_EXPORT void* BlockDataAlloc (PBLOCKHEAP heap);
 
MG_EXPORT void BlockDataFree (PBLOCKHEAP heap, void* data);
 
MG_EXPORT void DestroyBlockDataHeap (PBLOCKHEAP heap);
 
struct _BITMAP;
 
typedef struct _BITMAP BITMAP;
 
typedef BITMAP* PBITMAP;
 
struct _MYBITMAP;
 
typedef struct _MYBITMAP MYBITMAP;
 
typedef struct _MYBITMAP* PMYBITMAP;
 
 
typedef struct _CLIPRECT
{
    RECT rc;
    struct _CLIPRECT* next;
    struct _CLIPRECT* prev;
} CLIPRECT;
typedef CLIPRECT* PCLIPRECT;
 
/* Clipping Region */
#define NULLREGION      0x00
#define SIMPLEREGION    0x01
#define COMPLEXREGION   0x02
 
typedef struct _CLIPRGN
{
    BYTE            type;
    BYTE            reserved[3];
    RECT            rcBound;
    PCLIPRECT       head;
    PCLIPRECT       tail;
    PBLOCKHEAP      heap;
} CLIPRGN;
 
typedef CLIPRGN* PCLIPRGN;
 
#define InitFreeClipRectList(heap, size)    \
                InitBlockDataHeap (heap, sizeof (CLIPRECT), size)
 
#define ClipRectAlloc(heap)     BlockDataAlloc (heap)
 
#define FreeClipRect(heap, cr)  BlockDataFree (heap, cr);
 
#define DestroyFreeClipRectList(heap)   DestroyBlockDataHeap (heap);
 
MG_EXPORT void GUIAPI InitClipRgn (PCLIPRGN pRgn, PBLOCKHEAP pFreeList);
 
MG_EXPORT void GUIAPI EmptyClipRgn (PCLIPRGN pRgn);
 
MG_EXPORT PCLIPRGN GUIAPI CreateClipRgn (void);
 
MG_EXPORT void GUIAPI DestroyClipRgn (PCLIPRGN pRgn);
 
MG_EXPORT BOOL GUIAPI ClipRgnCopy (PCLIPRGN pDstRgn, const CLIPRGN* pSrcRgn);
 
MG_EXPORT BOOL GUIAPI ClipRgnIntersect (PCLIPRGN pRstRgn,
                       const CLIPRGN* pRgn1, const CLIPRGN* pRgn2);
 
MG_EXPORT void GUIAPI GetClipRgnBoundRect (PCLIPRGN pRgn, PRECT pRect);
 
MG_EXPORT BOOL GUIAPI SetClipRgn (PCLIPRGN pRgn, const RECT* pRect);
 
MG_EXPORT BOOL GUIAPI IsEmptyClipRgn (const CLIPRGN* pRgn);
 
MG_EXPORT BOOL GUIAPI AddClipRect (PCLIPRGN pRgn, const RECT* pRect);
 
MG_EXPORT BOOL GUIAPI IntersectClipRect (PCLIPRGN pRgn, const RECT* pRect);
 
MG_EXPORT BOOL GUIAPI SubtractClipRect (PCLIPRGN pRgn, const RECT* pRect);
 
MG_EXPORT BOOL GUIAPI PtInRegion (const PCLIPRGN region, int x, int y);
 
MG_EXPORT BOOL GUIAPI RectInRegion (const PCLIPRGN region, const RECT* rect);
 
static inline
BOOL GUIAPI AreRegionsIntersected (const PCLIPRGN s1, const PCLIPRGN s2)
{
    PCLIPRECT crc = s1->head;
    while (crc) {
        if (RectInRegion (s2, &crc->rc))
            return TRUE;
        crc = crc->next;
    }
 
    return FALSE;
}
 
MG_EXPORT void GUIAPI OffsetRegionEx (PCLIPRGN region, const RECT *rcClient,
                            const RECT *rcScroll, int x, int y);
 
MG_EXPORT void GUIAPI OffsetRegion (PCLIPRGN region, int x, int y);
 
MG_EXPORT BOOL GUIAPI UnionRegion (PCLIPRGN dst,
                const CLIPRGN* src1, const CLIPRGN* src2);
 
MG_EXPORT BOOL GUIAPI SubtractRegion (CLIPRGN* rgnD,
                const CLIPRGN* rgnM, const CLIPRGN* rgnS);
 
MG_EXPORT BOOL GUIAPI XorRegion (CLIPRGN *dst,
                const CLIPRGN *src1, const CLIPRGN *src2);
 
#define UnionRectWithRegion     AddClipRect
 
#define CopyRegion              ClipRgnCopy
 
#define IntersectRegion         ClipRgnIntersect
 
MG_EXPORT BOOL GUIAPI InitCircleRegion (PCLIPRGN dst, int x, int y, int r);
 
MG_EXPORT BOOL GUIAPI InitEllipseRegion (PCLIPRGN dst,
                int x, int y, int rx, int ry);
 
MG_EXPORT BOOL GUIAPI InitPolygonRegion (PCLIPRGN dst,
                const POINT* pts, int vertices);
 
#define HDC_SCREEN          ((HDC)0)
 
/*
 * \def HDC_SCREEN_SYS
 * \brief This is a system screen DC created for internal use.
 *
 * Under compositing schema, this DC stands for the surface of the
 * real screen. The compositor running in the server will
 * use this DC to compositing the surfaces created and rendered by
 * the server and the clients to the screen. For clients, this DC
 * essentially is HDC_SCREEN.
 *
 * Under MiniGUI-Standalone runmode, MiniGUI-Threads
 * runmode, and MiniGUI-Processes runmode with shared frame buffer schema,
 * MiniGUI uses it to draw popup menus and other global objects.
 *
 * \sa HDC_SCREEN
 */
#define HDC_SCREEN_SYS      ((HDC)1)
 
#define HDC_INVALID         ((HDC)-1)
 
#define GDCAP_COLORNUM      0
#define GDCAP_HPIXEL        1
#define GDCAP_VPIXEL        2
#define GDCAP_MAXX          3
#define GDCAP_MAXY          4
#define GDCAP_DEPTH         5
#define GDCAP_BPP           6
#define GDCAP_BITSPP        7
#define GDCAP_RMASK         8
#define GDCAP_GMASK         9
#define GDCAP_BMASK         10
#define GDCAP_AMASK         11
#define GDCAP_PITCH         12
#define GDCAP_DPI           13
    #define GDCAP_DPI_DEFAULT   96
    #define GDCAP_DPI_MINIMAL   36
 
MG_EXPORT Uint32 GUIAPI GetGDCapability (HDC hdc, int iItem);
 
MG_EXPORT HDC GUIAPI GetDCEx (HWND hWnd, BOOL bClient);
 
static inline HDC GUIAPI GetDC (HWND hWnd)
{
    return GetDCEx (hWnd, FALSE);
}
 
static inline HDC GUIAPI GetClientDC (HWND hWnd)
{
    return GetDCEx (hWnd, TRUE);
}
 
MG_EXPORT HDC GUIAPI GetSubDC (HDC hdc, int off_x, int off_y, int width, int height);
 
MG_EXPORT void GUIAPI ReleaseDC (HDC hdc);
 
MG_EXPORT HWND GUIAPI WindowFromDC (HDC hdc);
 
MG_EXPORT int GUIAPI SaveDC (HDC hdc);
 
MG_EXPORT BOOL GUIAPI RestoreDC (HDC hdc, int saved_dc);
 
#define MEMDC_FLAG_NONE             0x00000000  /* None. */
#define MEMDC_FLAG_SWSURFACE        0x00000000  /* DC is in system memory */
#define MEMDC_FLAG_HWSURFACE        0x00000001  /* DC is in video memory */
#define MEMDC_FLAG_SRCCOLORKEY      0x00001000  /* Blit uses a source color key */
#define MEMDC_FLAG_SRCALPHA         0x00010000  /* Blit uses source alpha blending*/
#define MEMDC_FLAG_SRCPIXELALPHA    0x00020000  /* Blit uses source per-pixel alpha blending*/
#define MEMDC_FLAG_RLEACCEL         0x00004000  /* Surface is RLE encoded */
 
MG_EXPORT HDC GUIAPI CreateCompatibleDCEx (HDC hdc, int width, int height);
 
MG_EXPORT BOOL GUIAPI IsCompatibleDC (HDC hdc1, HDC hdc2);
 
MG_EXPORT BOOL GUIAPI IsMemDC (HDC hdc);
 
MG_EXPORT BOOL GUIAPI IsScreenDC (HDC hdc);
 
MG_EXPORT BOOL GUIAPI IsWindowDC (HDC hdc);
 
MG_EXPORT HDC GUIAPI CreateMemDCEx (int width, int height, int depth, DWORD flags,
        Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask,
        void* bits, int pitch);
 
static inline HDC GUIAPI CreateMemDC (int width, int height, int depth, DWORD flags,
        Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
{
    return CreateMemDCEx (width, height, depth, flags, Rmask, Gmask, Bmask, Amask,
            NULL, 0);
}
 
MG_EXPORT HDC GUIAPI CreateSubMemDC (HDC parent, int off_x, int off_y,
                int width, int height, BOOL comp_to_parent);
 
MG_EXPORT HDC GUIAPI CreateMemDCFromBitmap (HDC hdc, const BITMAP* bmp);
 
MG_EXPORT HDC GUIAPI CreateMemDCFromMyBitmap (const MYBITMAP* my_bmp, const RGB* pal);
 
MG_EXPORT BOOL GUIAPI ConvertMemDC (HDC mem_dc, HDC ref_dc, DWORD flags);
 
MG_EXPORT BOOL GUIAPI SetMemDCAlpha (HDC mem_dc, DWORD flags, Uint8 alpha);
 
MG_EXPORT BOOL GUIAPI SetMemDCColorKey (HDC mem_dc, DWORD flags,
                Uint32 color_key);
 
MG_EXPORT void GUIAPI DeleteMemDC (HDC mem_dc);
 
#define CreateCompatibleDC(hdc) CreateCompatibleDCEx(hdc, 0, 0)
 
#define DeleteCompatibleDC(hdc) DeleteMemDC(hdc)
 
MG_EXPORT Uint8* GUIAPI LockDC (HDC hdc, const RECT* rw_rc,
                int* width, int* height, int* pitch);
 
typedef void (* CB_DIRECT_DRAW_RECT) (HDC hdc, Uint8 * pixels,
        int pitch, int bytesPerPixel, const RECT* rc, void* context);
 
MG_EXPORT BOOL GUIAPI LockDCEx (HDC hdc, const PCLIPRGN region,
        void* context, CB_DIRECT_DRAW_RECT cb);
 
MG_EXPORT void GUIAPI UnlockDC (HDC hdc);
 
MG_EXPORT HDC GUIAPI CreatePrivateDC (HWND hwnd);
 
MG_EXPORT HDC GUIAPI CreatePrivateClientDC (HWND hwnd);
 
HDC GUIAPI CreatePrivateSubDC(HDC hdc, int off_x, int off_y,
        int width, int height);
 
MG_EXPORT HDC GUIAPI GetPrivateClientDC (HWND hwnd);
 
MG_EXPORT void GUIAPI DeletePrivateDC (HDC hdc);
 
MG_EXPORT HDC GUIAPI CreateSecondaryDC (HWND hwnd);
 
typedef int (* ON_UPDATE_SECONDARYDC)(HWND hwnd, HDC secondary_dc,
        HDC real_dc, const RECT* secondary_rc, const RECT* real_rc,
        const RECT* main_update_rc);
 
#define ON_UPDSECDC_DEFAULT     ((ON_UPDATE_SECONDARYDC)0)
#define ON_UPDSECDC_DONOTHING   ((ON_UPDATE_SECONDARYDC)-1)
 
MG_EXPORT HDC GUIAPI SetSecondaryDC (HWND hwnd, HDC secondary_dc,
        ON_UPDATE_SECONDARYDC on_update_secondarydc);
 
MG_EXPORT HDC GUIAPI GetSecondaryDC (HWND hwnd);
 
MG_EXPORT HDC GUIAPI GetDCInSecondarySurface (HWND hWnd, BOOL bClient);
 
static inline HDC GUIAPI GetSecondaryClientDC (HWND hwnd)
{
    return GetDCInSecondarySurface (hwnd, TRUE);
}
 
static inline void GUIAPI ReleaseSecondaryDC (HWND hwnd, HDC hdc)
{
    ReleaseDC (hdc);
}
 
MG_EXPORT void GUIAPI DeleteSecondaryDC (HWND hwnd);
 
MG_EXPORT HDC GUIAPI GetEffectiveCDC (HWND hwnd);
 
MG_EXPORT BOOL GUIAPI SyncUpdateDC (HDC hdc);
 
MG_EXPORT BOOL GUIAPI SyncUpdateSurface (HWND hwnd);
 
#define BM_TRANSPARENT          1
#define BM_OPAQUE               0
 
#define DC_ATTR_BK_COLOR        0
#define DC_ATTR_PEN_COLOR       1
#define DC_ATTR_BRUSH_COLOR     2
#define DC_ATTR_TEXT_COLOR      3
 
#define DC_ATTR_BK_MODE         4
 
#define DC_ATTR_TAB_STOP        5
#define DC_ATTR_CHAR_EXTRA      6
#define DC_ATTR_WORD_EXTRA      7
#define DC_ATTR_ALINE_EXTRA     8
#define DC_ATTR_BLINE_EXTRA     9
 
#define DC_ATTR_MAP_MODE        10
 
#define DC_ATTR_TEXT_ALIGN      11
 
#define DC_ATTR_BIDI_FLAGS      12
 
#ifdef _MGHAVE_ADV_2DAPI
# define DC_ATTR_PEN_TYPE        13
# define DC_ATTR_PEN_CAP_STYLE   14
# define DC_ATTR_PEN_JOIN_STYLE  15
# define DC_ATTR_PEN_WIDTH       16
# define DC_ATTR_BRUSH_TYPE      17
# define NR_DC_ATTRS             18
#else   /* _MGHAVE_ADV_2DAPI */
# define NR_DC_ATTRS             13
#endif  /* !_MGHAVE_ADV_2DAPI */
 
 
MG_EXPORT Uint32 GUIAPI GetDCAttr (HDC hdc, int attr);
 
MG_EXPORT Uint32 GUIAPI SetDCAttr (HDC hdc, int attr, Uint32 value);
 
#define GetBkColor(hdc)     GetDCAttr (hdc, DC_ATTR_BK_COLOR)
 
#define GetBkMode(hdc)      GetDCAttr (hdc, DC_ATTR_BK_MODE)
 
#define GetPenColor(hdc)    GetDCAttr (hdc, DC_ATTR_PEN_COLOR)
 
#define GetBrushColor(hdc)  GetDCAttr (hdc, DC_ATTR_BRUSH_COLOR)
 
#define GetTextColor(hdc)   GetDCAttr (hdc, DC_ATTR_TEXT_COLOR)
 
#define GetTabStop(hdc)     GetDCAttr (hdc, DC_ATTR_TAB_STOP)
 
#define SetBkColor(hdc, color)  \
                SetDCAttr (hdc, DC_ATTR_BK_COLOR, (DWORD) color)
 
#define SetBkMode(hdc, mode)    \
                SetDCAttr (hdc, DC_ATTR_BK_MODE, (DWORD) mode)
 
#define SetPenColor(hdc, color) \
                SetDCAttr (hdc, DC_ATTR_PEN_COLOR, (DWORD) color)
 
#define SetBrushColor(hdc, color)   \
                SetDCAttr (hdc, DC_ATTR_BRUSH_COLOR, (DWORD) color)
 
#define SetTextColor(hdc, color)    \
                SetDCAttr (hdc, DC_ATTR_TEXT_COLOR, (DWORD) color)
 
#define SetTabStop(hdc, value)  \
                SetDCAttr (hdc, DC_ATTR_TAB_STOP, (DWORD) value)
 
#define ROP_SET         0
#define ROP_AND         1
#define ROP_OR          2
#define ROP_XOR         3
#define ROP_COMPOSITE   4
#define ROP_COMP_USER   0x0100
/* Reserved for future
 * #define ROP_COMP_XXX    0x01XX
 */
 
MG_EXPORT int GUIAPI GetRasterOperation (HDC hdc);
 
MG_EXPORT int GUIAPI SetRasterOperation (HDC hdc, int rop);
 
MG_EXPORT int GUIAPI GetPalette (HDC hdc, int start, int len, GAL_Color* cmap);
 
MG_EXPORT BOOL GUIAPI SetPalette (HDC hdc, int start, int len, GAL_Color* cmap);
 
MG_EXPORT BOOL GUIAPI SetColorfulPalette (HDC hdc);
 
MG_EXPORT HPALETTE GUIAPI CreatePalette (GAL_Palette* pal);
 
MG_EXPORT BOOL GUIAPI SelectPalette (HDC hdc, HPALETTE hpal, BOOL reserved);
 
MG_EXPORT BOOL GUIAPI RealizePalette (HDC hdc);
 
MG_EXPORT BOOL GUIAPI ResizePalette (HPALETTE hpal, int len);
 
MG_EXPORT void GUIAPI DestroyPalette (HPALETTE hpal);
 
MG_EXPORT HPALETTE GUIAPI GetDefaultPalette (void);
 
MG_EXPORT int GUIAPI GetPaletteEntries (HPALETTE hpal,
                int start, int len, GAL_Color* cmap);
 
MG_EXPORT int GUIAPI SetPaletteEntries (HPALETTE hpal,
                int start, int len, GAL_Color* cmap);
 
MG_EXPORT UINT GUIAPI GetNearestPaletteIndex (HPALETTE hpal,
                Uint8 red, Uint8 green, Uint8 blue);
 
MG_EXPORT RGBCOLOR GUIAPI GetNearestColor (HDC hdc,
                Uint8 red, Uint8 green, Uint8 blue);
 
MG_EXPORT void GUIAPI SetPixel (HDC hdc, int x, int y, gal_pixel pixel);
 
MG_EXPORT gal_pixel GUIAPI SetPixelRGB (HDC hdc, int x, int y,
                Uint8 r, Uint8 g, Uint8 b);
 
MG_EXPORT gal_pixel GUIAPI SetPixelRGBA (HDC hdc, int x, int y,
                Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
MG_EXPORT gal_pixel GUIAPI GetPixel (HDC hdc, int x, int y);
 
MG_EXPORT gal_pixel GUIAPI GetPixelRGB (HDC hdc, int x, int y,
                Uint8* r, Uint8* g, Uint8* b);
 
MG_EXPORT gal_pixel GUIAPI GetPixelRGBA (HDC hdc, int x, int y,
                Uint8* r, Uint8* g, Uint8* b, Uint8* a);
 
MG_EXPORT void GUIAPI RGBA2Pixels (HDC hdc, const RGB* rgbs,
                gal_pixel* pixels, int count);
 
static inline gal_pixel RGBA2Pixel (HDC hdc,
                Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
    RGB rgb = {r, g, b, a};
    gal_pixel pixel;
 
    RGBA2Pixels (hdc, &rgb, &pixel, 1);
    return pixel;
}
 
MG_EXPORT void GUIAPI RGB2Pixels (HDC hdc, const RGB* rgbs,
                gal_pixel* pixels, int count);
 
static inline gal_pixel RGB2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b)
{
    RGB rgb = {r, g, b, 0xFF};
    gal_pixel pixel;
 
    RGB2Pixels (hdc, &rgb, &pixel, 1);
    return pixel;
}
 
MG_EXPORT void GUIAPI Pixel2RGBs (HDC hdc, const gal_pixel* pixels,
                RGB* rgbs, int count);
 
static inline void Pixel2RGB (HDC hdc, gal_pixel pixel,
                Uint8* r, Uint8* g, Uint8* b)
{
    RGB rgb;
    Pixel2RGBs (hdc, &pixel, &rgb, 1);
    *r = rgb.r; *g = rgb.g, *b = rgb.b;
}
 
MG_EXPORT void GUIAPI Pixel2RGBAs (HDC hdc, const gal_pixel* pixels,
                RGB* rgbs, int count);
 
static inline void Pixel2RGBA (HDC hdc, gal_pixel pixel,
                Uint8* r, Uint8* g, Uint8* b, Uint8* a)
{
    RGB rgb;
    Pixel2RGBAs (hdc, &pixel, &rgb, 1);
    *r = rgb.r; *g = rgb.g, *b = rgb.b; *a = rgb.a;
}
 
static inline DWORD Pixel2DWORD (HDC hdc, gal_pixel pixel)
{
    Uint8 r,g,b,a;
    Pixel2RGBA (hdc, pixel, &r, &g, &b, &a);
    return MakeRGBA (r, g, b, a);
}
 
#define PIXEL2DWORD(hdc, pixel) Pixel2DWORD(hdc, pixel)
 
static inline gal_pixel DWORD2Pixel (HDC hdc, DWORD dword)
{
    return RGBA2Pixel (hdc,
            GetRValue(dword), GetGValue(dword),
            GetBValue(dword), GetAValue(dword));
}
 
MG_EXPORT void GUIAPI FocusRect (HDC hdc, int x0, int y0, int x1, int y1);
 
MG_EXPORT void GUIAPI DrawHVDotLine (HDC hdc, int x, int y, int w_h, BOOL H_V);
 
#define DrawHDotLine(hdc, x, y, w) DrawHVDotLine (hdc, x, y, w, TRUE);
 
#define DrawVDotLine(hdc, x, y, h) DrawHVDotLine (hdc, x, y, h, FALSE);
 
MG_EXPORT BOOL GUIAPI LineClipper (const RECT* cliprc,
                int *_x0, int *_y0, int *_x1, int *_y1);
 
typedef void (* CB_LINE) (void* context, int stepx, int stepy);
 
MG_EXPORT void GUIAPI LineGenerator (void* context,
                int x1, int y1, int x2, int y2, CB_LINE cb);
 
typedef void (* CB_CIRCLE) (void* context, int x1, int x2, int y);
 
MG_EXPORT void GUIAPI CircleGenerator (void* context,
                int sx, int sy, int r, CB_CIRCLE cb);
 
typedef void (* CB_ELLIPSE) (void* context, int x1, int x2, int y);
 
MG_EXPORT void GUIAPI EllipseGenerator (void* context,
                int sx, int sy, int rx, int ry, CB_ELLIPSE cb);
 
typedef void (* CB_ARC) (void* context, int x, int y);
 
MG_EXPORT void GUIAPI CircleArcGenerator (void* context,
                int sx, int sy, int r, int ang1, int ang2, CB_ARC cb);
 
typedef void (* CB_POLYGON) (void* context, int x1, int x2, int y);
 
MG_EXPORT BOOL GUIAPI MonotoneVerticalPolygonGenerator (void* context,
                const POINT* pts, int vertices, CB_POLYGON cb);
 
MG_EXPORT BOOL GUIAPI PolygonIsMonotoneVertical (const POINT* pts,
                int vertices);
 
MG_EXPORT BOOL GUIAPI PolygonGeneratorEx (void* context,
                const POINT* pts, int vertices, CB_POLYGON cb, RECT* rc_output);
#define PolygonGenerator(context, pts, vertices, cb)          \
                PolygonGeneratorEx(context, pts, vertices, cb, NULL)
 
typedef BOOL (* CB_EQUAL_PIXEL) (void* context, int x, int y);
 
typedef void (* CB_FLOOD_FILL) (void* context, int x1, int x2, int y);
 
MG_EXPORT BOOL GUIAPI FloodFillGenerator (void* context,
                const RECT* src_rc, int x, int y,
                CB_EQUAL_PIXEL cb_equal_pixel, CB_FLOOD_FILL cb_flood_fill);
 
/* DDA algorithm */
#define BITMAP_SCALER_DDA       0
/* Bilinear interpolation algorithm */
#define BITMAP_SCALER_BILINEAR  1
 
MG_EXPORT int GUIAPI SetBitmapScalerType (HDC hdc, int scaler_type);
 
MG_EXPORT void GUIAPI MoveTo (HDC hdc, int x, int y);
 
MG_EXPORT void GUIAPI LineTo (HDC hdc, int x, int y);
 
MG_EXPORT void GUIAPI Rectangle (HDC hdc, int x0, int y0, int x1, int y1);
 
MG_EXPORT void GUIAPI PolyLineTo (HDC hdc, const POINT* pts, int vertices);
 
MG_EXPORT void GUIAPI SplineTo (HDC hdc, const POINT* pts);
 
MG_EXPORT void GUIAPI Circle (HDC hdc, int sx, int sy, int r);
 
MG_EXPORT void GUIAPI Ellipse (HDC hdc, int sx, int sy, int rx, int ry);
 
MG_EXPORT void GUIAPI CircleArc (HDC hdc, int sx, int sy, int r,
                int ang1, int ang2);
 
MG_EXPORT void GUIAPI FillBox (HDC hdc, int x, int y, int w, int h);
 
MG_EXPORT void GUIAPI FillCircle (HDC hdc, int sx, int sy, int r);
 
MG_EXPORT void GUIAPI FillEllipse (HDC hdc, int sx, int sy, int rx, int ry);
 
MG_EXPORT BOOL GUIAPI FillPolygon (HDC hdc, const POINT* pts, int vertices);
 
MG_EXPORT BOOL GUIAPI FloodFill (HDC hdc, int x, int y);
 
#ifdef _MGHAVE_ADV_2DAPI
 
typedef enum
{
  PT_SOLID,
  PT_ON_OFF_DASH,
  PT_DOUBLE_DASH,
} PenType;
 
#define GetPenType(hdc)                 \
                GetDCAttr (hdc, DC_ATTR_PEN_TYPE)
 
#define SetPenType(hdc, type)           \
                SetDCAttr (hdc, DC_ATTR_PEN_TYPE, (DWORD) type)
 
MG_EXPORT void GUIAPI SetPenDashes (HDC hdc, int dash_offset,
                const unsigned char* dash_list, int n);
 
typedef enum
{
  PT_CAP_BUTT,
  PT_CAP_ROUND,
  PT_CAP_PROJECTING
} PTCapStyle;
 
#define GetPenCapStyle(hdc)                 \
                GetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE)
 
#define SetPenCapStyle(hdc, style)          \
            SetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE, (DWORD) style)
 
typedef enum
{
  PT_JOIN_MITER,
  PT_JOIN_ROUND,
  PT_JOIN_BEVEL
} PTJoinStyle;
 
#define GetPenJoinStyle(hdc)           GetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE)
 
#define SetPenJoinStyle(hdc, style)         \
            SetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE, (DWORD) style)
 
#define GetPenWidth(hdc)                    \
                GetDCAttr (hdc, DC_ATTR_PEN_WIDTH)
 
#define SetPenWidth(hdc, width)             \
                SetDCAttr (hdc, DC_ATTR_PEN_WIDTH, (DWORD) width)
 
typedef enum {
  BT_SOLID,
  BT_TILED,
  BT_STIPPLED,
  BT_OPAQUE_STIPPLED
} BrushType;
 
#define GetBrushType(hdc)               \
                GetDCAttr (hdc, DC_ATTR_BRUSH_TYPE)
 
#define SetBrushType(hdc, type)         \
                SetDCAttr (hdc, DC_ATTR_BRUSH_TYPE, (DWORD) type)
 
typedef struct _STIPPLE
{
    int width;
    int height;
 
    int pitch;
 
    size_t size;
 
    const unsigned char* bits;
} STIPPLE;
 
MG_EXPORT void GUIAPI SetBrushInfo (HDC hdc,
                const BITMAP* tile, const STIPPLE* stipple);
 
MG_EXPORT void GUIAPI SetBrushOrigin (HDC hdc, int x, int y);
 
MG_EXPORT void GUIAPI LineEx (HDC hdc, int x1, int y1, int x2, int y2);
 
MG_EXPORT void GUIAPI ArcEx (HDC hdc, int x, int y, int width, int height,
                int ang1, int ang2);
 
MG_EXPORT void GUIAPI FillArcEx (HDC hdc, int x, int y, int width, int height,
                int ang1, int ang2);
 
MG_EXPORT void GUIAPI PolyLineEx (HDC hdc, const POINT* pts, int nr_pts);
 
typedef struct _ARC
{
    int x;
    int y;
 
    int width;
    int height;
 
    int angle1;
    int angle2;
} ARC;
 
MG_EXPORT void GUIAPI PolyArcEx (HDC hdc, const ARC* arcs, int nr_arcs);
 
MG_EXPORT void GUIAPI PolyFillArcEx (HDC hdc, const ARC* arcs, int nr_arcs);
 
MG_EXPORT BOOL GUIAPI RoundRect (HDC hdc, int x0, int y0, int x1, int y1, int cw, int ch);
 
#endif
 
#define MM_TEXT               0
#define MM_ANISOTROPIC        1
 
#define GetMapMode(hdc)         GetDCAttr (hdc, DC_ATTR_MAP_MODE)
 
#define SetMapMode(hdc, mapmode)        \
                SetDCAttr (hdc, DC_ATTR_MAP_MODE, (DWORD)mapmode)
 
MG_EXPORT void GUIAPI GetDCLCS (HDC hdc, int which, POINT* pt);
 
MG_EXPORT void GUIAPI SetDCLCS (HDC hdc, int which, const POINT* pt);
 
#define DC_LCS_VORG     0
#define DC_LCS_VEXT     1
#define DC_LCS_WORG     2
#define DC_LCS_WEXT     3
#define NR_DC_LCS_PTS   4
 
#define GetViewportOrg(hdc, pPt)    GetDCLCS(hdc, DC_LCS_VORG, pPt)
 
#define GetViewportExt(hdc, pPt)    GetDCLCS(hdc, DC_LCS_VEXT, pPt)
 
#define GetWindowOrg(hdc, pPt)      GetDCLCS(hdc, DC_LCS_WORG, pPt)
 
#define GetWindowExt(hdc, pPt)      GetDCLCS(hdc, DC_LCS_WEXT, pPt)
 
#define SetViewportOrg(hdc, pPt)    SetDCLCS(hdc, DC_LCS_VORG, pPt)
 
#define SetViewportExt(hdc, pPt)    SetDCLCS(hdc, DC_LCS_VEXT, pPt)
 
#define SetWindowOrg(hdc, pPt)      SetDCLCS(hdc, DC_LCS_WORG, pPt)
 
#define SetWindowExt(hdc, pPt)      SetDCLCS(hdc, DC_LCS_WEXT, pPt)
 
MG_EXPORT void GUIAPI DPtoLP (HDC hdc, POINT* pPt);
 
 
MG_EXPORT void GUIAPI LPtoDP (HDC hdc, POINT* pPt);
 
MG_EXPORT void GUIAPI SPtoLP(HDC hdc, POINT* pPt);
 
 
MG_EXPORT void GUIAPI LPtoSP(HDC hdc, POINT* pPt);
 
MG_EXPORT void GUIAPI ExcludeClipRect (HDC hdc, const RECT* prc);
 
MG_EXPORT void GUIAPI IncludeClipRect (HDC hdc, const RECT* prc);
 
MG_EXPORT BOOL GUIAPI PtVisible (HDC hdc, int x, int y);
 
MG_EXPORT void GUIAPI ClipRectIntersect (HDC hdc, const RECT* prc);
 
MG_EXPORT void GUIAPI SelectClipRect (HDC hdc, const RECT* prc);
 
#define RGN_COPY        0x00
#define RGN_DIFF        0x01
#define RGN_AND         0x02
#define RGN_OR          0x03
#define RGN_XOR         0x04
 
MG_EXPORT int GUIAPI SelectClipRegionEx (HDC hdc, const CLIPRGN* pRgn,
                int fnMode);
 
MG_EXPORT void GUIAPI SelectClipRegion (HDC hdc, const CLIPRGN* pRgn);
 
MG_EXPORT int GUIAPI OffsetClipRegion (HDC hdc, int nXOffset, int nYOffset);
 
MG_EXPORT void GUIAPI GetBoundsRect (HDC hdc, RECT* pRect);
 
MG_EXPORT BOOL GUIAPI RectVisible (HDC hdc, const RECT* pRect);
 
MG_EXPORT int GUIAPI GetClipBox (HDC hdc, RECT* clipbox);
 
MG_EXPORT int GUIAPI GetClipRegion (HDC hdc, CLIPRGN* cliprgn);
 
MG_EXPORT BOOL GUIAPI GetBitmapFromDC (HDC hdc,
                int x, int y, int w, int h, BITMAP* bmp);
 
MG_EXPORT BOOL GUIAPI FillBoxWithBitmap (HDC hdc, int x, int y, int w, int h,
                const BITMAP *bmp);
 
MG_EXPORT BOOL GUIAPI FillBoxWithBitmapPart (HDC hdc,
                int x, int y, int w, int h,
                int bw, int bh, const BITMAP* bmp, int xo, int yo);
 
MG_EXPORT BOOL GUIAPI FillBitmapPartInBox (HDC hdc, int box_x, int box_y,
                int box_w, int box_h, const BITMAP* pbmp, int bmp_x, int bmp_y,
                int bmp_w, int bmp_h);
 
typedef enum {
    COLOR_BLEND_LEGACY      = 0,
    COLOR_BLEND_FLAGS_MASK  = 0x00FF,
 
    COLOR_BLEND_PD_CLEAR    = 0x0100,   // PIXMAN_OP_CLEAR          = 0x00
    COLOR_BLEND_PD_SRC      = 0x0101,   // PIXMAN_OP_SRC            = 0x01
    COLOR_BLEND_PD_DST      = 0x0102,   // PIXMAN_OP_DST            = 0x02
    COLOR_BLEND_PD_SRC_OVER = 0x0103,   // PIXMAN_OP_OVER           = 0x03
    COLOR_BLEND_PD_DST_OVER = 0x0104,   // PIXMAN_OP_OVER_REVERSE   = 0x04
    COLOR_BLEND_PD_SRC_IN   = 0x0105,   // PIXMAN_OP_IN             = 0x05
    COLOR_BLEND_PD_DST_IN   = 0x0106,   // PIXMAN_OP_IN_REVERSE     = 0x06
    COLOR_BLEND_PD_SRC_OUT  = 0x0107,   // PIXMAN_OP_OUT            = 0x07
    COLOR_BLEND_PD_DST_OUT  = 0x0108,   // PIXMAN_OP_OUT_REVERSE    = 0x08
    COLOR_BLEND_PD_SRC_ATOP = 0x0109,   // PIXMAN_OP_ATOP           = 0x09
    COLOR_BLEND_PD_DST_ATOP = 0x010a,   // PIXMAN_OP_ATOP_REVERSE   = 0x0a
    COLOR_BLEND_PD_XOR      = 0x010b,   // PIXMAN_OP_XOR            = 0x0b
    COLOR_BLEND_PD_PLUS     = 0x010c,   // PIXMAN_OP_ADD            = 0x0c
    COLOR_BLEND_PD_MODULATE = 0x010d,   // PIXMAN_OP_SATURATE       = 0x0d
 
    COLOR_BLEND_PD_FLAG     = 0x0100,
    COLOR_BLEND_PD_FIRST    = COLOR_BLEND_PD_CLEAR,
    COLOR_BLEND_PD_LAST     = COLOR_BLEND_PD_MODULATE,
 
    COLOR_BLEND_SP_NORMAL       = 0x0801,
    COLOR_BLEND_SP_MULTIPLY     = 0x0830,   // PIXMAN_OP_MULTIPLY       = 0x30
    COLOR_BLEND_SP_SCREEN       = 0x0831,   // PIXMAN_OP_SCREEN         = 0x31
    COLOR_BLEND_SP_OVERLAY      = 0x0832,   // PIXMAN_OP_OVERLAY        = 0x32
    COLOR_BLEND_SP_DARKEN       = 0x0833,   // PIXMAN_OP_DARKEN         = 0x33
    COLOR_BLEND_SP_LIGHTEN      = 0x0834,   // PIXMAN_OP_LIGHTEN        = 0x34
    COLOR_BLEND_SP_COLOR_DODGE  = 0x0835,    // PIXMAN_OP_COLOR_DODGE   = 0x35,
    COLOR_BLEND_SP_COLOR_BURN   = 0x0836,   // PIXMAN_OP_COLOR_BURN     = 0x36,
    COLOR_BLEND_SP_HARD_LIGHT   = 0x0837,   // PIXMAN_OP_HARD_LIGHT     = 0x37,
    COLOR_BLEND_SP_SOFT_LIGHT   = 0x0838,   // PIXMAN_OP_SOFT_LIGHT     = 0x38
    COLOR_BLEND_SP_DIFFERENCE   = 0x0839,   // PIXMAN_OP_DIFFERENCE     = 0x39
    COLOR_BLEND_SP_EXCLUSION    = 0x083a,   // PIXMAN_OP_EXCLUSION      = 0x3a
 
    COLOR_BLEND_SP_FLAG         = 0x0800,
    COLOR_BLEND_SP_FIRST        = COLOR_BLEND_SP_NORMAL,
    COLOR_BLEND_SP_LAST         = COLOR_BLEND_SP_EXCLUSION,
 
    COLOR_BLEND_NS_HUE          = 0x103b,   // PIXMAN_OP_HSL_HUE        = 0x3b
    COLOR_BLEND_NS_SATURATION   = 0x103c,   // PIXMAN_OP_HSL_SATURATION = 0x3c
    COLOR_BLEND_NS_COLOR        = 0x103d,   // PIXMAN_OP_HSL_COLOR      = 0x3d
 
    COLOR_BLEND_NS_LUMINOSITY   = 0x103e,  // PIXMAN_OP_HSL_LUMINOSITY  = 0x3e
 
    COLOR_BLEND_NS_FLAG         = 0x1000,
    COLOR_BLEND_NS_FIRST        = COLOR_BLEND_NS_HUE,
    COLOR_BLEND_NS_LAST         = COLOR_BLEND_NS_LUMINOSITY,
 
    COLOR_BLEND_FIRST        = COLOR_BLEND_PD_CLEAR,
    COLOR_BLEND_LAST         = COLOR_BLEND_NS_LAST,
} ColorBlendMethod;
 
typedef enum {
   COLOR_LOGICOP_CLEAR = 0,
   COLOR_LOGICOP_NOR,
   COLOR_LOGICOP_AND_INVERTED,
   COLOR_LOGICOP_COPY_INVERTED,
   COLOR_LOGICOP_AND_REVERSE,
   COLOR_LOGICOP_INVERT,
   COLOR_LOGICOP_XOR,
   COLOR_LOGICOP_NAND,
   COLOR_LOGICOP_AND,
   COLOR_LOGICOP_EQUIV,
   COLOR_LOGICOP_NOOP0,
   COLOR_LOGICOP_OR_INVERTED1,
   COLOR_LOGICOP_COPY,
   COLOR_LOGICOP_OR_REVERSE,
   COLOR_LOGICOP_OR,
   COLOR_LOGICOP_SET,
} ColorLogicalOp;
 
MG_EXPORT void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh,
                HDC hddc, int dx, int dy, DWORD dwRop);
 
typedef enum {
    SCALING_FILTER_FAST     = 0x00000000,
    SCALING_FILTER_GOOD     = 0x00010000,
    SCALING_FILTER_BEST     = 0x00020000,
    SCALING_FILTER_NEAREST  = 0x00020000,
    SCALING_FILTER_BILINEAR = 0x00040000,
    SCALING_FILTER_CONVOLUTION = 0x00050000,
    SCALING_FILTER_SHIFT    = 16,
} ScalingFilter;
 
typedef struct _STRETCH_EXTRA_INFO {
    int version;
 
    int rotation;
 
    int cx;
    int cy;
} STRETCH_EXTRA_INFO;
 
MG_EXPORT BOOL GUIAPI StretchBltEx (HDC hsdc, int sx, int sy, int sw, int sh,
        HDC hddc, int dx, int dy, int dw, int dh,
        const STRETCH_EXTRA_INFO *sei, DWORD dwRop);
 
static inline void GUIAPI StretchBlt (HDC hsdc, int sx, int sy, int sw, int sh,
        HDC hddc, int dx, int dy, int dw, int dh, DWORD dwRop)
{
    StretchBltEx (hsdc, sx, sy, sw, sh, hddc, dx, dy, dw, dh, NULL, dwRop);
}
 
/* Use this if you want to have the legacy manner of StretchBlt */
MG_EXPORT void GUIAPI StretchBltLegacy (HDC hsdc, int sx, int sy, int sw, int sh,
                       HDC hddc, int dx, int dy, int dw, int dh, DWORD dwRop);
 
MG_EXPORT BOOL GUIAPI ScaleBitmapEx (BITMAP* dst, const BITMAP* src,
        HDC ref_dc);
 
#define ScaleBitmap(dst, src) ScaleBitmapEx(dst, src, HDC_SCREEN)
 
MG_EXPORT gal_pixel GUIAPI GetPixelInBitmapEx (const BITMAP* bmp, int x, int y, Uint8* alpha);
 
static inline gal_pixel GUIAPI GetPixelInBitmap (const BITMAP* bmp, int x, int y)
{
    return GetPixelInBitmapEx (bmp, x, y, NULL);
}
 
MG_EXPORT BOOL GUIAPI SetPixelInBitmapEx (const BITMAP* bmp,
                int x, int y, gal_pixel pixel, const Uint8* alpha);
 
static inline BOOL GUIAPI SetPixelInBitmap (const BITMAP* bmp,
        int x, int y, gal_pixel pixel)
{
    return SetPixelInBitmapEx (bmp, x, y, pixel, NULL);
}
 
#ifdef _MGMISC_SAVESCREEN
 
MG_EXPORT BOOL GUIAPI SaveScreenRectContent (const RECT* rcWin,
                const char* filename);
 
MG_EXPORT BOOL GUIAPI SaveMainWindowContent (HWND hWnd, const char* filename);
#endif
 
MG_EXPORT HICON GUIAPI LoadIconFromFile (HDC hdc, const char* filename,
                int which);
 
MG_EXPORT HICON GUIAPI LoadIconFromMem (HDC hdc, const void* area, int which);
 
MG_EXPORT HICON GUIAPI CreateIconEx (HDC hdc, int w, int h,
                const BYTE* AndBits, const BYTE* XorBits, int colornum,
                const RGB* pal);
#define CreateIcon(hdc, w, h, AndBits, XorBits, colornum) \
        CreateIconEx(hdc, w, h, AndBits, XorBits, colornum, NULL)
 
MG_EXPORT HICON GUIAPI LoadBitmapIconEx (HDC hdc, MG_RWops* area,
        const char* ext);
 
MG_EXPORT HICON GUIAPI LoadBitmapIconFromFile (HDC hdc,
        const char* file_name);
 
MG_EXPORT HICON GUIAPI LoadBitmapIconFromMem (HDC hdc,
        const void* mem, size_t size, const char* ext);
 
MG_EXPORT BOOL GUIAPI DestroyIcon (HICON hicon);
 
MG_EXPORT BOOL GUIAPI GetIconSize (HICON hicon, int* w, int* h);
 
MG_EXPORT void GUIAPI DrawIcon (HDC hdc,
                int x, int y, int w, int h, HICON hicon);
 
static inline void SetRect (RECT* prc, int left, int top, int right, int bottom)
{
    (prc)->left = left; (prc)->top = top;
    (prc)->right = right; (prc)->bottom = bottom;
}
 
static inline void SetRectEmpty (RECT* prc)
{
    (prc)->left = (prc)->top = (prc)->right = (prc)->bottom = 0;
}
 
static inline void CopyRect (RECT* pdrc, const RECT* psrc)
{
    (pdrc)->left = (psrc)->left; (pdrc)->top = (psrc)->top;
    (pdrc)->right = (psrc)->right; (pdrc)->bottom = (psrc)->bottom;
}
 
static inline void OffsetRect (RECT* prc, int x, int y)
{
    (prc)->left += x; (prc)->top += y; (prc)->right += x; (prc)->bottom += y;
}
 
static inline void InflateRect (RECT* prc, int cx, int cy)
{
    (prc)->left -= cx; (prc)->top -= cy;
    (prc)->right += cx; (prc)->bottom += cy;
}
 
static inline void InflateRectToPt (RECT* prc, int x, int y)
{
    if ((x) < (prc)->left) (prc)->left = (x);
    if ((y) < (prc)->top) (prc)->top = (y);
    if ((x) > (prc)->right) (prc)->right = (x);
    if ((y) > (prc)->bottom) (prc)->bottom = (y);
}
 
static inline BOOL PtInRect(const RECT* prc, int x, int y)
{
    if (x >= prc->left && x < prc->right && y >= prc->top && y < prc->bottom)
        return TRUE;
    return FALSE;
}
 
MG_EXPORT BOOL GUIAPI IsRectEmpty (const RECT* prc);
 
MG_EXPORT BOOL GUIAPI EqualRect (const RECT* prc1, const RECT* prc2);
 
MG_EXPORT void GUIAPI NormalizeRect (RECT* pRect);
 
MG_EXPORT BOOL GUIAPI IntersectRect (RECT* pdrc,
                const RECT* psrc1, const RECT* psrc2);
 
MG_EXPORT BOOL GUIAPI IsCovered (const RECT* prc1, const RECT* prc2);
 
MG_EXPORT BOOL GUIAPI DoesIntersect (const RECT* psrc1, const RECT* psrc2);
 
MG_EXPORT BOOL GUIAPI UnionRect (RECT* pdrc,
                const RECT* psrc1, const RECT* psrc2);
 
MG_EXPORT void GUIAPI GetBoundRect (PRECT pdrc,
                const RECT* psrc1, const RECT* psrc2);
 
MG_EXPORT int GUIAPI SubtractRect (RECT* rc, const RECT* psrc1, const RECT* psrc2);
 
#define RECTWP(prc)  ((prc)->right - (prc)->left)
 
#define RECTHP(prc)  ((prc)->bottom - (prc)->top)
 
#define RECTW(rc)    ((rc).right - (rc).left)
 
#define RECTH(rc)    ((rc).bottom - (rc).top)
 
/* Font-related structures */
#define LEN_LOGFONT_NAME_FIELD      31
#define LEN_LOGFONT_FAMILY_FIELD    (LEN_LOGFONT_NAME_FIELD*7+6)
#define LEN_LOGFONT_NAME_FULL       (LEN_LOGFONT_FAMILY_FIELD + 32)
#define LEN_UNIDEVFONT_NAME         255
 
#define LEN_FONT_NAME               LEN_LOGFONT_NAME_FIELD
#define LEN_DEVFONT_NAME            LEN_UNIDEVFONT_NAME
 
#define FONT_WEIGHT_NIL             '\0'
#define FONT_WEIGHT_ANY             '*'
#define FONT_WEIGHT_THIN            't'
#define FONT_WEIGHT_EXTRA_LIGHT     'e'
#define FONT_WEIGHT_LIGHT           'l'
#define FONT_WEIGHT_NORMAL          'n'
#define FONT_WEIGHT_REGULAR         'r'
#define FONT_WEIGHT_MEDIUM          'm'
#define FONT_WEIGHT_DEMIBOLD        'd'
#define FONT_WEIGHT_BOLD            'b'
#define FONT_WEIGHT_EXTRA_BOLD      'x'
#define FONT_WEIGHT_BLACK           'c'
 
/* Backward compatiblilty definitions.
 * deprecated since v4.0.0, use FS_RENDER_XXX/FONT_RENDER_XXX instead
 */
#define FONT_WEIGHT_SUBPIXEL        's'
#define FONT_WEIGHT_BOOK            'k'
 
#define FS_WEIGHT_MASK              0x000000FF
#define FS_WEIGHT_ANY               0
#define FS_WEIGHT_THIN              10
#define FS_WEIGHT_EXTRA_LIGHT       20
#define FS_WEIGHT_LIGHT             30
#define FS_WEIGHT_NORMAL            35
#define FS_WEIGHT_REGULAR           40
#define FS_WEIGHT_MEDIUM            50
#define FS_WEIGHT_DEMIBOLD          60
#define FS_WEIGHT_EXTRA_BOLD        70
#define FS_WEIGHT_BOLD              80
#define FS_WEIGHT_BLACK             90
 
#define FONT_SLANT_NIL              '\0'
#define FONT_SLANT_ANY              '*'
#define FONT_SLANT_ROMAN            'r'
#define FONT_SLANT_ITALIC           'i'
#define FONT_SLANT_OBLIQUE          'o'
 
#define FS_SLANT_MASK               0x00000F00
#define FS_SLANT_ANY                0x00000000
#define FS_SLANT_ROMAN              0x00000100
#define FS_SLANT_ITALIC             0x00000200
#define FS_SLANT_OBLIQUE            0x00000300
 
#define FONT_FLIP_NONE              'n'
#define FONT_FLIP_HORZ              'h'
#define FONT_FLIP_VERT              'v'
#define FONT_FLIP_HORZVERT          't'
#define FONT_FLIP_NIL               FONT_FLIP_NONE
 
#define FS_FLIP_MASK                0x0000F000
#define FS_FLIP_NONE                0x00000000
#define FS_FLIP_HORZ                0x00001000
#define FS_FLIP_VERT                0x00002000
#define FS_FLIP_HORZVERT            0x00003000 /* HORZ | VERT */
 
#define FONT_OTHER_NONE             'n'
#define FONT_OTHER_AUTOSCALE        's'
#define FONT_OTHER_TTFNOCACHE       'c'
#define FONT_OTHER_TTFKERN          'k'
#define FONT_OTHER_TTFNOCACHEKERN   'r'
#define FONT_OTHER_NIL              FONT_OTHER_NONE
 
#define FS_OTHER_MASK               0x00F00000
#define FS_OTHER_NONE               0x00000000
#define FS_OTHER_AUTOSCALE          0x00100000
#define FS_OTHER_TTFNOCACHE         0x00200000
#define FS_OTHER_TTFKERN            0x00400000
#define FS_OTHER_TTFNOCACHEKERN     0x00600000 /* KERN | NOCACHE */
 
#define FONT_DECORATE_NIL           '\0'
#define FONT_DECORATE_NONE          'n'
#define FONT_DECORATE_UNDERLINE     'u'
#define FONT_DECORATE_STRUCKOUT     's'
#define FONT_DECORATE_REVERSE       'r'
#define FONT_DECORATE_OUTLINE       'o'
#define FONT_DECORATE_US            'U' /* UNDERLINE | STRUCKOUT */
 
#define FS_DECORATE_MASK            0x0F000000
#define FS_DECORATE_NONE            0x00000000
#define FS_DECORATE_UNDERLINE       0x01000000
#define FS_DECORATE_STRUCKOUT       0x02000000
#define FS_DECORATE_REVERSE         0x04000000
#define FS_DECORATE_OUTLINE         0x08000000
#define FS_DECORATE_US              (FS_DECORATE_UNDERLINE | FS_DECORATE_STRUCKOUT)
 
#define FONT_RENDER_NIL             '\0'
#define FONT_RENDER_ANY             '*'
#define FONT_RENDER_MONO            'n'
#define FONT_RENDER_GREY            'g'
#define FONT_RENDER_SUBPIXEL        's'
 
#define FS_RENDER_MASK              0xF0000000
#define FS_RENDER_MONO              0x00000000
#define FS_RENDER_GREY              0x10000000
#define FS_RENDER_SUBPIXEL          0x20000000
#define FS_RENDER_ANY               FS_RENDER_MONO
 
/* Backward compatiblilty definitions; deprecated since v4.0.0 */
#define FONT_OTHER_LCDPORTRAIT      'p'
#define FONT_OTHER_LCDPORTRAITKERN  'q'
 
#define FONT_WEIGHT_ALL             FONT_WEIGHT_ANY
#define FONT_SLANT_ALL              FONT_SLANT_ANY
#define FS_WEIGHT_ALL               FS_WEIGHT_ANY
#define FS_SLANT_ALL                FS_SLANT_ANY
 
/* Backward compatiblilty definitions; deprecated since v4.0.0
 * All FONT_SETWIDTH_* and FONT_SPACING_* types will
 * be treated as FONT_FLIP_NIL and FONT_OTHER_NIL respectively.
 */
#define FONT_SETWIDTH_NIL           '\0'
#define FONT_SETWIDTH_ALL           '*'
#define FONT_SETWIDTH_BOLD          'b'
#define FONT_SETWIDTH_CONDENSED     'c'
#define FONT_SETWIDTH_SEMICONDENSED 's'
#define FONT_SETWIDTH_NORMAL        'n'
#define FONT_SETWIDTH_TTFNOCACHE    'w'
 
#define FONT_SPACING_NIL            '\0'
#define FONT_SPACING_ALL            '*'
#define FONT_SPACING_MONOSPACING    'm'
#define FONT_SPACING_PROPORTIONAL   'p'
#define FONT_SPACING_CHARCELL       'c'
 
#define FONT_UNDERLINE_NIL          '\0'
#define FONT_UNDERLINE_ALL          '*'
#define FONT_UNDERLINE_LINE         'u'
#define FONT_UNDERLINE_NONE         'n'
 
#define FONT_STRUCKOUT_NIL          '\0'
#define FONT_STRUCKOUT_ALL          '*'
#define FONT_STRUCKOUT_LINE         's'
#define FONT_STRUCKOUT_NONE         'n'
/******/
 
#define FONT_TYPE_NAME_LEN          3
#define FONT_TYPE_NAME_BITMAP_NUF   "nuf"
#define FONT_TYPE_NAME_BITMAP_RAW   "rbf"
#define FONT_TYPE_NAME_BITMAP_VAR   "vbf"
#define FONT_TYPE_NAME_BITMAP_QPF   "qpf"
#define FONT_TYPE_NAME_BITMAP_UPF   "upf"
#define FONT_TYPE_NAME_BITMAP_BMP   "bmp"
#define FONT_TYPE_NAME_SCALE_TTF    "ttf"
#define FONT_TYPE_NAME_SCALE_T1F    "t1f"
#define FONT_TYPE_NAME_ANY          "*"
#define FONT_TYPE_NAME_ALL          FONT_TYPE_NAME_ANY
 
#define FONT_ETC_SECTION_NAME_VBF   "varbitmapfonts"
#define FONT_ETC_SECTION_NAME_RBF   "rawbitmapfonts"
#define FONT_ETC_SECTION_NAME_UPF   "upf"
#define FONT_ETC_SECTION_NAME_QPF   "qpf"
#define FONT_ETC_SECTION_NAME_TTF   "truetypefonts"
 
#define FONT_TYPE_BITMAP_RAW        0x0001  /* "rbf" */
#define FONT_TYPE_BITMAP_VAR        0x0002  /* "vbf" */
#define FONT_TYPE_BITMAP_QPF        0x0003  /* "qpf" */
#define FONT_TYPE_BITMAP_BMP        0x0004  /* "bmp" */
#define FONT_TYPE_BITMAP_UPF        0x0005  /* "upf" */
#define FONT_TYPE_SCALE_TTF         0x0010  /* "ttf" */
#define FONT_TYPE_SCALE_T1F         0x0011  /* "t1f" */
#define FONT_TYPE_ANY               0x0000  /* "any" */
#define FONT_TYPE_ALL               FONT_TYPE_ANY
 
#define FONT_CHARSET_US_ASCII       "US-ASCII"
 
#define FONT_CHARSET_ISO8859_1      "ISO8859-1"
#define FONT_CHARSET_ISO8859_2      "ISO8859-2"
#define FONT_CHARSET_ISO8859_3      "ISO8859-3"
#define FONT_CHARSET_ISO8859_4      "ISO8859-4"
#define FONT_CHARSET_ISO8859_5      "ISO8859-5"
#define FONT_CHARSET_ISO8859_6      "ISO8859-6"
#define FONT_CHARSET_ISO8859_7      "ISO8859-7"
#define FONT_CHARSET_ISO8859_8      "ISO8859-8"
#define FONT_CHARSET_ISO8859_9      "ISO8859-9"
#define FONT_CHARSET_ISO8859_10     "ISO8859-10"
#define FONT_CHARSET_ISO8859_11     "ISO8859-11"
#define FONT_CHARSET_ISO8859_12     "ISO8859-12"
#define FONT_CHARSET_ISO8859_13     "ISO8859-13"
#define FONT_CHARSET_ISO8859_14     "ISO8859-14"
#define FONT_CHARSET_ISO8859_15     "ISO8859-15"
#define FONT_CHARSET_ISO8859_16     "ISO8859-16"
 
#define FONT_CHARSET_EUC_CN         "EUC-CN"
 
#define FONT_CHARSET_GB1988_0       "GB1988-0"
 
#define FONT_CHARSET_GB2312_0       "GB2312-0"
#define FONT_CHARSET_GBK            "GBK"
 
#define FONT_CHARSET_GB18030_0      "GB18030-0"
#define FONT_CHARSET_BIG5           "BIG5"
 
#define FONT_CHARSET_EUCTW          "EUC-TW"
#define FONT_CHARSET_EUCKR          "EUC-KR"
 
#define FONT_CHARSET_KSC5636_0      "KSC5636-0"
 
#define FONT_CHARSET_KSC5601_0      "KSC5601-0"
#define FONT_CHARSET_EUCJP          "EUC-JP"
 
#define FONT_CHARSET_JISX0201_0     "JISX0201-0"
 
#define FONT_CHARSET_JISX0208_0     "JISX0208-0"
#define FONT_CHARSET_SHIFTJIS       "SHIFT-JIS"
 
#define FONT_CHARSET_JISX0201_1     "JISX0201-1"
 
#define FONT_CHARSET_JISX0208_1     "JISX0208-1"
 
#define FONT_CHARSET_ISO_10646_1    "ISO-10646-1"
 
#define FONT_CHARSET_UTF8           "UTF-8"
 
#define FONT_CHARSET_UTF16LE        "UTF-16LE"
 
#define FONT_CHARSET_UTF16BE        "UTF-16BE"
 
#define FONT_MAX_SIZE               256
#define FONT_MIN_SIZE               1
#define MAXNR_DEVFONTS              8
 
struct _DEVFONT;
typedef struct _DEVFONT DEVFONT;
 
typedef struct _LOGFONT {
    char* type;
    char* family;
    char* charset;
    DWORD32 style;
    int  size;
    int  rotation;
    int  ascent;
    int  descent;
    int  size_request;
 
    /*
     * The following fields are internally used.
     * They may be changed in the future.
     */
 
    // The scale factors of devfonts
    unsigned short  scales[MAXNR_DEVFONTS];
    // The devfonts for the logfont
    DEVFONT*        devfonts[MAXNR_DEVFONTS];
} LOGFONT;
 
typedef LOGFONT* PLOGFONT;
 
typedef const LOGFONT* CPLOGFONT;
 
struct _WORDINFO;
 
typedef struct _WORDINFO WORDINFO;
 
#define MAX_LEN_MCHAR               6
 
typedef Uint16 Uchar16;
typedef Uint32 Uchar32;
 
#define ACHARTYPE_BASIC_MASK        0x0000FFFF
#define ACHARTYPE_CATEGORY_MASK     0x00FF0000
#define ACHARTYPE_BREAK_MASK        0xFF000000
 
#define ACHARTYPE_EXTRACT_BASIC(t) \
        (((t) & ACHARTYPE_BASIC_MASK))
 
#define ACHARTYPE_EXTRACT_CATEGORY(t) \
        (((t) & ACHARTYPE_CATEGORY_MASK) >> 16)
 
#define ACHARTYPE_EXTRACT_BREAK(t) \
        (((t) & ACHARTYPE_BREAK_MASK) >> 24)
 
#define ACHARTYPE_UNKNOWN           0
 
#define ACHAR_BASIC_NOSPACING_MARK   0x0001
#define ACHAR_BASIC_ABOVE_MARK       0x0002
#define ACHAR_BASIC_BELLOW_MARK      0x0004
 
#define ACHAR_BASIC_UNKNOWN          0x0000
#define ACHAR_BASIC_NUL              (0x0000 | ACHAR_BASIC_NOSPACING_MARK)
 
#define ACHAR_BASIC_CTRL1            0x0100
 
#define ACHAR_BASIC_BEL              0x0200
 
#define ACHAR_BASIC_BS               0x0300
 
#define ACHAR_BASIC_HT               0x0400
 
#define ACHAR_BASIC_LF               0x0500
 
#define ACHAR_BASIC_VT               0x0600
 
#define ACHAR_BASIC_FF               0x0700
 
#define ACHAR_BASIC_CR               0x0800
 
#define ACHAR_BASIC_CTRL2            0x0900
 
#define ACHAR_BASIC_SPACE            0x0A00
 
#define ACHAR_BASIC_ZEROWIDTH        0x0B00
#define ACHAR_BASIC_GENERIC          0x0C00
 
#define ACHAR_BASIC_LIGATURE         (0x0D00 | ACHAR_BASIC_NOSPACING_MARK)
#define ACHAR_BASIC_VOWEL            (0x0E00 | ACHAR_BASIC_NOSPACING_MARK)
#define ACHAR_BASIC_VOWEL_ABOVE      (ACHAR_BASIC_VOWEL | ACHAR_BASIC_ABOVE_MARK)
#define ACHAR_BASIC_VOWEL_BELLOW     (ACHAR_BASIC_VOWEL | ACHAR_BASIC_BELLOW_MARK)
 
/* Compatibility definitions */
#define MCHAR_TYPE_UNKNOWN          ACHAR_BASIC_UNKNOWN
#define MCHAR_TYPE_NUL              ACHAR_BASIC_NUL
#define MCHAR_TYPE_CTRL1            ACHAR_BASIC_CTRL1
#define MCHAR_TYPE_BEL              ACHAR_BASIC_BEL
#define MCHAR_TYPE_BS               ACHAR_BASIC_BS
#define MCHAR_TYPE_HT               ACHAR_BASIC_HT
#define MCHAR_TYPE_LF               ACHAR_BASIC_LF
#define MCHAR_TYPE_VT               ACHAR_BASIC_VT
#define MCHAR_TYPE_FF               ACHAR_BASIC_FF
#define MCHAR_TYPE_CR               ACHAR_BASIC_CR
#define MCHAR_TYPE_CTRL2            ACHAR_BASIC_CTRL2
#define MCHAR_TYPE_SPACE            ACHAR_BASIC_SPACE
#define MCHAR_TYPE_ZEROWIDTH        ACHAR_BASIC_ZEROWIDTH
#define MCHAR_TYPE_GENERIC          ACHAR_BASIC_GENERIC
#define MCHAR_TYPE_NOSPACING_MARK   ACHAR_BASIC_NOSPACING_MARK
#define MCHAR_TYPE_LIGATURE         ACHAR_BASIC_LIGATURE
#define MCHAR_TYPE_VOWEL            ACHAR_BASIC_VOWEL
#define MCHAR_TYPE_VOWEL_ABOVE      ACHAR_BASIC_VOWEL_ABOVE
#define MCHAR_TYPE_VOWEL_BELLOW     ACHAR_BASIC_VOWEL_BELLOW
 
#if 0
#define MCHAR_TYPE_ASCII            0x0080
#define MCHAR_TYPE_LATIN1           0x0081
#define MCHAR_TYPE_LATIN2           0x0082
#define MCHAR_TYPE_LATIN3           0x0083
#define MCHAR_TYPE_LATIN4           0x0084
#define MCHAR_TYPE_LATIN5           0x0085
#define MCHAR_TYPE_LATIN6           0x0086
#define MCHAR_TYPE_LATIN7           0x0087
#define MCHAR_TYPE_LATIN8           0x0088
#define MCHAR_TYPE_LATIN9           0x0089
#define MCHAR_TYPE_LATIN10          0x008A
#define MCHAR_TYPE_CYRILLIC         0x008B
#define MCHAR_TYPE_ARABIC           0x008C
#define MCHAR_TYPE_GREEK            0x008D
#define MCHAR_TYPE_HEBREW           0x008E
#define MCHAR_TYPE_THAI             0x008F
 
#define MCHAR_TYPE_DIGIT            0x0091
#define MCHAR_TYPE_SYMBOL_PUNCT     0x0092
#define MCHAR_TYPE_SYMBOL_MATH      0x0093
#define MCHAR_TYPE_SYMBOL_OTHER     0x0094
#define MCHAR_TYPE_FW_DIGIT         0x0095
#define MCHAR_TYPE_FW_SYM_PUNCT     0x0096
#define MCHAR_TYPE_FW_SYM_MATH      0x0097
#define MCHAR_TYPE_FW_SYM_OTHER     0x0098
 
#define MCHAR_TYPE_HANGUL           0x00A1
#define MCHAR_TYPE_KATAKANA         0x00A2
#define MCHAR_TYPE_CJK              0x00A3
#endif
 
typedef enum {
    UCHAR_CATEGORY_CONTROL,
    UCHAR_CATEGORY_FORMAT,
    UCHAR_CATEGORY_UNASSIGNED,
    UCHAR_CATEGORY_PRIVATE_USE,
    UCHAR_CATEGORY_SURROGATE,
    UCHAR_CATEGORY_LOWERCASE_LETTER,
    UCHAR_CATEGORY_MODIFIER_LETTER,
    UCHAR_CATEGORY_OTHER_LETTER,
    UCHAR_CATEGORY_TITLECASE_LETTER,
    UCHAR_CATEGORY_UPPERCASE_LETTER,
    UCHAR_CATEGORY_SPACING_MARK,
    UCHAR_CATEGORY_ENCLOSING_MARK,
    UCHAR_CATEGORY_NON_SPACING_MARK,
    UCHAR_CATEGORY_DECIMAL_NUMBER,
    UCHAR_CATEGORY_LETTER_NUMBER,
    UCHAR_CATEGORY_OTHER_NUMBER,
    UCHAR_CATEGORY_CONNECT_PUNCTUATION,
    UCHAR_CATEGORY_DASH_PUNCTUATION,
    UCHAR_CATEGORY_CLOSE_PUNCTUATION,
    UCHAR_CATEGORY_FINAL_PUNCTUATION,
    UCHAR_CATEGORY_INITIAL_PUNCTUATION,
    UCHAR_CATEGORY_OTHER_PUNCTUATION,
    UCHAR_CATEGORY_OPEN_PUNCTUATION,
    UCHAR_CATEGORY_CURRENCY_SYMBOL,
    UCHAR_CATEGORY_MODIFIER_SYMBOL,
    UCHAR_CATEGORY_MATH_SYMBOL,
    UCHAR_CATEGORY_OTHER_SYMBOL,
    UCHAR_CATEGORY_LINE_SEPARATOR,
    UCHAR_CATEGORY_PARAGRAPH_SEPARATOR,
    UCHAR_CATEGORY_SPACE_SEPARATOR
} UCharGeneralCategory;
 
typedef enum {
    UCHAR_BREAK_MANDATORY,
    UCHAR_BREAK_CARRIAGE_RETURN,
    UCHAR_BREAK_LINE_FEED,
    UCHAR_BREAK_COMBINING_MARK,
    UCHAR_BREAK_SURROGATE,
    UCHAR_BREAK_ZERO_WIDTH_SPACE,
    UCHAR_BREAK_INSEPARABLE,
    UCHAR_BREAK_NON_BREAKING_GLUE,
    UCHAR_BREAK_CONTINGENT,
    UCHAR_BREAK_SPACE,
    UCHAR_BREAK_AFTER,
    UCHAR_BREAK_BEFORE,
    UCHAR_BREAK_BEFORE_AND_AFTER,
    UCHAR_BREAK_HYPHEN,
    UCHAR_BREAK_NON_STARTER,
    UCHAR_BREAK_OPEN_PUNCTUATION,
    UCHAR_BREAK_CLOSE_PUNCTUATION,
    UCHAR_BREAK_QUOTATION,
    UCHAR_BREAK_EXCLAMATION,
    UCHAR_BREAK_IDEOGRAPHIC,
    UCHAR_BREAK_NUMERIC,
    UCHAR_BREAK_INFIX_SEPARATOR,
    UCHAR_BREAK_SYMBOL,
    UCHAR_BREAK_ALPHABETIC,
    UCHAR_BREAK_PREFIX,
    UCHAR_BREAK_POSTFIX,
    UCHAR_BREAK_COMPLEX_CONTEXT,
    UCHAR_BREAK_AMBIGUOUS,
    UCHAR_BREAK_UNKNOWN,
    UCHAR_BREAK_NEXT_LINE,
    UCHAR_BREAK_WORD_JOINER,
    UCHAR_BREAK_HANGUL_L_JAMO,
    UCHAR_BREAK_HANGUL_V_JAMO,
    UCHAR_BREAK_HANGUL_T_JAMO,
    UCHAR_BREAK_HANGUL_LV_SYLLABLE,
    UCHAR_BREAK_HANGUL_LVT_SYLLABLE,
    UCHAR_BREAK_CLOSE_PARANTHESIS,
    UCHAR_BREAK_CONDITIONAL_JAPANESE_STARTER,
    UCHAR_BREAK_HEBREW_LETTER,
    UCHAR_BREAK_REGIONAL_INDICATOR,
    UCHAR_BREAK_EMOJI_BASE,
    UCHAR_BREAK_EMOJI_MODIFIER,
    UCHAR_BREAK_ZERO_WIDTH_JOINER
} UCharBreakType;
 
typedef enum {
    SCRIPT_INVALID_CODE = 0xFF,
    SCRIPT_COMMON       = 0,   /* Zyyy */
    SCRIPT_INHERITED,          /* Zinh (Qaai) */
    SCRIPT_ARABIC,             /* Arab */
    SCRIPT_ARMENIAN,           /* Armn */
    SCRIPT_BENGALI,            /* Beng */
    SCRIPT_BOPOMOFO,           /* Bopo */
    SCRIPT_CHEROKEE,           /* Cher */
    SCRIPT_COPTIC,             /* Copt (Qaac) */
    SCRIPT_CYRILLIC,           /* Cyrl (Cyrs) */
    SCRIPT_DESERET,            /* Dsrt */
    SCRIPT_DEVANAGARI,         /* Deva */
    SCRIPT_ETHIOPIC,           /* Ethi */
    SCRIPT_GEORGIAN,           /* Geor (Geon, Geoa) */
    SCRIPT_GOTHIC,             /* Goth */
    SCRIPT_GREEK,              /* Grek */
    SCRIPT_GUJARATI,           /* Gujr */
    SCRIPT_GURMUKHI,           /* Guru */
    SCRIPT_HAN,                /* Hani */
    SCRIPT_HANGUL,             /* Hang */
    SCRIPT_HEBREW,             /* Hebr */
    SCRIPT_HIRAGANA,           /* Hira */
    SCRIPT_KANNADA,            /* Knda */
    SCRIPT_KATAKANA,           /* Kana */
    SCRIPT_KHMER,              /* Khmr */
    SCRIPT_LAO,                /* Laoo */
    SCRIPT_LATIN,              /* Latn (Latf, Latg) */
    SCRIPT_MALAYALAM,          /* Mlym */
    SCRIPT_MONGOLIAN,          /* Mong */
    SCRIPT_MYANMAR,            /* Mymr */
    SCRIPT_OGHAM,              /* Ogam */
    SCRIPT_OLD_ITALIC,         /* Ital */
    SCRIPT_ORIYA,              /* Orya */
    SCRIPT_RUNIC,              /* Runr */
    SCRIPT_SINHALA,            /* Sinh */
    SCRIPT_SYRIAC,             /* Syrc (Syrj, Syrn, Syre) */
    SCRIPT_TAMIL,              /* Taml */
    SCRIPT_TELUGU,             /* Telu */
    SCRIPT_THAANA,             /* Thaa */
    SCRIPT_THAI,               /* Thai */
    SCRIPT_TIBETAN,            /* Tibt */
    SCRIPT_CANADIAN_ABORIGINAL, /* Cans */
    SCRIPT_YI,                 /* Yiii */
    SCRIPT_TAGALOG,            /* Tglg */
    SCRIPT_HANUNOO,            /* Hano */
    SCRIPT_BUHID,              /* Buhd */
    SCRIPT_TAGBANWA,           /* Tagb */
 
    /* Unicode-4.0 additions */
    SCRIPT_BRAILLE,            /* Brai */
    SCRIPT_CYPRIOT,            /* Cprt */
    SCRIPT_LIMBU,              /* Limb */
    SCRIPT_OSMANYA,            /* Osma */
    SCRIPT_SHAVIAN,            /* Shaw */
    SCRIPT_LINEAR_B,           /* Linb */
    SCRIPT_TAI_LE,             /* Tale */
    SCRIPT_UGARITIC,           /* Ugar */
 
    /* Unicode-4.1 additions */
    SCRIPT_NEW_TAI_LUE,        /* Talu */
    SCRIPT_BUGINESE,           /* Bugi */
    SCRIPT_GLAGOLITIC,         /* Glag */
    SCRIPT_TIFINAGH,           /* Tfng */
    SCRIPT_SYLOTI_NAGRI,       /* Sylo */
    SCRIPT_OLD_PERSIAN,        /* Xpeo */
    SCRIPT_KHAROSHTHI,         /* Khar */
 
    /* Unicode-5.0 additions */
    SCRIPT_UNKNOWN,            /* Zzzz */
    SCRIPT_BALINESE,           /* Bali */
    SCRIPT_CUNEIFORM,          /* Xsux */
    SCRIPT_PHOENICIAN,         /* Phnx */
    SCRIPT_PHAGS_PA,           /* Phag */
    SCRIPT_NKO,                /* Nkoo */
 
    /* Unicode-5.1 additions */
    SCRIPT_KAYAH_LI,           /* Kali */
    SCRIPT_LEPCHA,             /* Lepc */
    SCRIPT_REJANG,             /* Rjng */
    SCRIPT_SUNDANESE,          /* Sund */
    SCRIPT_SAURASHTRA,         /* Saur */
    SCRIPT_CHAM,               /* Cham */
    SCRIPT_OL_CHIKI,           /* Olck */
    SCRIPT_VAI,                /* Vaii */
    SCRIPT_CARIAN,             /* Cari */
    SCRIPT_LYCIAN,             /* Lyci */
    SCRIPT_LYDIAN,             /* Lydi */
 
    /* Unicode-5.2 additions */
    SCRIPT_AVESTAN,                /* Avst */
    SCRIPT_BAMUM,                  /* Bamu */
    SCRIPT_EGYPTIAN_HIEROGLYPHS,   /* Egyp */
    SCRIPT_IMPERIAL_ARAMAIC,       /* Armi */
    SCRIPT_INSCRIPTIONAL_PAHLAVI,  /* Phli */
    SCRIPT_INSCRIPTIONAL_PARTHIAN, /* Prti */
    SCRIPT_JAVANESE,               /* Java */
    SCRIPT_KAITHI,                 /* Kthi */
    SCRIPT_LISU,                   /* Lisu */
    SCRIPT_MEETEI_MAYEK,           /* Mtei */
    SCRIPT_OLD_SOUTH_ARABIAN,      /* Sarb */
    SCRIPT_OLD_TURKIC,             /* Orkh */
    SCRIPT_SAMARITAN,              /* Samr */
    SCRIPT_TAI_THAM,               /* Lana */
    SCRIPT_TAI_VIET,               /* Tavt */
 
    /* Unicode-6.0 additions */
    SCRIPT_BATAK,                  /* Batk */
    SCRIPT_BRAHMI,                 /* Brah */
    SCRIPT_MANDAIC,                /* Mand */
 
    /* Unicode-6.1 additions */
    SCRIPT_CHAKMA,                 /* Cakm */
    SCRIPT_MEROITIC_CURSIVE,       /* Merc */
    SCRIPT_MEROITIC_HIEROGLYPHS,   /* Mero */
    SCRIPT_MIAO,                   /* Plrd */
    SCRIPT_SHARADA,                /* Shrd */
    SCRIPT_SORA_SOMPENG,           /* Sora */
    SCRIPT_TAKRI,                  /* Takr */
 
    /* Unicode 7.0 additions */
    SCRIPT_BASSA_VAH,              /* Bass */
    SCRIPT_CAUCASIAN_ALBANIAN,     /* Aghb */
    SCRIPT_DUPLOYAN,               /* Dupl */
    SCRIPT_ELBASAN,                /* Elba */
    SCRIPT_GRANTHA,                /* Gran */
    SCRIPT_KHOJKI,                 /* Khoj */
    SCRIPT_KHUDAWADI,              /* Sind */
    SCRIPT_LINEAR_A,               /* Lina */
    SCRIPT_MAHAJANI,               /* Mahj */
    SCRIPT_MANICHAEAN,             /* Manu */
    SCRIPT_MENDE_KIKAKUI,          /* Mend */
    SCRIPT_MODI,                   /* Modi */
    SCRIPT_MRO,                    /* Mroo */
    SCRIPT_NABATAEAN,              /* Nbat */
    SCRIPT_OLD_NORTH_ARABIAN,      /* Narb */
    SCRIPT_OLD_PERMIC,             /* Perm */
    SCRIPT_PAHAWH_HMONG,           /* Hmng */
    SCRIPT_PALMYRENE,              /* Palm */
    SCRIPT_PAU_CIN_HAU,            /* Pauc */
    SCRIPT_PSALTER_PAHLAVI,        /* Phlp */
    SCRIPT_SIDDHAM,                /* Sidd */
    SCRIPT_TIRHUTA,                /* Tirh */
    SCRIPT_WARANG_CITI,            /* Wara */
 
    /* Unicode 8.0 additions */
    SCRIPT_AHOM,                   /* Ahom */
    SCRIPT_ANATOLIAN_HIEROGLYPHS,  /* Hluw */
    SCRIPT_HATRAN,                 /* Hatr */
    SCRIPT_MULTANI,                /* Mult */
    SCRIPT_OLD_HUNGARIAN,          /* Hung */
    SCRIPT_SIGNWRITING,            /* Sgnw */
 
    /* Unicode 9.0 additions */
    SCRIPT_ADLAM,                  /* Adlm */
    SCRIPT_BHAIKSUKI,              /* Bhks */
    SCRIPT_MARCHEN,                /* Marc */
    SCRIPT_NEWA,                   /* Newa */
    SCRIPT_OSAGE,                  /* Osge */
    SCRIPT_TANGUT,                 /* Tang */
 
    /* Unicode 10.0 additions */
    SCRIPT_MASARAM_GONDI,          /* Gonm */
    SCRIPT_NUSHU,                  /* Nshu */
    SCRIPT_SOYOMBO,                /* Soyo */
    SCRIPT_ZANABAZAR_SQUARE,       /* Zanb */
 
    /* Unicode 11.0 additions */
    SCRIPT_DOGRA,                  /* Dogr */
    SCRIPT_GUNJALA_GONDI,          /* Gong */
    SCRIPT_HANIFI_ROHINGYA,        /* Rohg */
    SCRIPT_MAKASAR,                /* Maka */
    SCRIPT_MEDEFAIDRIN,            /* Medf */
    SCRIPT_OLD_SOGDIAN,            /* Sogo */
    SCRIPT_SOGDIAN,                /* Sogd */
 
    /* Unicode 12.0 additions */
    SCRIPT_ELYMAIC,                /* Elymaic */
    SCRIPT_NANDINAGARI,            /* Nandinagari */
    SCRIPT_NYIAKENG_PUACHUE_HMONG, /* Nyiakeng Puachue Hmong */
    SCRIPT_WANCHO,                 /* Wancho */
} ScriptType;
 
typedef enum {
    LANGCODE_unknown = 0xFF,
    LANGCODE_aa = 0,
    LANGCODE_ab,
    LANGCODE_af,
    LANGCODE_am,
    LANGCODE_ar,
    LANGCODE_as,
    LANGCODE_ay,
    LANGCODE_az,
    LANGCODE_ba,
    LANGCODE_be,
    LANGCODE_bg,
    LANGCODE_bh,
    LANGCODE_bi,
    LANGCODE_bn,
    LANGCODE_bo,
    LANGCODE_br,
    LANGCODE_ca,
    LANGCODE_co,
    LANGCODE_cs,
    LANGCODE_cy,
    LANGCODE_da,
    LANGCODE_de,
    LANGCODE_dv,
    LANGCODE_dz,
    LANGCODE_el,
    LANGCODE_en,
    LANGCODE_eo,
    LANGCODE_es,
    LANGCODE_et,
    LANGCODE_eu,
    LANGCODE_fa,
    LANGCODE_fi,
    LANGCODE_fj,
    LANGCODE_fo,
    LANGCODE_fr,
    LANGCODE_fy,
    LANGCODE_ga,
    LANGCODE_gd,
    LANGCODE_gl,
    LANGCODE_gn,
    LANGCODE_gu,
    LANGCODE_ha,
    LANGCODE_hi,
    LANGCODE_he,
    LANGCODE_hr,
    LANGCODE_hu,
    LANGCODE_hy,
    LANGCODE_ia,
    LANGCODE_id,
    LANGCODE_ie,
    LANGCODE_ik,
    LANGCODE_in,
    LANGCODE_is,
    LANGCODE_it,
    LANGCODE_iu,
    LANGCODE_iw,
    LANGCODE_ja,
    LANGCODE_ji,
    LANGCODE_jw,
    LANGCODE_ka,
    LANGCODE_kk,
    LANGCODE_kl,
    LANGCODE_km,
    LANGCODE_kn,
    LANGCODE_ko,
    LANGCODE_ks,
    LANGCODE_ku,
    LANGCODE_ky,
    LANGCODE_la,
    LANGCODE_ln,
    LANGCODE_lo,
    LANGCODE_lt,
    LANGCODE_lv,
    LANGCODE_mg,
    LANGCODE_mi,
    LANGCODE_mk,
    LANGCODE_ml,
    LANGCODE_mn,
    LANGCODE_mo,
    LANGCODE_mr,
    LANGCODE_ms,
    LANGCODE_mt,
    LANGCODE_my,
    LANGCODE_na,
    LANGCODE_ne,
    LANGCODE_nl,
    LANGCODE_no,
    LANGCODE_oc,
    LANGCODE_om,
    LANGCODE_or,
    LANGCODE_pa,
    LANGCODE_pl,
    LANGCODE_ps,
    LANGCODE_pt,
    LANGCODE_qu,
    LANGCODE_rm,
    LANGCODE_rn,
    LANGCODE_ro,
    LANGCODE_ru,
    LANGCODE_rw,
    LANGCODE_sa,
    LANGCODE_sd,
    LANGCODE_sg,
    LANGCODE_sh,
    LANGCODE_si,
    LANGCODE_sk,
    LANGCODE_sl,
    LANGCODE_sm,
    LANGCODE_sn,
    LANGCODE_so,
    LANGCODE_sq,
    LANGCODE_sr,
    LANGCODE_ss,
    LANGCODE_st,
    LANGCODE_su,
    LANGCODE_sv,
    LANGCODE_sw,
    LANGCODE_ta,
    LANGCODE_te,
    LANGCODE_tg,
    LANGCODE_th,
    LANGCODE_ti,
    LANGCODE_tk,
    LANGCODE_tl,
    LANGCODE_tn,
    LANGCODE_to,
    LANGCODE_tr,
    LANGCODE_ts,
    LANGCODE_tt,
    LANGCODE_tw,
    LANGCODE_ug,
    LANGCODE_uk,
    LANGCODE_ur,
    LANGCODE_uz,
    LANGCODE_vi,
    LANGCODE_vo,
    LANGCODE_wo,
    LANGCODE_xh,
    LANGCODE_yi,
    LANGCODE_yo,
    LANGCODE_za,
    LANGCODE_zh,
    LANGCODE_zu,
} LanguageCode;
 
MG_EXPORT LanguageCode GUIAPI LanguageCodeFromISO639s1 (Uint16 iso639_1);
 
static inline LanguageCode GUIAPI LanguageCodeFromISO639s1Code(const char* iso639_1)
{
    return LanguageCodeFromISO639s1(MAKEWORD16(iso639_1[1],
            iso639_1[0]));
}
 
MG_EXPORT const char* GUIAPI LanguageCodeToISO639s1(LanguageCode lc);
 
MG_EXPORT LanguageCode GUIAPI GetSampleLanguageForScript(ScriptType st);
 
MG_EXPORT const ScriptType* GUIAPI GetScriptsForLang(const char* lang_name,
        LanguageCode* lang_code, int* nr_scripts);
 
MG_EXPORT ScriptType GUIAPI NormalizeScriptType(LanguageCode cl,
    ScriptType ws);
 
struct _FONTOPS;
struct _CHARSETOPS;
 
typedef struct _FONTOPS FONTOPS;
typedef struct _CHARSETOPS CHARSETOPS;
 
struct _DEVFONT {
    char             name [LEN_UNIDEVFONT_NAME + 1];
 
    DWORD32          style;
 
    /*
     * The following fields are internally used.
     * They may changed in the future.
     */
    // indicating if the data need to be unloaded before delete a devfont
    BOOL             need_unload;
 
    // The pointer to font operation structure.
    FONTOPS*         font_ops;
 
    // The pointer to character set operation structure.
    CHARSETOPS*      charset_ops;
 
    // The pointer to next device font.
    struct _DEVFONT* next;
 
    // The device font used data.
    void*            data;
 
    // The device font used relationship.
    void*            relationship;
};
 
#define INV_LOGFONT     0
 
typedef struct _FONTMETRICS {
    int font_height;
    int ascent;
    int descent;
 
    int max_width;
    int ave_width;
} FONTMETRICS;
 
MG_EXPORT void GUIAPI GetFontMetrics (LOGFONT* log_font,
                FONTMETRICS* font_metrics);
 
typedef struct _GLYPHBITMAP {
    int bbox_x, bbox_y, bbox_w, bbox_h;
    int advance_x, advance_y;
 
    size_t bmp_size;
    int bmp_pitch;
    const unsigned char* bits;
} GLYPHBITMAP;
 
MG_EXPORT void GUIAPI GetGlyphBitmap (LOGFONT* log_font,
                const char* mchar, int mchar_len,
                GLYPHBITMAP* glyph_bitmap);
 
static inline BOOL GUIAPI InitVectorialFonts (void)
{
    _WRN_PRINTF("deprecated\n");
    return TRUE;
}
 
static inline void GUIAPI TermVectorialFonts (void)
{
    _WRN_PRINTF("deprecated\n");
}
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFont (const char* type, const char* family,
        const char* charset, char weight, char slant, char flip,
        char other, char underline, char struckout,
        int size, int rotation);
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFontEx (const char* type, const char* family,
        const char* charset, char weight, char slant, char flip,
        char other, char decoration, char rendering,
        int size, int rotation);
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFontByName(const char* font_name);
 
#ifdef _MGCHARSET_UNICODE
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFontForMChar2UChar(const char* charset);
#endif /* _MGCHARSET_UNICODE */
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFontIndirect (LOGFONT* logfont);
 
MG_EXPORT PLOGFONT GUIAPI CreateLogFontIndirectEx (LOGFONT* logfont,
        int rotation);
 
MG_EXPORT void GUIAPI DestroyLogFont (PLOGFONT log_font);
 
MG_EXPORT void GUIAPI GetLogFontInfo (HDC hdc, LOGFONT* log_font);
 
MG_EXPORT PLOGFONT GUIAPI GetCurFont (HDC hdc);
 
MG_EXPORT PLOGFONT GUIAPI SelectFont (HDC hdc, PLOGFONT log_font);
 
MG_EXPORT const DEVFONT* GUIAPI GetNextDevFont (const DEVFONT* dev_font);
 
#ifdef _MGFONT_FT2
 
typedef enum {
    MG_SMOOTH_NONE = 0,
    MG_SMOOTH_DEFAULT = 1,
    MG_SMOOTH_LIGHT = 2,
    MG_SMOOTH_LEGACY = 16,
    MG_SMOOTH_MAX    /*do not remove*/
} FT2LCDFilter;
 
MG_EXPORT BOOL GUIAPI ft2SetLcdFilter (LOGFONT* logfont, FT2LCDFilter filter);
 
#endif
 
MG_EXPORT DEVFONT* GUIAPI LoadDevFontFromIncoreData (const char *devfont_name,
        const void *data);
 
MG_EXPORT DEVFONT* GUIAPI LoadDevFontFromFile (const char *devfont_name,
        const char *file_name);
 
MG_EXPORT void GUIAPI DestroyDynamicDevFont (DEVFONT **devfont);
 
#define SYSLOGFONT_DEFAULT          0
 
#define SYSLOGFONT_WCHAR_DEF        1
 
#define SYSLOGFONT_FIXED            2
 
#define SYSLOGFONT_CAPTION          3
 
#define SYSLOGFONT_MENU             4
 
#define SYSLOGFONT_CONTROL          5
 
#define NR_SYSLOGFONTS              6
 
 
extern MG_EXPORT PLOGFONT g_SysLogFont [];
 
static inline PLOGFONT GUIAPI GetSystemFont (int font_id)
{
    if (font_id >= 0 && font_id < NR_SYSLOGFONTS)
        return g_SysLogFont [font_id];
    else
        return (PLOGFONT)NULL;
}
 
MG_EXPORT int GUIAPI GetSysFontMaxWidth (int font_id);
 
MG_EXPORT int GUIAPI GetSysFontAveWidth (int font_id);
 
MG_EXPORT int GUIAPI GetSysFontHeight (int font_id);
 
MG_EXPORT const char* GUIAPI GetSysCharset (BOOL wchar);
 
MG_EXPORT int GUIAPI GetSysCharHeight (void);
 
MG_EXPORT int GUIAPI GetSysCharWidth (void);
 
MG_EXPORT int GUIAPI GetSysCCharWidth (void);
 
struct _WORDINFO
{
    int len;
    unsigned char delimiter;
    int nr_delimiters;
};
 
MG_EXPORT int GUIAPI GetTextMCharInfo (PLOGFONT log_font,
                const char* mstr, int len, int* pos_chars);
 
MG_EXPORT int GUIAPI GetTextWordInfo (PLOGFONT log_font, const char* mstr,
                int len, int* pos_words, WORDINFO* info_words);
 
MG_EXPORT int GUIAPI GetFirstMCharLen (PLOGFONT log_font,
                const char* mstr, int len);
 
MG_EXPORT int GUIAPI GetFirstWord (PLOGFONT log_font,
                const char* mstr, int len, WORDINFO* word_info);
 
MG_EXPORT int GUIAPI GetTextExtentPoint (HDC hdc, const char* text, int len,
                int max_extent, int* fit_chars, int* pos_chars,
                int* dx_chars, SIZE* size);
 
MG_EXPORT int GUIAPI GetTabbedTextExtentPoint (HDC hdc,
                const char* text, int len, int max_extent,
                int* fit_chars, int* pos_chars, int* dx_chars, SIZE* size);
 
#ifdef _MGCHARSET_UNICODE
 
MG_EXPORT int GUIAPI MB2WCEx (PLOGFONT log_font, void* dest, BOOL wc32,
                const unsigned char* mstr, int n);
 
#define MB2WC(log_font, dest, mstr, n) \
                   MB2WCEx (log_font, dest, sizeof(wchar_t) == 4, mstr, n)
 
MG_EXPORT int GUIAPI WC2MBEx (PLOGFONT log_font, unsigned char *s, Uchar32 wc);
 
#define WC2MB(log_font, s, wc) \
                   WC2MBEx (log_font, s, (Uchar32)wc)
 
MG_EXPORT int GUIAPI MBS2WCSEx (PLOGFONT log_font, void* dest, BOOL wc32,
                const unsigned char* mstr, int mstr_len, int n,
                int* conved_mstr_len);
 
#define MBS2WCS(log_font, dest, mstr, mstr_len, n) \
            MBS2WCSEx(log_font, dest, sizeof (wchar_t) == 4, mstr, \
            mstr_len, n, NULL)
 
MG_EXPORT int GUIAPI WCS2MBSEx (PLOGFONT log_font, unsigned char* dest,
                const void *wcs, int wcs_len, BOOL wc32, int n,
                int* conved_wcs_len);
 
#define WCS2MBS(log_font, dest, wcs, wcs_len, n) \
            WCS2MBSEx (log_font, dest, wcs, wcs_len, sizeof (wchar_t) == 4, \
            n, NULL)
 
#endif /* _MGCHARSET_UNICODE */
 
typedef Sint8   BidiLevel;
typedef Uint16  BidiType;
typedef Uint32  BidiBracketType;
 
typedef Uint8   BidiJoiningType;
typedef Uint8   BidiArabicProp;
 
typedef Uint16  ParagraphDir;
 
#define BIDI_FLAG_SHAPE_MIRRORING       0x00000001
#define BIDI_FLAG_REORDER_NSM           0x00000002
#define BIDI_FLAG_SHAPE_ARAB_PRES       0x00000100
#define BIDI_FLAG_SHAPE_ARAB_LIGA       0x00000200
#define BIDI_FLAG_SHAPE_ARAB_CONSOLE    0x00000400
 
#define BIDI_FLAGS_DEFAULT  \
    (BIDI_FLAG_REORDER_NSM | BIDI_FLAG_REMOVE_SPECIALS)
 
#define BIDI_FLAGS_ARABIC  \
    (BIDI_FLAG_SHAPE_ARAB_PRES | BIDI_FLAG_SHAPE_ARAB_LIGA)
 
#define BIDI_FLAG_REMOVE_BIDI           0x00010000
#define BIDI_FLAG_REMOVE_JOINING        0x00020000
#define BIDI_FLAG_REMOVE_SPECIALS       0x00040000
 
#define BIDI_BRACKET_NONE           0
#define BIDI_BRACKET_OPEN_MASK      0x80000000
#define BIDI_BRACKET_CHAR_MASK      0X7FFFFFFF
#define BIDI_IS_BRACKET_OPEN(bt)    ((bt & BIDI_BRACKET_OPEN_MASK)>0)
#define BIDI_BRACKET_CHAR(bt)       ((bt & BIDI_BRACKET_CHAR_MASK))
 
/*
 * Define some bit masks, that character types are based on, each one has
 * only one bit on.
 */
 
#define BIDI_TYPE_INVALID       0x0000
 
#define BIDI_MASK_RTL           0x0001    /* Is right to left */
#define BIDI_MASK_ARABIC        0x0002    /* Is arabic */
#define BIDI_MASK_FIRST         0x0004    /* Is direction is determined by first strong */
#define BIDI_MASK_SEPARATOR     0x0008    /* Is separator: BS, SS */
 
#define BIDI_MASK_STRONG        0x0010    /* Is strong */
#define BIDI_MASK_WEAK          0x0020    /* Is weak */
#define BIDI_MASK_NEUTRAL       0x0040    /* Is neutral */
#define BIDI_MASK_SENTINEL      0x0080    /* Is sentinel: SOT, EOT */
 
/* Each char can be only one of the seven following: */
#define BIDI_MASK_LETTER        0x0100    /* Is letter: L, R, AL */
#define BIDI_MASK_NUMBER        0x0200    /* Is number: EN, AN */
#define BIDI_MASK_NUMSEPTER     0x0300    /* Is number separator or terminator: ES, ET, CS */
#define BIDI_MASK_SPACE         0x0400    /* Is space: BN, BS, SS, WS */
#define BIDI_MASK_EXPLICIT      0x0500    /* Is expilict mark: LRE, RLE, LRO, RLO, PDF */
#define BIDI_MASK_ISOLATE       0x0600    /* Is isolate mark: LRI, RLI, FSI, PDI */
#define BIDI_MASK_NSM           0x0700    /* Is non spacing mark: NSM */
#   define BIDI_TYPE_MASK          0x0700
 
#define BIDI_MASK_OVERRIDE      0x8000    /* Is explicit override: LRO, RLO */
 
/* Each char can be only one of the seven following: */
#define BIDI_MASK_ES            0x1000
#define BIDI_MASK_CS            0x2000
#define BIDI_MASK_ET            0x3000
#define BIDI_MASK_BS            0x4000
#define BIDI_MASK_SS            0x5000
#define BIDI_MASK_BN            0x6000
#define BIDI_MASK_WS            0x7000
#   define BIDI_MISC_MASK          0x7000
 
/* Reserved for private use */
#define BIDI_MASK_PRIVATE       0x8000
 
#define BIDI_TYPE_LTR \
    (BIDI_MASK_STRONG | BIDI_MASK_LETTER)
 
#define BIDI_TYPE_RTL \
    (BIDI_MASK_STRONG | BIDI_MASK_LETTER | BIDI_MASK_RTL)
 
#define BIDI_TYPE_AL \
    (BIDI_MASK_STRONG | BIDI_MASK_LETTER | BIDI_MASK_RTL  | BIDI_MASK_ARABIC)
 
#define BIDI_TYPE_LRE \
    (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT)
 
#define BIDI_TYPE_RLE \
    (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_RTL)
 
#define BIDI_TYPE_LRO \
    (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_OVERRIDE)
 
#define BIDI_TYPE_RLO \
    (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_RTL | BIDI_MASK_OVERRIDE)
 
#define BIDI_TYPE_PDF \
    (BIDI_MASK_WEAK | BIDI_MASK_EXPLICIT)
 
#define BIDI_TYPE_EN \
    (BIDI_MASK_WEAK | BIDI_MASK_NUMBER)
 
#define BIDI_TYPE_AN \
    (BIDI_MASK_WEAK | BIDI_MASK_NUMBER | BIDI_MASK_ARABIC)
 
#define BIDI_TYPE_ES \
    (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_ES)
 
#define BIDI_TYPE_ET \
    (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_ET)
 
#define BIDI_TYPE_CS \
    (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_CS)
 
#define BIDI_TYPE_NSM \
    (BIDI_MASK_WEAK | BIDI_MASK_NSM)
 
#define BIDI_TYPE_BN \
    (BIDI_MASK_WEAK | BIDI_MASK_SPACE | BIDI_MASK_BN)
 
#define BIDI_TYPE_BS \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_SEPARATOR | BIDI_MASK_BS)
 
#define BIDI_TYPE_SS \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_SEPARATOR | BIDI_MASK_SS)
 
#define BIDI_TYPE_WS \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_WS)
 
#define BIDI_TYPE_ON \
    (BIDI_MASK_NEUTRAL)
 
#define BIDI_TYPE_LRI \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE)
 
#define BIDI_TYPE_RLI \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE | BIDI_MASK_RTL)
 
#define BIDI_TYPE_FSI \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE | BIDI_MASK_FIRST)
 
#define BIDI_TYPE_PDI \
    (BIDI_MASK_NEUTRAL | BIDI_MASK_WEAK | BIDI_MASK_ISOLATE)
 
#define BIDI_TYPE_SENTINEL    (BIDI_MASK_SENTINEL)
 
/* The following are only used internally */
 
/* Weak Left-To-Right */
#define BIDI_TYPE_WLTR      (BIDI_MASK_WEAK)
/* Weak Right-To-Left */
#define BIDI_TYPE_WRTL      (BIDI_MASK_WEAK | BIDI_MASK_RTL)
 
/* Start of text */
#define BIDI_TYPE_SOT       (BIDI_MASK_SENTINEL)
/* End of text */
#define BIDI_TYPE_EOT       (BIDI_MASK_SENTINEL | BIDI_MASK_RTL)
 
#define BIDI_TYPE_PRIVATE   (BIDI_MASK_PRIVATE)
 
/* Is private-use value? */
#define BIDI_IS_PRIVATE(p)  ((p) & BIDI_MASK_PRIVATE)
 
/* Is right to left? */
#define BIDI_IS_RTL(p)      ((p) & BIDI_MASK_RTL)
 
/* Is arabic? */
#define BIDI_IS_ARABIC(p)   ((p) & BIDI_MASK_ARABIC)
 
/* Is right-to-left level? */
#define BIDI_LEVEL_IS_RTL(lev) ((lev) & 1)
 
/* Return the bidi type corresponding to the direction of the level number,
   BIDI_TYPE_LTR for evens and BIDI_TYPE_RTL for odds. */
#define BIDI_LEVEL_TO_DIR(lev) \
    (BIDI_LEVEL_IS_RTL(lev) ? BIDI_TYPE_RTL : BIDI_TYPE_LTR)
 
/* Return the minimum level of the direction, 0 for BIDI_TYPE_LTR and
   1 for BIDI_TYPE_RTL and BIDI_TYPE_AL. */
#define BIDI_DIR_TO_LEVEL(dir) \
    ((BidiLevel) (BIDI_IS_RTL(dir) ? 1 : 0))
 
/* Is strong? */
#define BIDI_IS_STRONG(p)   ((p) & BIDI_MASK_STRONG)
/* Is weak? */
#define BIDI_IS_WEAK(p)     ((p) & BIDI_MASK_WEAK)
/* Is neutral? */
#define BIDI_IS_NEUTRAL(p)  ((p) & BIDI_MASK_NEUTRAL)
/* Is sentinel? */
#define BIDI_IS_SENTINEL(p) ((p) & BIDI_MASK_SENTINEL)
 
/* Is letter: L, R, AL? */
#define BIDI_IS_LETTER(p)   (((p) & BIDI_TYPE_MASK) == BIDI_MASK_LETTER)
 
/* Is number: EN, AN? */
#define BIDI_IS_NUMBER(p)   (((p) & BIDI_TYPE_MASK) == BIDI_MASK_NUMBER)
 
/* Is number separator or terminator: ES, ET, CS? */
#define BIDI_IS_NUMBER_SEPARATOR_OR_TERMINATOR(p) \
    (((p) & BIDI_TYPE_MASK) == BIDI_MASK_NUMSEPTER)
 
/* Is space: BN, BS, SS, WS? */
#define BIDI_IS_SPACE(p)    (((p) & BIDI_TYPE_MASK) == BIDI_MASK_SPACE)
/* Is explicit mark: LRE, RLE, LRO, RLO, PDF? */
#define BIDI_IS_EXPLICIT(p) (((p) & BIDI_TYPE_MASK) == BIDI_MASK_EXPLICIT)
 
/* Is test separator: BS, SS? */
#define BIDI_IS_SEPARATOR(p) ((p) & BIDI_MASK_SEPARATOR)
 
/* Is explicit override: LRO, RLO? */
#define BIDI_IS_OVERRIDE(p) ((p) & BIDI_MASK_OVERRIDE)
 
/* Is isolote: LRO, RLO? */
#define BIDI_IS_ISOLATE(p) (((p) & BIDI_TYPE_MASK) == BIDI_MASK_ISOLATE)
 
/* Is left to right letter: LTR? */
#define BIDI_IS_LTR_LETTER(p) \
    ((p) & (BIDI_MASK_LETTER | BIDI_MASK_RTL) == BIDI_MASK_LETTER)
 
/* Is right to left letter: RTL, AL? */
#define BIDI_IS_RTL_LETTER(p) \
    ((p) & (BIDI_MASK_LETTER | BIDI_MASK_RTL) \
    == (BIDI_MASK_LETTER | BIDI_MASK_RTL))
 
/* Is ES or CS: ES, CS? */
#define BIDI_IS_ES_OR_CS(p) \
    (((p) & BIDI_MISC_MASK) == BIDI_MASK_ES || \
     ((p) & BIDI_MISC_MASK) == BIDI_MASK_CS)
 
/* Change numbers: EN, AN to RTL. */
#define BIDI_NUMBER_TO_RTL(p) \
    (BIDI_IS_NUMBER(p) ? BIDI_TYPE_RTL : (p))
 
/* Is explicit or BN: LRE, RLE, LRO, RLO, PDF, BN? */
#define BIDI_IS_EXPLICIT_OR_BN(p) \
    ((((p) & BIDI_TYPE_MASK) == BIDI_MASK_EXPLICIT) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_BN))
 
/* Is explicit or BN or WS: LRE, RLE, LRO, RLO, PDF, BN, WS? */
#define BIDI_IS_EXPLICIT_OR_BN_OR_WS(p) \
    ((((p) & BIDI_TYPE_MASK) == BIDI_MASK_EXPLICIT) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_BN) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_WS))
 
/* Is explicit or separator or BN or WS: LRE, RLE, LRO, RLO, PDF, BS, SS, BN, WS? */
#define BIDI_IS_EXPLICIT_OR_SEPARATOR_OR_BN_OR_WS(p) \
    ((((p) & BIDI_TYPE_MASK) == BIDI_MASK_EXPLICIT) || \
        ((p) & BIDI_MASK_SEPARATOR) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_BN) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_WS))
 
/* Is explicit or BN or NSM: LRE, RLE, LRO, RLO, PDF, BN, NSM? */
#define BIDI_IS_EXPLICIT_OR_BN_OR_NSM(p) \
    ((((p) & BIDI_TYPE_MASK) == BIDI_MASK_EXPLICIT) || \
        (((p) & BIDI_TYPE_MASK) == BIDI_MASK_NSM) || \
        (((p) & BIDI_MISC_MASK) == BIDI_MASK_BN))
 
/* Override status of an explicit mark:
 * LRO,LRE->LTR, RLO,RLE->RTL, otherwise->ON. */
#define BIDI_EXPLICIT_TO_OVERRIDE_DIR(p) \
    (BIDI_IS_OVERRIDE(p) ? BIDI_LEVEL_TO_DIR(BIDI_DIR_TO_LEVEL(p)) \
        : BIDI_TYPE_ON)
 
/* Change numbers to RTL: EN,AN -> RTL. */
#define BIDI_CHANGE_NUMBER_TO_RTL(p) \
    (BIDI_IS_NUMBER(p) ? BIDI_TYPE_RTL : (p))
 
#define BIDI_PGDIR_LTR  BIDI_TYPE_LTR
#define BIDI_PGDIR_RTL  BIDI_TYPE_RTL
#define BIDI_PGDIR_WLTR BIDI_TYPE_WLTR
#define BIDI_PGDIR_WRTL BIDI_TYPE_WRTL
#define BIDI_PGDIR_ON   BIDI_TYPE_ON
 
/*
 * Define bit masks that joining types are based on, each mask has
 * only one bit set.
 */
#define BIDI_MASK_JOINS_RIGHT       0x01    /* May join to right */
#define BIDI_MASK_JOINS_LEFT        0x02    /* May join to right */
#define BIDI_MASK_ARAB_SHAPES       0x04    /* May Arabic shape */
#define BIDI_MASK_TRANSPARENT       0x08    /* Is transparent */
#define BIDI_MASK_IGNORED           0x10    /* Is ignored */
#define BIDI_MASK_LIGATURED         0x20    /* Is ligatured */
 
/*
 * Define values for BidiJoiningType
 */
 
/* nUn-joining */
#define BIDI_JOINING_TYPE_U_VAL    ( 0 )
 
/* Right-joining */
#define BIDI_JOINING_TYPE_R_VAL    \
    ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_ARAB_SHAPES )
 
/* Dual-joining */
#define BIDI_JOINING_TYPE_D_VAL    \
    ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT \
    | BIDI_MASK_ARAB_SHAPES )
 
/* join-Causing */
#define BIDI_JOINING_TYPE_C_VAL    \
    ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT )
 
/* Left-joining */
#define BIDI_JOINING_TYPE_L_VAL    \
    ( BIDI_MASK_JOINS_LEFT | BIDI_MASK_ARAB_SHAPES )
 
/* Transparent */
#define BIDI_JOINING_TYPE_T_VAL    \
    ( BIDI_MASK_TRANSPARENT | BIDI_MASK_ARAB_SHAPES )
 
/* iGnored */
#define BIDI_JOINING_TYPE_G_VAL    ( BIDI_MASK_IGNORED )
 
/*
 * The equivalent of JoiningType values for ArabicProp
 */
 
/* Primary Arabic Joining Classes (Table 8-2) */
 
/* nUn-joining */
#define BIDI_IS_JOINING_TYPE_U(p)    \
    ( 0 == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT ) ) )
 
/* Right-joining */
#define BIDI_IS_JOINING_TYPE_R(p)    \
    ( BIDI_MASK_JOINS_RIGHT == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT ) ) )
 
/* Dual-joining */
#define BIDI_IS_JOINING_TYPE_D(p)    \
    ( ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT    \
      | BIDI_MASK_ARAB_SHAPES ) == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT    \
        | BIDI_MASK_ARAB_SHAPES ) ) )
 
/* join-Causing */
#define BIDI_IS_JOINING_TYPE_C(p)    \
    ( ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT ) == ( (p) & \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT    \
        | BIDI_MASK_ARAB_SHAPES ) ) )
 
/* Left-joining */
#define BIDI_IS_JOINING_TYPE_L(p)    \
    ( BIDI_MASK_JOINS_LEFT == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT ) ) )
 
/* Transparent */
#define BIDI_IS_JOINING_TYPE_T(p)    \
    ( BIDI_MASK_TRANSPARENT == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED ) ) )
 
/* iGnored */
#define BIDI_IS_JOINING_TYPE_G(p)    \
    ( BIDI_MASK_IGNORED == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED ) ) )
 
/* and for Derived Arabic Joining Classes (Table 8-3) */
 
/* Right join-Causing */
#define BIDI_IS_JOINING_TYPE_RC(p)    \
    ( BIDI_MASK_JOINS_RIGHT == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_RIGHT ) ) )
 
/* Left join-Causing */
#define BIDI_IS_JOINING_TYPE_LC(p)    \
    ( BIDI_MASK_JOINS_LEFT == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_JOINS_LEFT ) ) )
 
/*
 * Defining macros for needed queries, It is fully dependent on the
 * implementation of BidiJoiningType.
 */
 
/* Joins to right: R, D, C? */
#define BIDI_JOINS_RIGHT(p)    ((p) & BIDI_MASK_JOINS_RIGHT)
 
/* Joins to left: L, D, C? */
#define BIDI_JOINS_LEFT(p)    ((p) & BIDI_MASK_JOINS_LEFT)
 
/* May shape: R, D, L, T? */
#define BIDI_ARAB_SHAPES(p)    ((p) & BIDI_MASK_ARAB_SHAPES)
 
/* Is skipped in joining: T, G? */
#define BIDI_IS_JOIN_SKIPPED(p)    \
    ((p) & (BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED))
 
/* Is base that will be shaped: R, D, L? */
#define BIDI_IS_JOIN_BASE_SHAPES(p)    \
    ( BIDI_MASK_ARAB_SHAPES == ( (p) &    \
        ( BIDI_MASK_TRANSPARENT | BIDI_MASK_IGNORED    \
        | BIDI_MASK_ARAB_SHAPES ) ) )
 
#define BIDI_JOINS_PRECEDING_MASK(level)    \
    (BIDI_LEVEL_IS_RTL (level) ? BIDI_MASK_JOINS_RIGHT    \
                      : BIDI_MASK_JOINS_LEFT)
 
#define BIDI_JOINS_FOLLOWING_MASK(level)    \
    (BIDI_LEVEL_IS_RTL (level) ? BIDI_MASK_JOINS_LEFT    \
                      : BIDI_MASK_JOINS_RIGHT)
 
#define BIDI_JOIN_SHAPE(p)    \
    ((p) & ( BIDI_MASK_JOINS_RIGHT | BIDI_MASK_JOINS_LEFT ))
 
#ifdef _MGCHARSET_UNICODE
 
MG_EXPORT UCharGeneralCategory GUIAPI UCharGetCategory(Uchar32 uc);
 
MG_EXPORT UCharBreakType GUIAPI UCharGetBreakType(Uchar32 uc);
 
MG_EXPORT BidiType GUIAPI UCharGetBidiType(Uchar32 uc);
 
MG_EXPORT void GUIAPI UStrGetBidiTypes(const Uchar32* ucs, int nr_ucs,
        BidiType* bdts);
 
MG_EXPORT BidiBracketType GUIAPI UCharGetBracketType(Uchar32 ch);
 
MG_EXPORT void GUIAPI UStrGetBracketTypes(const Uchar32 *ucs,
        const BidiType *bidi_types, int len_ucs,
        BidiBracketType *bracket_types);
 
MG_EXPORT BOOL GUIAPI UCharGetMirror(Uchar32 uc, Uchar32* mirrored);
 
MG_EXPORT BidiJoiningType GUIAPI UCharGetJoiningType(Uchar32 uc);
 
MG_EXPORT void GUIAPI UStrGetJoiningTypes(const Uchar32 *ucs, int nr_ucs,
        BidiJoiningType *joining_types);
 
MG_EXPORT BidiType GUIAPI UBidiGetParagraphDir(const BidiType *bidi_types, int len);
 
MG_EXPORT BidiLevel GUIAPI UBidiGetParagraphEmbeddingLevels(
        const BidiType *bidi_types,
        const BidiBracketType* bracket_types, int len,
        ParagraphDir *paragraph_dir, BidiLevel *embedding_levels);
 
MG_EXPORT BidiLevel GUIAPI UBidiGetParagraphEmbeddingLevelsAlt(
        const Uchar32* ucs, int nr_ucs,
        ParagraphDir *paragraph_dir, BidiLevel *embedding_levels);
 
/*
 * \var typedef void (*CB_REVERSE_ARRAY) (void* extra, int len, int pos)
 * \brief The prototype of the user defined function to reverse an array.
 *
 * The function reverse an array pointed by \a extra from the position
 * specified by \a pos for the length specified by \a len.
 *
 * \sa UBidiReorderLine, BIDILogAChars2VisACharsEx
 */
typedef void (*CB_REVERSE_ARRAY) (void* extra, int len, int pos);
 
MG_EXPORT BidiLevel GUIAPI UBidiReorderLine(Uint32 bidi_flags,
        const BidiType *bidi_types, int len, int off,
        ParagraphDir paragraph_dir, BidiLevel *embedding_levels,
        Uchar32 *visual_str, int *indices_map,
        void* extra, CB_REVERSE_ARRAY cb_reverse_extra);
 
MG_EXPORT void GUIAPI UBidiShapeMirroring(const BidiLevel *embedding_levels,
        int len, Uchar32* ucs);
 
MG_EXPORT void GUIAPI UBidiJoinArabic(const BidiType *bidi_types,
        const BidiLevel *embedding_levels, int len,
        BidiArabicProp *ar_props);
 
MG_EXPORT void GUIAPI UBidiShapeArabic(Uint32 shaping_flags,
        const BidiLevel *embedding_levels, int len,
        BidiArabicProp *ar_props, Uchar32* ucs);
 
MG_EXPORT void GUIAPI UBidiShape(Uint32 shaping_flags,
        const BidiLevel *embedding_levels, int len,
        BidiArabicProp *ar_props, Uchar32* ucs);
 
#define CTR_NONE            0x00
 
#define CTR_CASE_MASK       0x0F
 
#define CTR_CAPITALIZE      0x01
 
#define CTR_UPPERCASE       0x02
 
#define CTR_LOWERCASE       0x03
 
#define CTR_FULL_WIDTH      0x10
 
#define CTR_FULL_SIZE_KANA  0x20
 
#define WBR_NORMAL          0x00
 
#define WBR_BREAK_ALL       0x01
 
#define WBR_KEEP_ALL        0x02
 
#define LBP_NORMAL          0x00
 
#define LBP_LOOSE           0x01
 
#define LBP_STRICT          0x02
 
#define LBP_ANYWHERE        0x03
 
#define BOV_UNKNOWN                 0x0000
 
#define BOV_WHITESPACE              0x8000
 
#define BOV_EXPANDABLE_SPACE        0x0800
 
#define BOV_ZERO_WIDTH              0x0080
 
#define BOV_GB_MASK                 0x7000
 
#define BOV_GB_CHAR_BREAK           0x1000
 
#define BOV_GB_CURSOR_POS           0x2000
 
#define BOV_GB_BACKSPACE_DEL_CH     0x4000
 
#define BOV_WB_MASK                 0x0700
 
#define BOV_WB_WORD_BOUNDARY        0x0100
 
#define BOV_WB_WORD_START           0x0200
 
#define BOV_WB_WORD_END             0x0400
 
#define BOV_SB_MASK                 0x0070
 
#define BOV_SB_SENTENCE_BOUNDARY    0x0010
 
#define BOV_SB_SENTENCE_START       0x0020
 
#define BOV_SB_SENTENCE_END         0x0040
 
#define BOV_LB_MASK                 0x000F
#define BOV_LB_BREAK_FLAG           0x0004
#define BOV_LB_MANDATORY_FLAG       0x0008
 
#define BOV_LB_ALLOWED              (BOV_LB_BREAK_FLAG | 0x0001)
 
#define BOV_LB_MANDATORY            (BOV_LB_BREAK_FLAG | BOV_LB_MANDATORY_FLAG | 0x0002)
 
#define BOV_LB_NOTALLOWED           0x0003
 
typedef Uint16 BreakOppo;
 
MG_EXPORT int GUIAPI UStrGetBreaks(LanguageCode lang_code,
        Uint8 ctr, Uint8 wbr, Uint8 lbp,
        Uchar32* ucs, int nr_ucs, BreakOppo** break_oppos);
 
MG_EXPORT void GUIAPI UStrTailorBreaks(ScriptType writing_system,
        const Uchar32* ucs, int nr_ucs, BreakOppo* break_oppos);
 
MG_EXPORT BOOL GUIAPI IsUCharAlnum(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharAlpha(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharControl(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharDigit(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharGraph(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharLowercase(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharPrint(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharUppercase(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharPunct(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharSpace(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharMark(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharTitle(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharXDigit(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharDefined(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharZeroWidth(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharWide(Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI IsUCharWideCJK(Uchar32 uc);
 
MG_EXPORT Uchar32 UCharToUpper (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToLower (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToTitle (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToFullWidth (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToSingleWidth (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToFullSizeKana (Uchar32 uc);
 
MG_EXPORT Uchar32 GUIAPI UCharToSmallKana (Uchar32 uc);
 
MG_EXPORT BOOL GUIAPI UCharIsArabicVowel(Uchar32 uc);
 
MG_EXPORT int GUIAPI UCharCombiningClass (Uchar32 uc);
 
MG_EXPORT void GUIAPI UCharCanonicalOrdering (Uchar32 *string, int len);
 
MG_EXPORT BOOL GUIAPI UCharCompose (Uchar32 a, Uchar32 b, Uchar32 *ch);
 
MG_EXPORT BOOL GUIAPI UCharDecompose (Uchar32 ch, Uchar32 *a, Uchar32 *b);
 
MG_EXPORT int GUIAPI UCharFullyDecompose (Uchar32 ch, BOOL compat,
        Uchar32 *result, int result_len);
 
MG_EXPORT ScriptType GUIAPI UCharGetScriptType (Uchar32 ch);
 
MG_EXPORT Uint32 GUIAPI ScriptTypeToISO15924 (ScriptType script);
 
MG_EXPORT ScriptType GUIAPI ScriptTypeFromISO15924 (Uint32 iso15924);
 
static inline ScriptType GUIAPI ScriptTypeFromISO15924Code (const char* iso15924)
{
    return ScriptTypeFromISO15924(MAKEDWORD32(iso15924[3],
            iso15924[2], iso15924[1], iso15924[0]));
}
 
typedef enum _UVerticalOrient {
    UCHAR_VOP_U = 0,
    UCHAR_VOP_R,
    UCHAR_VOP_TU,
    UCHAR_VOP_TR,
} UVerticalOrient;
 
typedef enum {
    GLYPH_RUN_DIR_LTR = 0,
    GLYPH_RUN_DIR_RTL,
    GLYPH_RUN_DIR_TTB,
    GLYPH_RUN_DIR_BTT,
} GlyphRunDir;
 
typedef enum {
    GLYPH_GRAVITY_SOUTH = 0,
    GLYPH_GRAVITY_EAST,
    GLYPH_GRAVITY_NORTH,
    GLYPH_GRAVITY_WEST,
    GLYPH_GRAVITY_AUTO,
} GlyphGravity;
 
typedef enum {
    GLYPH_GRAVITY_POLICY_NATURAL,
    GLYPH_GRAVITY_POLICY_STRONG,
    GLYPH_GRAVITY_POLICY_LINE,
    GLYPH_GRAVITY_POLICY_MIXED,
} GlyphGravityPolicy;
 
MG_EXPORT UVerticalOrient GUIAPI UCharGetVerticalOrientation(Uchar32 uc);
 
MG_EXPORT GlyphGravity GUIAPI ScriptGetGlyphGravity(ScriptType script,
        BOOL vertical, GlyphGravity base_gravity, GlyphGravityPolicy policy);
 
GlyphGravity ScriptGetGlyphGravityForWide (ScriptType script,
        BOOL vertical, BOOL wide,
        GlyphGravity base_gravity, GlyphGravityPolicy policy);
 
#endif /* _MGCHARSET_UNICODE */
 
MG_EXPORT int GUIAPI GetFontHeight (HDC hdc);
 
MG_EXPORT int GUIAPI GetMaxFontWidth (HDC hdc);
 
 
MG_EXPORT int GUIAPI GetTextExtent (HDC hdc,
                const char* spText, int len, SIZE* pSize);
 
MG_EXPORT int GUIAPI GetTabbedTextExtent (HDC hdc,
                const char* spText, int len, SIZE* pSize);
 
#define GetTextCharacterExtra(hdc)  GetDCAttr (hdc, DC_ATTR_CHAR_EXTRA)
 
#define GetTextWordExtra(hdc)  GetDCAttr (hdc, DC_ATTR_WORD_EXTRA)
 
#define GetTextAboveLineExtra(hdc)  GetDCAttr (hdc, DC_ATTR_ALINE_EXTRA)
 
#define GetTextBellowLineExtra(hdc) GetDCAttr (hdc, DC_ATTR_BLINE_EXTRA)
 
#define SetTextCharacterExtra(hdc, extra)       \
                SetDCAttr (hdc, DC_ATTR_CHAR_EXTRA, (DWORD) extra)
 
#define SetTextWordExtra(hdc, extra)       \
                SetDCAttr (hdc, DC_ATTR_WORD_EXTRA, (DWORD) extra)
 
#define SetTextAboveLineExtra(hdc, extra)       \
                SetDCAttr (hdc, DC_ATTR_ALINE_EXTRA, (DWORD) extra)
 
#define SetTextBellowLineExtra(hdc, extra)      \
                SetDCAttr (hdc, DC_ATTR_BLINE_EXTRA, (DWORD) extra)
 
#define TA_LEFT         0x0000
#define TA_RIGHT        0x0001
#define TA_CENTER       0x0002
#define TA_X_MASK       0x000F
 
#define TA_TOP          0x0000
#define TA_BASELINE     0x0010
#define TA_BOTTOM       0x0020
#define TA_Y_MASK       0x00F0
 
#define TA_NOUPDATECP   0x0000
#define TA_UPDATECP     0x0100
#define TA_CP_MASK      0x0F00
 
#define GetTextAlign(hdc)         GetDCAttr (hdc, DC_ATTR_TEXT_ALIGN)
 
#define SetTextAlign(hdc, ta_flags)         \
            SetDCAttr (hdc, DC_ATTR_TEXT_ALIGN, (DWORD)ta_flags)
 
#define BIDI_FLAG_LTR       0x00
#define BIDI_FLAG_RTL       0x10
 
#define GetBIDIFlags(hdc)                   \
            GetDCAttr (hdc, DC_ATTR_BIDI_FLAGS)
 
#define SetBIDIFlags(hdc, bidi_flags)       \
            SetDCAttr (hdc, DC_ATTR_BIDI_FLAGS, (DWORD)bidi_flags)
 
MG_EXPORT int GUIAPI TextOutLen (HDC hdc, int x, int y,
                const char* spText, int len);
 
 
MG_EXPORT int GUIAPI TextOutOmitted (HDC hdc, int x, int y,
                const char *mtext, int len, int max_extent);
 
MG_EXPORT int GUIAPI TabbedTextOutLen (HDC hdc, int x, int y,
                const char* spText, int len);
 
MG_EXPORT int GUIAPI TabbedTextOutEx (HDC hdc, int x, int y,
                const char* spText, int nCount,
                int nTabPositions, int *pTabPositions, int nTabOrigin);
 
MG_EXPORT void GUIAPI GetLastTextOutPos (HDC hdc, POINT* pt);
 
#define TextOut(hdc, x, y, text)    TextOutLen (hdc, x, y, text, -1)
 
#define TabbedTextOut(hdc, x, y, text)  TabbedTextOutLen (hdc, x, y, text, -1)
 
#define DT_TOP              0x00000000
#define DT_LEFT             0x00000000
#define DT_CENTER           0x00000001
#define DT_RIGHT            0x00000002
#define DT_VCENTER          0x00000004
#define DT_BOTTOM           0x00000008
#define DT_WORDBREAK        0x00000010
#define DT_SINGLELINE       0x00000020
#define DT_EXPANDTABS       0x00000040
#define DT_TABSTOP          0x00000080
#define DT_NOCLIP           0x00000100
#define DT_EXTERNALLPADING  0x00000200
#define DT_CALCRECT         0x00000400
#define DT_NOPREFIX         0x00000800
#define DT_INTERNAL         0x00001000
#define DT_CHARBREAK        0x00002000
 
typedef struct _DTFIRSTLINE
{
    int nr_chars;
    int startx;
    int starty;
    int width;
    int height;
} DTFIRSTLINE;
 
MG_EXPORT int GUIAPI DrawTextEx2 (HDC hdc, const char* pText, int nCount,
                RECT* pRect, int nIndent, UINT nFormat, DTFIRSTLINE *firstline);
 
#define DrawText(hdc, text, n, rc, format)          \
                DrawTextEx2 (hdc, text, n, rc, 0, format, NULL)
 
#define DrawTextEx(hdc, text, n, rc, indent, format)    \
                DrawTextEx2 (hdc, text, n, rc, indent, format, NULL)
 
#define MYBMP_TYPE_NORMAL       0x00000000
#define MYBMP_TYPE_RLE4         0x00000001
#define MYBMP_TYPE_RLE8         0x00000002
#define MYBMP_TYPE_RGB          0x00000003
#define MYBMP_TYPE_BGR          0x00000004
#define MYBMP_TYPE_RGBA         0x00000005
#define MYBMP_TYPE_MASK         0x0000000F
 
#define MYBMP_FLOW_DOWN         0x00000010
#define MYBMP_FLOW_UP           0x00000020
#define MYBMP_FLOW_MASK         0x000000F0
 
#define MYBMP_TRANSPARENT       0x00000100
#define MYBMP_ALPHACHANNEL      0x00000200
#define MYBMP_ALPHA             0x00000400
 
#define MYBMP_RGBSIZE_3         0x00001000
#define MYBMP_RGBSIZE_4         0x00002000
 
#define MYBMP_LOAD_GRAYSCALE    0x00010000
#define MYBMP_LOAD_ALLOCATE_ONE 0x00020000
#define MYBMP_LOAD_NONE         0x00000000
 
struct _MYBITMAP
{
    DWORD flags;
    int   frames;
    Uint8 depth;
    Uint8 alpha;
    Uint8 reserved [2];
    Uint32 transparent;
 
    Uint32 w;
    Uint32 h;
    Uint32 pitch;
    Uint32 size;
 
    BYTE* bits;
};
 
#define BMP_TYPE_NORMAL         0x00
#define BMP_TYPE_RLE            0x01
#define BMP_TYPE_ALPHA          0x02
#define BMP_TYPE_ALPHACHANNEL   0x04
#define BMP_TYPE_COLORKEY       0x10
#define BMP_TYPE_ALPHA_MASK     0x20
#define BMP_TYPE_REPLACEKEY     0x40
 
struct _BITMAP
{
    Uint8   bmType;
    Uint8   bmBitsPerPixel;
    Uint8   bmBytesPerPixel;
    Uint8   bmAlpha;
    Uint32  bmColorKey;
    Uint32  bmColorRep;
 
    Uint32  bmWidth;
    Uint32  bmHeight;
    Uint32  bmPitch;
    Uint8*  bmBits;
 
    /* Obsolte.
     The private pixel format
    void*   bmAlphaPixelFormat; */
 
    Uint8*  bmAlphaMask;
 
    Uint32  bmAlphaPitch;
};
 
typedef BOOL (* CB_ALLOC_BITMAP_BUFF) (void* context, BITMAP* bmp);
 
typedef void (* CB_ONE_SCANLINE) (void* context, MYBITMAP* my_bmp, int y);
 
MG_EXPORT BOOL GUIAPI RegisterBitmapFileType (const char *ext,
            void* (*init) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal),
            int (*load) (MG_RWops* fp, void* init_info, MYBITMAP *my_bmp,
            CB_ONE_SCANLINE cb, void* context),
            void (*cleanup) (void* init_info),
            int (*save) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal),
            BOOL (*check) (MG_RWops* fp));
 
MG_EXPORT const char* GUIAPI CheckBitmapType (MG_RWops* fp);
 
#define MLS_BLENDMODE_NONE           0x00
#define MLS_BLENDMODE_COLORKEY       0x01
#define MLS_BLENDMODE_ALPHA          0x02
 
#define MLS_INFOMASK_OFFSET          0x01
#define MLS_INFOMASK_BLEND           0x02
#define MLS_INFOMASK_ZORDER          0x04
#define MLS_INFOMASK_ALL             0x07
#define MLS_INFOMASK_ENABLE          0x08
 
MG_EXPORT BOOL GUIAPI mlsSetSlaveScreenInfo (HDC dc_mls, DWORD mask, int offset_x, int offset_y,
        DWORD blend_flags, gal_pixel color_key, int alpha, int z_order);
 
MG_EXPORT BOOL GUIAPI mlsGetSlaveScreenInfo (HDC dc_mls, DWORD mask, int* offset_x, int* offset_y,
                        DWORD blend_flags, gal_pixel* color_key, int* alpha, int* z_order);
MG_EXPORT BOOL GUIAPI mlsEnableSlaveScreen (HDC dc_mls, BOOL enable);
 
#define ERR_BMP_OK              0
#define ERR_BMP_IMAGE_TYPE      -1
#define ERR_BMP_UNKNOWN_TYPE    -2
#define ERR_BMP_CANT_READ       -3
#define ERR_BMP_CANT_SAVE       -4
#define ERR_BMP_NOT_SUPPORTED   -5
#define ERR_BMP_MEM             -6
#define ERR_BMP_LOAD            -7
#define ERR_BMP_FILEIO          -8
#define ERR_BMP_OTHER           -9
#define ERR_BMP_ERROR_SOURCE    -10
 
MG_EXPORT int GUIAPI LoadBitmapEx2 (HDC hdc, PBITMAP pBitmap,
                MG_RWops* area, const char* ext,
                CB_ALLOC_BITMAP_BUFF cb_alloc_buff, void* context);
 
static inline int LoadBitmapEx (HDC hdc, PBITMAP pBitmap,
                MG_RWops* area, const char* ext) {
    return LoadBitmapEx2 (hdc, pBitmap, area, ext, NULL, NULL);
}
 
MG_EXPORT int GUIAPI LoadBitmapFromFile (HDC hdc, PBITMAP pBitmap,
                const char* spFileName);
 
#define LoadBitmap  LoadBitmapFromFile
 
MG_EXPORT int GUIAPI LoadBitmapFromMem (HDC hdc, PBITMAP pBitmap,
                const void* mem, size_t size, const char* ext);
 
MG_EXPORT void GUIAPI UnloadBitmap (PBITMAP pBitmap);
 
MG_EXPORT int GUIAPI SetBitmapKeyColor (HDC hdc, PBITMAP bmp, Uint8 r, Uint8 g, Uint8 b);
 
MG_EXPORT void GUIAPI ReplaceBitmapColor (HDC hdc, PBITMAP pBitmap,
                gal_pixel iOColor, gal_pixel iNColor);
 
MG_EXPORT void GUIAPI HFlipBitmap (BITMAP* bmp, unsigned char* inter_buff);
 
MG_EXPORT void GUIAPI VFlipBitmap (BITMAP* bmp, unsigned char* inter_buff);
 
MG_EXPORT void* GUIAPI InitMyBitmapSL (MG_RWops* area,
                const char* ext, MYBITMAP* my_bmp, RGB* pal);
 
MG_EXPORT int GUIAPI LoadMyBitmapSL (MG_RWops* area, void* load_info,
                MYBITMAP* my_bmp, CB_ONE_SCANLINE cb, void* context);
 
MG_EXPORT int GUIAPI CleanupMyBitmapSL (MYBITMAP* my_bmp, void* load_info);
 
MG_EXPORT int GUIAPI LoadMyBitmapEx (PMYBITMAP my_bmp, RGB* pal,
                MG_RWops* area, const char* ext);
 
MG_EXPORT int GUIAPI LoadMyBitmapFromFile (PMYBITMAP my_bmp, RGB* pal,
                const char* file_name);
 
#define LoadMyBitmap    LoadMyBitmapFromFile
 
MG_EXPORT int GUIAPI LoadMyBitmapFromMem (PMYBITMAP my_bmp, RGB* pal,
                const void* mem, size_t size, const char* ext);
 
MG_EXPORT void GUIAPI UnloadMyBitmap (PMYBITMAP my_bmp);
 
#ifdef _MGMISC_SAVEBITMAP
 
MG_EXPORT int GUIAPI SaveMyBitmapToFile (PMYBITMAP my_bmp, RGB* pal,
                const char* spFileName);
 
MG_EXPORT int GUIAPI SaveBitmapToFile (HDC hdc, PBITMAP pBitmap,
                const char* spFileName);
#define SaveBitmap  SaveBitmapToFile
#endif
 
MG_EXPORT BOOL GUIAPI InitBitmap (HDC hdc, Uint32 w, Uint32 h, Uint32 pitch,
                BYTE* bits, PBITMAP bmp);
 
MG_EXPORT HDC GUIAPI InitSlaveScreenEx (const char* name, const char* mode, int dpi);
 
static inline HDC InitSlaveScreen (const char* name, const char* mode)
{
    return InitSlaveScreenEx(name, mode, GDCAP_DPI_DEFAULT);
}
 
MG_EXPORT void GUIAPI TerminateSlaveScreen (HDC hdc);
MG_EXPORT BOOL GUIAPI InitBitmapPixelFormat (HDC hdc, PBITMAP bmp);
 
MG_EXPORT void GUIAPI DeleteBitmapAlphaPixel (PBITMAP bmp);
 
/* Everything in the pixel format structure is read-only */
typedef struct GAL_PixelFormat {
    GAL_Palette *palette;
 
    Uint8  BitsPerPixel;
    Uint8  BytesPerPixel;
    /* The flag indicating dithered palette */
    Uint8  DitheredPalette;
    /* The flag indicating the Most Significant Bits (MSB)
     * is left when depth is less than 8. */
    Uint8  MSBLeft;
 
    Uint8  Rloss;
    Uint8  Gloss;
    Uint8  Bloss;
    Uint8  Aloss;
    Uint8  Rshift;
    Uint8  Gshift;
    Uint8  Bshift;
    Uint8  Ashift;
    Uint32 Rmask;
    Uint32 Gmask;
    Uint32 Bmask;
    Uint32 Amask;
 
    /* RGB color key information */
    gal_pixel colorkey;
    /* Alpha value information (per-surface alpha) */
    gal_uint8 alpha;
} GAL_PixelFormat;
 
#define _FILL_MYBITMAP
 
#ifndef MYBITMAP_CONTXT
typedef struct _MYBITMAP_CONTXT{
    Uint32 colorKey;
    Uint32 pitch;
    GAL_PixelFormat* AlphaPixelFormat;
    MYBITMAP*  mybmp;
}MYBITMAP_CONTXT;
#endif
 
typedef BYTE* (* CB_DRAW_PIXEL) (HDC hdc, MYBITMAP_CONTXT* mybmp, Uint32 pixel, BYTE* dest);
 
MG_EXPORT int GUIAPI ExpandMyBitmap (HDC hdc, PBITMAP bmp,
                const MYBITMAP* my_bmp, const RGB* pal, int frame);
 
MG_EXPORT void GUIAPI ExpandMonoBitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, Uint32 bg, Uint32 fg);
 
MG_EXPORT void GUIAPI Expand16CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags,
                const RGB* pal, BYTE use_pal_alpha, BYTE alpha);
 
static inline void GUIAPI Expand16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, const RGB* pal)
{
    Expand16CBitmapEx (hdc, bits, pitch, my_bits, my_pitch,
                w, h, flags, pal, FALSE, 0xFF);
}
 
MG_EXPORT void GUIAPI Expand256CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags,
                const RGB* pal, BYTE use_pal_alpha, BYTE alpha,
                CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp);
static inline void GUIAPI Expand256CBitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, const RGB* pal,
                CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp)
{
    Expand256CBitmapEx (hdc, bits, pitch, my_bits, my_pitch,
                w, h, flags, pal, FALSE, 0xFF, cb_draw, mybmp);
}
 
MG_EXPORT void GUIAPI CompileRGBABitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, void* pixel_format,
                CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp);
 
MG_EXPORT void GUIAPI CompileRGBABitmapEx (HDC hdc, BYTE* bits, Uint32 pitch,
                        const BYTE* my_bits, Uint32 my_pitch,
                        Uint32 w, Uint32 h, DWORD flags, void* pixel_format,
                        CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp,
                        BYTE* alpha_mask);
 
#ifdef _FILL_MYBITMAP
MG_EXPORT int GUIAPI FillBoxWithMyBitmap (HDC hdc, int x, int y, MYBITMAP* mybmp, RGB* pal);
 
MG_EXPORT void GUIAPI ExpandPartMonoBitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, Uint32 bg, Uint32 fg,
                int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp);
 
MG_EXPORT void GUIAPI ExpandPart16CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags,
                const RGB* pal, BYTE use_pal_alpha, BYTE alpha,
                int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp);
 
static inline void GUIAPI ExpandPart16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch,
                const BYTE* my_bits, Uint32 my_pitch,
                Uint32 w, Uint32 h, DWORD flags, const RGB* pal,
                int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp)
{
    ExpandPart16CBitmapEx (hdc, bits, pitch, my_bits, my_pitch,
                w, h, flags, pal, FALSE, 0xFF, stepx, cb_draw, mybmp);
}
 
#endif
 
#define CompileRGBBitmap CompileRGBABitmap
 
MG_EXPORT int GUIAPI PaintImageEx (HDC hdc, int x, int y,
                MG_RWops* area, const char* ext);
 
MG_EXPORT int GUIAPI PaintImageFromFile (HDC hdc, int x, int y,
                const char* spFileName);
 
MG_EXPORT int GUIAPI PaintImageFromMem (HDC hdc, int x, int y,
                const void* mem, size_t size, const char* ext);
 
MG_EXPORT int GUIAPI StretchPaintImageEx (HDC hdc, int x, int y, int w, int h,
                MG_RWops* area, const char* ext);
 
MG_EXPORT int GUIAPI StretchPaintImageFromFile (HDC hdc, int x, int y,
                int w, int h, const char* spFileName);
 
MG_EXPORT int GUIAPI StretchPaintImageFromMem (HDC hdc, int x, int y,
                int w, int h, const void* mem, size_t size, const char* ext);
 
#ifdef _MGHAVE_FIXED_MATH
 
MG_EXPORT void GUIAPI RotateBitmap (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle);
 
MG_EXPORT void GUIAPI RotateBitmapVFlip (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle);
 
MG_EXPORT void GUIAPI RotateBitmapHFlip (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle);
 
MG_EXPORT void GUIAPI RotateScaledBitmap (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle, int w, int h);
 
MG_EXPORT void GUIAPI RotateScaledBitmapVFlip (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle, int w, int h);
 
MG_EXPORT void GUIAPI RotateScaledBitmapHFlip (HDC hdc, const BITMAP *bmp,
                int lx, int ty, int angle, int w, int h);
 
MG_EXPORT void GUIAPI PivotBitmap(HDC hdc, const BITMAP *bmp,
                int lx, int ty, int cx, int cy, int angle);
 
MG_EXPORT void GUIAPI PivotScaledBitmapFlip (HDC hdc, const BITMAP *bmp,
                fixed x, fixed y, fixed cx, fixed cy, int angle, fixed scale_x,
                fixed scale_y, BOOL h_flip, BOOL v_flip);
 
#endif /*_MGHAVE_FIXED_MATH*/
 
#ifdef _MGFONT_BMPF
 
MG_EXPORT DEVFONT* GUIAPI CreateBMPDevFont (const char *bmpfont_name,
                const BITMAP* glyph_bmp, const char* start_mchar, int nr_glyphs,
                int glyph_width);
 
MG_EXPORT BOOL GUIAPI AddGlyphsToBMPFont (DEVFONT* dev_font, BITMAP* glyph_bmp,
                const char* start_mchar, int nr_glyphs, int glyph_width);
 
MG_EXPORT void GUIAPI DestroyBMPFont (DEVFONT* dev_font);
 
#endif /* end of _MGFONT_BMPF */
 
typedef Uint32  Achar32;
typedef Uint32  Glyph32;
 
#define INV_ACHAR_VALUE             0xFFFFFFFF
 
#define INV_GLYPH_VALUE             0xFFFFFFFF
 
MG_EXPORT Achar32 GUIAPI GetACharValue (LOGFONT* logfont, const char* mchar,
        int mchar_len, const char* pre_mchar, int pre_len);
 
#ifdef _MGCHARSET_UNICODE
 
MG_EXPORT int GUIAPI GetNextUChar(LOGFONT* logfont, const char* mchar,
        int mchar_len, Uchar32* uc);
 
#endif /* _MGCHARSET_UNICODE */
 
MG_EXPORT Uint32 GUIAPI GetACharType (LOGFONT* logfont, Achar32 chv);
 
typedef enum {
    ACHAR_ISOLATED,
    ACHAR_FINAL,
    ACHAR_INITIAL,
    ACHAR_MEDIAL
} ACHARSHAPETYPE;
 
MG_EXPORT Achar32 GUIAPI GetShapedAChar (LOGFONT* logfont, const char* mchar,
        int mchar_len, ACHARSHAPETYPE shape_type);
 
MG_EXPORT BOOL GUIAPI GetMirrorAChar (LOGFONT* logfont, Achar32 chv,
        Achar32* mirrored);
 
MG_EXPORT BidiType GUIAPI GetACharBidiType (LOGFONT* log_font, Achar32 chv);
 
typedef struct _ACHARMAPINFO {
    int byte_index;
    int char_len;
    BOOL is_rtol;
} ACHARMAPINFO;
 
MG_EXPORT int GUIAPI BIDIGetTextLogicalAChars (LOGFONT* log_font,
        const char* text, int text_len, Achar32** achars,
        ACHARMAPINFO** achars_map);
 
MG_EXPORT void GUIAPI BIDIGetTextRangesLog2Vis (LOGFONT* log_font,
        const char* text, int text_len, int start_index, int end_index,
        int** ranges, int* nr_ranges);
 
MG_EXPORT int GUIAPI BIDIGetTextVisualAChars (LOGFONT* log_font,
        const char* text, int text_len, Achar32** achars,
        ACHARMAPINFO** achars_map);
 
MG_EXPORT BOOL GUIAPI BIDILogAChars2VisACharsEx (LOGFONT* log_font,
        Achar32* achars, int nr_achars, int pel,
        void* extra, CB_REVERSE_ARRAY cb_reverse_extra);
 
MG_EXPORT Achar32* GUIAPI BIDILogAChars2VisAChars (LOGFONT* log_font,
        Achar32* achars, int nr_achars, ACHARMAPINFO* achars_map);
 
MG_EXPORT void GUIAPI BIDIGetLogicalEmbedLevelsEx (LOGFONT* log_font,
        Achar32* achars, int nr_achars, int pel, Uint8** embedding_levels);
 
static inline void BIDIGetLogicalEmbeddLevels (LOGFONT* log_font,
        Achar32* achars, int nr_achars, Uint8** embedding_levels)
{
    BIDIGetLogicalEmbedLevelsEx (log_font, achars, nr_achars, -1,
            embedding_levels);
}
 
MG_EXPORT void GUIAPI BIDIGetVisualEmbedLevelsEx (LOGFONT* log_font,
        Achar32* achars, int nr_achars, int pel, Uint8** embedding_levels);
 
static inline void BIDIGetVisualEmbeddLevels (LOGFONT* log_font,
        Achar32* achars, int nr_achars, Uint8** embedding_levels)
{
    BIDIGetVisualEmbedLevelsEx (log_font, achars, nr_achars, -1,
            embedding_levels);
}
 
/*
 * \fn int GUIAPI DrawACharString (HDC hdc, int x, int y,
 *      Achar32* achars, int nr_achars, int* adv_x, int* adv_y);
 *
 * \brief Draw an abstract character string.
 *
 * This function draws an abstract character string to the specific
 * postion of a DC. Note that this function will ignore all breaks
 * in the Achar32 string.
 *
 * \param hdc The device context.
 * \param x The output start x position.
 * \param y The output start y position.
 * \param achars The pointer to the glyph string.
 * \param nr_achars The number of achars which will be draw.
 * \param adv_x The pointer used to return the advance in x-coordinate of
 *        the glyph string, can be NULL.
 * \param adv_y The pointer used to return the advance in y-coordinate of
 *        the glyph string, can be NULL.
 *
 * \return The advance on baseline.
 */
MG_EXPORT int GUIAPI DrawACharString (HDC hdc, int x, int y, Achar32* achars,
        int nr_achars, int* adv_x, int* adv_y);
 
MG_EXPORT int GUIAPI GetACharsExtent (HDC hdc, Achar32* achars, int nr_achars,
        SIZE* size);
 
MG_EXPORT int GUIAPI GetACharsExtentPoint (HDC hdc, Achar32* achars,
        int nr_achars, int max_extent, SIZE* size);
 
MG_EXPORT Glyph32 GUIAPI GetGlyphValue (LOGFONT* logfont, const char* mchar,
        int mchar_len, const char* pre_mchar, int pre_len);
 
MG_EXPORT Glyph32 GUIAPI GetGlyphValueAlt(LOGFONT* logfont, Achar32 chv);
 
MG_EXPORT int GUIAPI DrawGlyph (HDC hdc, int x, int y, Glyph32 glyph_value,
        int* adv_x, int* adv_y);
 
/*
 * \fn int GUIAPI DrawGlyphString (HDC hdc, Glyph32* glyphs, int nr_glyphs,
 *      const POINT* pts);
 *
 * \brief Draw a glyph string at specified positions.
 *
 * This function draws a glyph string to the specific postions of a DC.
 * Note that this function will ignore all special type (such as zero-width)
 * in the glyph string.
 *
 * \param hdc The device context.
 * \param glyphs The pointer to the glyph string.
 * \param nr_glyphs The number of glyphs which will be draw.
 * \param pts The positions of every glyphs.
 *
 * \return The number of glyphs drawn.
 *
 * \sa DrawGlyphStringEx
 */
MG_EXPORT int GUIAPI DrawGlyphString (HDC hdc, Glyph32* glyphs, int nr_glyphs,
        const POINT* pts);
 
MG_EXPORT int GUIAPI GetGlyphsExtent (HDC hdc, Glyph32* glyphs, int nr_glyphs,
        SIZE* size);
 
MG_EXPORT int GUIAPI GetGlyphsExtentPoint (HDC hdc, Glyph32* glyphs,
        int nr_glyphs, int max_extent, SIZE* size);
 
#define GLYPH_INFO_METRICS      0x01
#define GLYPH_INFO_BMP          0x02
#define GLYPH_INFO_FACE         0x04
 
#define GLYPHBMP_TYPE_MONO      0x00
 
#define GLYPHBMP_TYPE_GREY      0x01
 
#define GLYPHBMP_TYPE_GREY4b    0x02
 
#define GLYPHBMP_TYPE_SUBPIXEL  0x03
 
#define GLYPHBMP_TYPE_PRERENDER 0x04
 
typedef struct _GLYPHINFO {
    Uint32 mask;
 
    int bbox_x, bbox_y, bbox_w, bbox_h;
    int advance_x, advance_y;
 
    int bmp_type;
 
    int bmp_width;
    int bmp_height;
    /* The pitch of the glyph bitmap. */
    int bmp_pitch;
 
    const unsigned char* bits;
 
    BITMAP prbitmap;
 
    void* ft_face;
    const char* file_path;
    Uint32 index;
} GLYPHINFO;
 
MG_EXPORT int GUIAPI GetGlyphInfo (LOGFONT* logfont, Glyph32 glyph_value,
        GLYPHINFO* glyph_info);
 
#ifdef _MGCHARSET_UNICODE
 
#define WSR_NORMAL          0x00
 
#define WSR_PRE             0x01
 
#define WSR_NOWRAP          0x02
 
#define WSR_PRE_WRAP        0x03
 
#define WSR_BREAK_SPACES    0x04
 
#define WSR_PRE_LINE        0x05
 
MG_EXPORT int GUIAPI GetUCharsUntilParagraphBoundary(LOGFONT* logfont,
        const char* mstr, int mstr_len, Uint8 wsr,
        Uchar32** uchars, int* nr_uchars);
 
MG_EXPORT Uchar32 GUIAPI AChar2UChar(LOGFONT* logfont, Achar32 chv);
 
MG_EXPORT int GUIAPI AChars2UChars(LOGFONT* logfont, const Achar32* chs,
        Uchar32* ucs, int n);
 
#define UCHAR2ACHAR(uc) ((uc) | 0x80000000)
 
MG_EXPORT BOOL GUIAPI UChar2AChar(LOGFONT* logfont, Uchar32 uc, Achar32* ac);
 
MG_EXPORT int GUIAPI UChars2AChars(LOGFONT* logfont, const Uchar32* ucs,
        Achar32* acs, int n);
 
#define GRF_WRITING_MODE_MASK               0xF0000000
#define GRF_WRITING_MODE_VERTICAL_FLAG      0x20000000
 
#define GRF_WRITING_MODE_HORIZONTAL_TB      0x00000000
 
#define GRF_WRITING_MODE_HORIZONTAL_BT      0x10000000
 
#define GRF_WRITING_MODE_VERTICAL_RL        0x20000000
 
#define GRF_WRITING_MODE_VERTICAL_LR        0x30000000
 
#define GRF_TEXT_ORIENTATION_MASK           0x0F000000
 
#define GRF_TEXT_ORIENTATION_UPRIGHT        0x00000000
 
#define GRF_TEXT_ORIENTATION_SIDEWAYS       0x01000000
 
#define GRF_TEXT_ORIENTATION_UPSIDE_DOWN    0x02000000
 
#define GRF_TEXT_ORIENTATION_SIDEWAYS_LEFT  0x03000000
 
#define GRF_TEXT_ORIENTATION_AUTO           0x04000000
 
#define GRF_TEXT_ORIENTATION_MIXED          0x05000000
 
#define GRF_TEXT_ORIENTATION_LINE           0x06000000
 
#define GRF_LINE_EXTENT_MASK                0x00C00000
 
#define GRF_LINE_EXTENT_FIXED               0x00000000
 
#define GRF_LINE_EXTENT_VARIABLE            0x00400000
 
#define GRF_INDENT_MASK                     0x00300000
 
#define GRF_INDENT_NONE                     0x00000000
 
#define GRF_INDENT_FIRST_LINE               0x00100000
 
#define GRF_INDENT_HANGING                  0x00200000
 
#define GRF_OVERFLOW_WRAP_MASK              0x000C0000
 
#define GRF_OVERFLOW_WRAP_NORMAL            0x00000000
 
#define GRF_OVERFLOW_WRAP_BREAK_WORD        0x00040000
 
#define GRF_OVERFLOW_WRAP_ANYWHERE          0x00080000
 
#define GRF_OVERFLOW_ELLIPSIZE_MASK         0x00030000
 
#define GRF_OVERFLOW_ELLIPSIZE_NONE         0x00000000
 
#define GRF_OVERFLOW_ELLIPSIZE_START        0x00010000
 
#define GRF_OVERFLOW_ELLIPSIZE_MIDDLE       0x00020000
 
#define GRF_OVERFLOW_ELLIPSIZE_END          0x00030000
 
#define GRF_ALIGN_MASK                      0x0000F000
 
#define GRF_ALIGN_START                     0x00000000
 
#define GRF_ALIGN_END                       0x00001000
 
#define GRF_ALIGN_LEFT                      0x00002000
 
#define GRF_ALIGN_RIGHT                     0x00003000
 
#define GRF_ALIGN_CENTER                    0x00004000
 
#define GRF_ALIGN_JUSTIFY                   0x00005000
 
#define GRF_TEXT_JUSTIFY_MASK               0x00000F00
 
#define GRF_TEXT_JUSTIFY_NONE               0x00000000
 
#define GRF_TEXT_JUSTIFY_AUTO               0x00000100
 
#define GRF_TEXT_JUSTIFY_INTER_WORD         0x00000200
 
#define GRF_TEXT_JUSTIFY_INTER_CHAR         0x00000300
 
#define GRF_HANGING_PUNC_MASK               0x000000F0
 
#define GRF_HANGING_PUNC_NONE               0x00000000
 
#define GRF_HANGING_PUNC_FORCE_END          0x00000010
 
#define GRF_HANGING_PUNC_ALLOW_END          0x00000020
 
#define GRF_HANGING_PUNC_OPEN               0x00000040
 
#define GRF_HANGING_PUNC_CLOSE              0x00000080
 
#define GRF_SPACES_MASK                     0x0000000F
 
#define GRF_SPACES_KEEP                     0x00000000
 
#define GRF_SPACES_REMOVE_START             0x00000001
 
#define GRF_SPACES_REMOVE_END               0x00000002
 
#define GRF_SPACES_HANGE_END                0x00000004
 
typedef enum {
    GLYPH_ORIENT_UPRIGHT        = GLYPH_GRAVITY_SOUTH,
    GLYPH_ORIENT_SIDEWAYS       = GLYPH_GRAVITY_EAST,
    GLYPH_ORIENT_UPSIDE_DOWN    = GLYPH_GRAVITY_NORTH,
    GLYPH_ORIENT_SIDEWAYS_LEFT  = GLYPH_GRAVITY_WEST,
} GlyphOrient;
 
typedef enum {
    GLYPH_HANGED_NONE = 0,
    GLYPH_HANGED_START,
    GLYPH_HANGED_END,
} GlyphHanged;
 
typedef struct _GLYPHEXTINFO {
    int bbox_x, bbox_y, bbox_w, bbox_h;
    int adv_x, adv_y;
    int extra_x, extra_y;
    int line_adv;
    Uint8 suppressed:1;
    Uint8 whitespace:1;
    Uint8 orientation:2;
} GLYPHEXTINFO;
 
typedef struct _GLYPHPOS {
    int x;
    int y;
    int x_off;
    int y_off;
    int advance;
    Uint8 suppressed:1;
    Uint8 whitespace:1;
    Uint8 ellipsis:1;
    Uint8 orientation:2;
    Uint8 hanged:2;
} GLYPHPOS;
 
MG_EXPORT int GUIAPI GetGlyphsExtentFromUChars(LOGFONT* logfont_upright,
        const Achar32* uchars, int nr_uchars, const BreakOppo* break_oppos,
        Uint32 render_flags, int x, int y,
        int letter_spacing, int word_spacing, int tab_size, int max_extent,
        SIZE* line_size, Glyph32* glyphs, GLYPHEXTINFO* glyph_ext_info,
        GLYPHPOS* glyph_pos, LOGFONT** logfont_sideways);
 
/*
 * \fn int GUIAPI DrawGlyphStringEx (HDC hdc,
 *      LOGFONT* logfont_upright, LOGFONT* logfont_sideways,
 *      const Glyph32* glyphs, const GLYPHPOS* glyph_pos, int nr_glyphs)
 * \brief Draw a glyph string at the specified positions and text orientations.
 *
 * This function draws a glyph string to the specific positions and
 * orientations on a DC \a hdc with the logfonts specified by
 * \a logfont_upright and \a logfont_sideways.
 *
 * \param hdc The device context.
 * \param logfont_upright The LOGFONT object used for upright glyphs.
 * \param logfont_sideways The LOGFONT object used for sideways glyphs.
 * \param glyphs The pointer to the glyph string
 * \param glyph_pos The buffer holds the position information
 *      of every glyph.
 * \param nr_glyphs The number of the glyphs should be drawn.
 *
 * \return The number of glyphs really drawn.
 *
 * \note The positions contained in \a glyph_pos are always aligned to
 *      the top-left corner of the output rectangle.
 *
 * \sa GetGlyphsExtentFromUChars
 *
 * Since 4.0.0
 */
MG_EXPORT int GUIAPI DrawGlyphStringEx (HDC hdc,
        LOGFONT* logfont_upright, LOGFONT* logfont_sideways,
        const Glyph32* glyphs, const GLYPHPOS* glyph_pos,
        int nr_glyphs);
 
typedef struct _TEXTRUNS TEXTRUNS;
 
MG_EXPORT TEXTRUNS* GUIAPI CreateTextRuns(
        const Uchar32* ucs, int nr_ucs,
        LanguageCode lang_code, ParagraphDir base_dir,
        const char* logfont_name, RGBCOLOR color, RGBCOLOR bg_color,
        BreakOppo* break_oppos);
 
MG_EXPORT BOOL GUIAPI SetFontNameInTextRuns(TEXTRUNS* truns,
        int start_index, int length, const char* logfont_name);
 
MG_EXPORT const char* GUIAPI GetFontNameInTextRuns(
        const TEXTRUNS* truns, int index);
 
MG_EXPORT BOOL GUIAPI SetTextColorInTextRuns(TEXTRUNS* truns,
        int start_index, int length, RGBCOLOR color);
 
MG_EXPORT RGBCOLOR GUIAPI GetTextColorInTextRuns(
        const TEXTRUNS* truns, int index);
 
MG_EXPORT BOOL GUIAPI SetBackgroundColorInTextRuns(TEXTRUNS* truns,
    int start_index, int length, RGBCOLOR color);
 
MG_EXPORT RGBCOLOR GUIAPI GetBackgroundColorInTextRuns(
        const TEXTRUNS* truns, int index);
 
MG_EXPORT BOOL GUIAPI DestroyTextRuns(TEXTRUNS* truns);
 
MG_EXPORT BOOL GUIAPI InitBasicShapingEngine(TEXTRUNS* truns);
 
#ifdef _MGCOMPLEX_SCRIPTS
 
MG_EXPORT BOOL GUIAPI InitComplexShapingEngine(TEXTRUNS* truns);
 
#endif /* _MGCOMPLEX_SCRIPTS */
 
typedef struct _LAYOUT LAYOUT;
 
typedef struct _LAYOUTLINE LAYOUTLINE;
 
MG_EXPORT LAYOUT* GUIAPI CreateLayout(
        const TEXTRUNS* truns, Uint32 render_flags,
        const BreakOppo* break_oppos, BOOL persist_lines,
        int max_line_extent, int indent,
        int letter_spacing, int word_spacing, int tab_size,
        int* tabs, int nr_tabs);
 
MG_EXPORT BOOL GUIAPI DestroyLayout(LAYOUT* layout);
 
/*
 * \var typedef struct _RENDERDATA RENDERDATA
 * \brief The extra rendering data of the shaped glyph.
 */
typedef struct _RENDERDATA {
    const TEXTRUNS*     truns;
 
    const LAYOUT*       layout;
 
    const LAYOUTLINE*   line;
 
    LOGFONT*            logfont;
 
    Uint32              ta;
 
    Uchar32             uc;
 
    int                 uc_index;
} RENDERDATA;
 
typedef BOOL (*CB_GLYPH_LAID_OUT) (GHANDLE ctxt,
        Glyph32 glyph_value, const GLYPHPOS* glyph_pos,
        const RENDERDATA* render_data);
 
MG_EXPORT LAYOUTLINE* GUIAPI LayoutNextLine(LAYOUT* layout,
        LAYOUTLINE* prev_line, int max_extent, BOOL last_line,
        CB_GLYPH_LAID_OUT cb_laid_out, GHANDLE ctxt);
 
MG_EXPORT BOOL GUIAPI GetLayoutLineSize(const LAYOUTLINE* line,
        SIZE* line_size);
 
MG_EXPORT BOOL GUIAPI GetLayoutLineRect(const LAYOUTLINE* line,
        int* x, int* y, int line_height, RECT* line_rc);
 
MG_EXPORT int GUIAPI CalcLayoutBoundingRect(LAYOUT* layout,
        int max_line_extent, int max_height, int line_height,
        int x, int y, RECT* bounding);
 
MG_EXPORT BOOL DrawShapedGlyph(HDC hdc,
        Glyph32 glyph_value, const GLYPHPOS* glyph_pos,
        const RENDERDATA* render_data);
 
MG_EXPORT int DrawLayoutLine(HDC hdc, const LAYOUTLINE* line,
        int x, int y);
 
#ifdef _MGDEVEL_MODE
typedef struct _TextRun TEXTRUN;
 
MG_EXPORT TEXTRUN* GetNextTextRunInfo(TEXTRUNS* runinfo,
        TEXTRUN* prev,
        const char** fontname, int* start_index, int* length,
        LanguageCode* lang_code, ScriptType* script,
        BidiLevel* embedding_level, Uint8* flags);
 
/* Get layout line information */
MG_EXPORT BOOL GUIAPI GetLayoutLineInfo(LAYOUTLINE* line,
        int* max_extent, int* nr_chars, int* nr_glyphs,
        int** log_widths, int* width, int* height,
        BOOL* is_ellipsized, BOOL* is_wrapped);
#endif
 
#endif /* _MGCHARSET_UNICODE */
 
/*
 * \var typedef struct _COMP_CTXT COMP_CTXT
 * \brief The context information of user defined color composition operators.
 *
 * \sa SetUserCompositionOps
 */
typedef struct _COMP_CTXT {
    gal_uint8* cur_dst;
 
    void* user_comp_ctxt;
 
    gal_pixel skip_pixel;
 
    gal_pixel cur_pixel;
 
    int step;
} COMP_CTXT;
 
/*
 * \var typedef struct _SPAN_CTXT SPAN_CTXT
 * \brief span context
 */
typedef struct _SPAN_CTXT {
    GAL_PixelFormat* dst_format; /* The pixel format of the destination pixels */
    GAL_PixelFormat* src_format; /* The pixel format of the source pixels */
    void * user_context; /* The user context passed to SetColorCompositeFunc */
} SPAN_CTXT;
 
/*
 * \var typedef struct _COMPOSITE_CTXT COMPOSITE_CTXT
 * \brief composite context
 */
typedef struct _COMPOSITE_CTXT {
    HDC dst_dc;
    int comp_mode;
    const int *far_bkmode;
    const int *far_step;
    const gal_pixel *far_skip_pixel;
} COMPOSITE_CTXT;
 
/*
 * \var typedef void (*CB_COMP_SETPIXEL) (COMP_CTXT* comp_ctxt)
 * \brief The prototype of the user defined color composition setpixel.
 *
 * This operator sets a pixel on the \a cur_dst defined in \a comp_ctxt with
 * the cur_pixel defined in \a comp_ctxt.
 *
 * \sa SetUserCompositionOps, COMP_CTXT
 */
typedef void (*CB_COMP_SETPIXEL) (COMP_CTXT* comp_ctxt);
 
/*
 * \var typedef void (*CB_COMP_SETHLINE) (COMP_CTXT* comp_ctxt, int w)
 * \brief The prototype of the user defined color composition sethline.
 *
 * This operator sets a horizital line on the \a cur_dst defined in \a comp_ctxt
 * with the \a cur_pixel defined in \a comp_ctxt, totally \a w pixels.
 *
 * \sa SetUserCompositionOps, COMP_CTXT
 */
typedef void (*CB_COMP_SETHLINE) (COMP_CTXT* comp_ctxt, int w);
 
/*
 * \var typedef void (*CB_COMP_PUTHLINE) (COMP_CTXT* comp_ctxt, gal_uint8* src, int w)
 * \brief The prototype of the user defined color composition puthline.
 *
 * This operator puts the pixels in \a src to a horizital line on the \a cur_dst
 * defined in \a comp_ctxt, totally \a w pixels.
 *
 * \sa SetUserCompositionOps, COMP_CTXT
 */
typedef void (*CB_COMP_PUTHLINE) (COMP_CTXT* comp_ctxt, gal_uint8* src, int bkmode, int w);
 
MG_EXPORT int GUIAPI SetUserCompositionOps (HDC hdc,
        CB_COMP_SETPIXEL comp_setpixel,
        CB_COMP_SETHLINE comp_sethline,
        CB_COMP_PUTHLINE comp_puthline,
        void* user_comp_ctxt);
 
MG_EXPORT GHANDLE GetVideoHandle (HDC hdc);
 
#ifdef _MGGAL_DRM
 
MG_EXPORT int drmGetDeviceFD (GHANDLE video);
 
typedef struct _DrmSurfaceInfo {
    uint32_t handle;
    int prime_fd;
    uint32_t name;
    uint32_t fb_id;
 
    uint32_t width;
    uint32_t height;
    uint32_t pitch;
    uint32_t drm_format;
    size_t size;
    off_t offset;
} DrmSurfaceInfo;
 
MG_EXPORT BOOL drmGetSurfaceInfo (GHANDLE video, HDC hdc, DrmSurfaceInfo* info);
 
MG_EXPORT HDC drmCreateDCFromNameEx (GHANDLE video,
        uint32_t name, uint32_t drm_format, off_t offset,
        uint32_t width, uint32_t height, uint32_t pitch);
 
static inline HDC drmCreateDCFromName (GHANDLE video,
        uint32_t name, uint32_t drm_format,
        uint32_t width, uint32_t height, uint32_t pitch)
{
    return drmCreateDCFromNameEx (video,
        name, drm_format, 0, width, height, pitch);
}
 
MG_EXPORT HDC drmCreateDCFromPrimeFdEx (GHANDLE video,
        int prime_fd, size_t size, uint32_t drm_format, off_t offset,
        uint32_t width, uint32_t height, uint32_t pitch);
 
static inline HDC drmCreateDCFromPrimeFd (GHANDLE video,
        int prime_fd, size_t size, uint32_t drm_format,
        uint32_t width, uint32_t height, uint32_t pitch)
{
    return drmCreateDCFromPrimeFdEx (video,
        prime_fd, size, drm_format, 0, width, height, pitch);
}
 
MG_EXPORT HDC drmCreateDCFromHandleEx (GHANDLE video,
        uint32_t handle, size_t size, uint32_t drm_format, off_t offset,
        uint32_t width, uint32_t height, uint32_t pitch);
 
static inline HDC drmCreateDCFromHandle (GHANDLE video,
        uint32_t handle, size_t size, uint32_t drm_format,
        uint32_t width, uint32_t height, uint32_t pitch)
{
    return drmCreateDCFromHandleEx (video,
        handle, size, drm_format, 0, width, height, pitch);
}
 
#endif /* _MGGAL_DRM */
 
#ifdef _MGGAL_HI3560
 
/* screen attribute type */
#define SCREEN_ATTR_ALPHA_CHANNEL    0x01      // alpha channel
#define SCREEN_ATTR_COLORKEY         0x02      // colorkey
#define SCREEN_ATTR_COLORSPACE       0x03      // colorspace
#define SCREEN_ATTR_ALPHA            0x04
#define SCREEN_NO_EXIST               -99      // screen don't exist
 
/* API speicific to Hi3560 GAL engines */
MG_EXPORT int hi3560GetVideoFD (void);
MG_EXPORT void* hi3560GetFBAddress (void);
MG_EXPORT int hi3560SetScreenAttr (Uint8 siAttr, void* pValue);
 
#endif /* _MGGAL_HI3560 */
 
#ifdef __cplusplus
}
#endif  /* __cplusplus */
 
#endif  /* _MGUI_GDI_H */