gdi.h

Go to the documentation of this file.

/*
 * $Id: gdi.h 13751 2011-03-22 03:08:37Z houhuihua $
 *
 *             MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *                     pSOS, ThreadX, NuCleus, OSE, and Win32.
 *
 *             Copyright (C) 2002-2009 Feynman Software.
 *             Copyright (C) 1998-2002 Wei Yongming.
 */

#ifndef _MGUI_GDI_H
    #define _MGUI_GDI_H

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

extern MG_EXPORT gal_pixel SysPixelIndex [];

extern const MG_EXPORT RGB SysPixelColor [];

#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]

/* Compatiblity definitions */
#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 SysColorIndex       SysPixelIndex

typedef struct _BLOCKHEAP
{
#ifdef _MGRM_THREADS
    pthread_mutex_t lock;
#endif

    size_t          bd_size;
    size_t          heap_size;
    int             free;
    void*           heap;
} BLOCKHEAP;

typedef BLOCKHEAP* PBLOCKHEAP;

MG_EXPORT extern void InitBlockDataHeap (PBLOCKHEAP heap, 
                size_t bd_size, size_t heap_size);

MG_EXPORT extern void* BlockDataAlloc (PBLOCKHEAP heap);

MG_EXPORT extern void BlockDataFree (PBLOCKHEAP heap, void* data);

MG_EXPORT extern 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 (PCLIPRGN region, int x, int y);

MG_EXPORT BOOL GUIAPI RectInRegion (PCLIPRGN region, const RECT* rect);

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          0

/* 
 * This is a system screen DC create for MiniGUI internal usage, for example,
 * menu and z-order operations
 */
#define HDC_SCREEN_SYS      1

#define HDC_INVALID         0xFFFFFFFF

#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

MG_EXPORT unsigned int GUIAPI GetGDCapability (HDC hdc, int iItem);

MG_EXPORT HDC GUIAPI GetDC (HWND hwnd);

MG_EXPORT HDC GUIAPI GetClientDC (HWND hwnd);

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 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)0xFFFFFFFF)

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 GetSecondaryClientDC (HWND hwnd);

MG_EXPORT void GUIAPI ReleaseSecondaryDC (HWND hwnd, HDC hdc);

MG_EXPORT void GUIAPI DeleteSecondaryDC (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_ALINE_EXTRA     7
#define DC_ATTR_BLINE_EXTRA     8

#define DC_ATTR_MAP_MODE        9

#define DC_ATTR_TEXT_ALIGN      10

#ifdef _MGHAVE_ADV_2DAPI

#define DC_ATTR_PEN_TYPE        11
#define DC_ATTR_PEN_CAP_STYLE   12
#define DC_ATTR_PEN_JOIN_STYLE  13
#define DC_ATTR_PEN_WIDTH       14

#define DC_ATTR_BRUSH_TYPE      15

#define NR_DC_ATTRS             16

#else

#define NR_DC_ATTRS             11

#endif


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, 0};
    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);

MG_EXPORT void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh, 
                HDC hddc, int dx, int dy, DWORD dwRop);

MG_EXPORT 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);

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 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_FONT_NAME               31
#define LEN_DEVFONT_NAME            79
#define LEN_UNIDEVFONT_NAME         127

#define FONT_WEIGHT_NIL             '\0'
#define FONT_WEIGHT_ALL             '*'
#define FONT_WEIGHT_BLACK           'c'
#define FONT_WEIGHT_BOLD            'b'
#define FONT_WEIGHT_BOOK            'k'
#define FONT_WEIGHT_DEMIBOLD        'd'
#define FONT_WEIGHT_LIGHT           'l'
#define FONT_WEIGHT_MEDIUM          'm'
#define FONT_WEIGHT_REGULAR         'r'
#define FONT_WEIGHT_SUBPIXEL        's'

#define FS_WEIGHT_MASK              0x000000FF
#define FS_WEIGHT_BLACK             0x00000001
#define FS_WEIGHT_BOLD              0x00000002
#define FS_WEIGHT_BOOK              0x00000004
#define FS_WEIGHT_DEMIBOLD          0x00000006 /* BOOK | BOLD */
#define FS_WEIGHT_LIGHT             0x00000010
#define FS_WEIGHT_MEDIUM            0x00000020
#define FS_WEIGHT_SUBPIXEL          0x00000040
#define FS_WEIGHT_REGULAR           0x00000000

#define FONT_SLANT_NIL              '\0'
#define FONT_SLANT_ALL              '*'
#define FONT_SLANT_ITALIC           'i'
#define FONT_SLANT_OBLIQUE          'o'
#define FONT_SLANT_ROMAN            'r'

#define FS_SLANT_MASK               0x00000F00
#define FS_SLANT_ITALIC             0x00000100
#define FS_SLANT_OBLIQUE            0x00000200
#define FS_SLANT_ROMAN              0x00000000

#define FONT_FLIP_NIL               '\0'
#define FONT_FLIP_HORZ              'H'
#define FONT_FLIP_VERT              'V'
#define FONT_FLIP_HORZVERT          'T'

#define FS_FLIP_MASK                0x0000F000
#define FS_FLIP_HORZ                0x00001000
#define FS_FLIP_VERT                0x00002000
#define FS_FLIP_HORZVERT            0x00003000 /* HORZ | VERT */

#define FONT_OTHER_NIL              '\0'
#define FONT_OTHER_AUTOSCALE        'S'
#define FONT_OTHER_TTFNOCACHE       'N'
#define FONT_OTHER_TTFKERN          'K'
#define FONT_OTHER_TTFNOCACHEKERN   'R'
#define FONT_OTHER_LCDPORTRAIT      'P'
#define FONT_OTHER_LCDPORTRAITKERN  'Q'

#define FS_OTHER_MASK               0x00FF0000
#define FS_OTHER_AUTOSCALE          0x00010000
#define FS_OTHER_TTFNOCACHE         0x00020000
#define FS_OTHER_TTFKERN            0x00040000
#define FS_OTHER_TTFNOCACHEKERN     0x00060000 /* KERN | NOCACHE */
#define FS_OTHER_LCDPORTRAIT        0x00100000
#define FS_OTHER_LCDPORTRAITKERN    0x00140000

/* 
 * Backward compatiblilty definitions. 
 * 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 FS_SETWIDTH_MASK            0x0000F000
#define FS_SETWIDTH_BOLD            0x00001000
#define FS_SETWIDTH_CONDENSED       0x00002000
#define FS_SETWIDTH_SEMICONDENSED   0x00004000
#define FS_SETWIDTH_TTFNOCACHE      0x00008000
#define FS_SETWIDTH_NORMAL          0x00000000
*/

#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 FS_SPACING_MASK             0x000F0000
#define FS_SPACING_MONOSPACING      0x00010000
#define FS_SPACING_PROPORTIONAL     0x00020000
#define FS_SPACING_CHARCELL         0x00000000
*/

#define FONT_UNDERLINE_NIL          '\0'
#define FONT_UNDERLINE_ALL          '*'
#define FONT_UNDERLINE_LINE         'u'
#define FONT_UNDERLINE_NONE         'n'

#define FS_UNDERLINE_MASK           0x00F00000
#define FS_UNDERLINE_LINE           0x00100000
#define FS_UNDERLINE_NONE           0x00000000

#define FONT_STRUCKOUT_NIL          '\0'
#define FONT_STRUCKOUT_ALL          '*'
#define FONT_STRUCKOUT_LINE         's'
#define FONT_STRUCKOUT_NONE         'n'

#define FS_STRUCKOUT_MASK           0x0F000000
#define FS_STRUCKOUT_LINE           0x01000000
#define FS_STRUCKOUT_NONE           0x00000000

#define FONT_TYPE_NAME_LEN          3
#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_ALL          "*"

#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_ALL               0x00FF  /* "all" */

#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               4

struct _DEVFONT;
typedef struct _DEVFONT DEVFONT;

typedef struct _LOGFONT {
    char type [LEN_FONT_NAME + 1];
    char family [LEN_FONT_NAME + 1];
    char charset [LEN_FONT_NAME + 1];
    DWORD style;
    int size;
    int rotation;
    int ascent;
    int descent;
    unsigned short sbc_scale;
    unsigned short mbc_scale;
    DEVFONT* sbc_devfont;
    DEVFONT* mbc_devfont;
} LOGFONT;
typedef LOGFONT*    PLOGFONT;
typedef const LOGFONT*    CPLOGFONT;

struct _WORDINFO;
typedef struct _WORDINFO WORDINFO;

#define MAX_LEN_MCHAR               6

typedef unsigned short  UChar16;
typedef int    UChar32;

#define MCHAR_TYPE_UNKNOWN          0xFFFF
#define MCHAR_TYPE_NUL              0x0000
#define MCHAR_TYPE_CTRL1            0x0100
#define MCHAR_TYPE_BEL              0x0200
#define MCHAR_TYPE_BS               0x0300
#define MCHAR_TYPE_HT               0x0400
#define MCHAR_TYPE_LF               0x0500
#define MCHAR_TYPE_VT               0x0600
#define MCHAR_TYPE_FF               0x0700
#define MCHAR_TYPE_CR               0x0800
#define MCHAR_TYPE_CTRL2            0x0900
#define MCHAR_TYPE_SPACE            0x0A00
#define MCHAR_TYPE_ZEROWIDTH        0x0B00
#define MCHAR_TYPE_GENERIC          0x0C00
#define MCHAR_TYPE_NOSPACING_MARK   0x0001
#define MCHAR_TYPE_LIGATURE         (MCHAR_TYPE_NOSPACING_MARK |0x0D00)
#define MCHAR_TYPE_VOWEL            (MCHAR_TYPE_NOSPACING_MARK |0x0E00)
#define MCHAR_TYPE_VOWEL_ABOVE      (MCHAR_TYPE_VOWEL |0x0002)
#define MCHAR_TYPE_VOWEL_BELLOW     (MCHAR_TYPE_VOWEL |0x0004)

#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

struct _FONTOPS;
struct _CHARSETOPS;

typedef struct _FONTOPS FONTOPS;
typedef struct _CHARSETOPS CHARSETOPS;

/* charops fontops devont structure is  here. */
struct _DEVFONT
{
    char             name [LEN_UNIDEVFONT_NAME + 1];

    DWORD            style;

    FONTOPS*         font_ops;

    CHARSETOPS*      charset_ops;

    struct _DEVFONT* next;

    void*            data;

    void*            relationship;

    BOOL             need_unload;
};

#define SBC_DEVFONT_INFO(logfont) (logfont.sbc_devfont)
#define MBC_DEVFONT_INFO(logfont) (logfont.mbc_devfont)

#define SBC_DEVFONT_INFO_P(logfont) (logfont->sbc_devfont)
#define MBC_DEVFONT_INFO_P(logfont) (logfont->mbc_devfont)

#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);

#ifndef _MGRM_THREADS

MG_EXPORT BOOL GUIAPI InitVectorialFonts (void);


MG_EXPORT void GUIAPI TermVectorialFonts (void);

#endif

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 CreateLogFontByName (const char* font_name);

MG_EXPORT PLOGFONT GUIAPI CreateLogFontIndirect (LOGFONT* logfont);

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*/
} mg_FT_LcdFilter;

MG_EXPORT BOOL GUIAPI ft2SetLcdFilter (LOGFONT* logfont, mg_FT_LcdFilter filter);

#endif

#if defined(_MGFONT_QPF) || defined(_MGFONT_FT2) || defined(_MGFONT_TTF) || defined(_MGFONT_UPF)

MG_EXPORT DEVFONT* GUIAPI LoadDevFontFromFile (const char *devfont_name, 
        const char *file_name);

MG_EXPORT void GUIAPI DestroyDynamicDevFont (DEVFONT **devfont);
#endif

#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);

#ifdef _MGCHARSET_UNICODE

#include <stddef.h>
#include <stdlib.h>

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 */

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);

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 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 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)

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_PRIV_PIXEL     0x00

#ifdef _FOR_MONOBITMAP
  #define BMP_TYPE_MONOKEY      0x40
#endif

struct _BITMAP
{
    Uint8   bmType;
    Uint8   bmBitsPerPixel;
    Uint8   bmBytesPerPixel;
    Uint8   bmAlpha;
    Uint32  bmColorKey;
#ifdef _FOR_MONOBITMAP
    Uint32  bmColorRep;
#endif

    Uint32  bmWidth;
    Uint32  bmHeight;
    Uint32  bmPitch;
    Uint8*  bmBits;

    /*void*   bmAlphaPixelFormat;*/
    Uint8*  bmAlphaMask;

    Uint32  bmAlphaPitch;
};

#include <stdio.h>
#include "endianrw.h"

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 LoadBitmapEx (HDC hdc, PBITMAP pBitmap, 
                MG_RWops* area, const char* ext);

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, int size, const char* ext);

MG_EXPORT void GUIAPI UnloadBitmap (PBITMAP pBitmap);

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, int 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 InitSlaveScreen (const char* name, const char* mode);

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 Expand16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, 
                const BYTE* my_bits, Uint32 my_pitch, 
                Uint32 w, Uint32 h, DWORD flags, const RGB* pal);
                                
MG_EXPORT 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);

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 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);

#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, int 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, int 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);

#ifdef _DEBUG
/*
 * Dump avl tree info
 */
void dump_tree (DEVFONT *dev_font);

/*
 * look up a node in bitmap font avl tree.
 */ 
int avl_look_up (DEVFONT *dev_font, char *start_mchar, int n);

/*
 * destroy bitmap font avl tree.
 */ 
void destroy_avl_tree (DEVFONT *dev_font);

#endif /* end of _DEBUG */

#endif /* end of _MGFONT_BMPF */ 

typedef int Glyph32;
#define INV_GLYPH_VALUE    -1

#define IS_MBC_GLYPH(glyph)  ((glyph) & 0x80000000)

#define SET_MBC_GLYPH(glyph) ((glyph) | 0x80000000)

#define REAL_GLYPH(glyph)    ((glyph) & 0x7FFFFFFF)


#define SELECT_DEVFONT(plogfont, glyph) \
    ((glyph) & 0x80000000 ? \
    (plogfont)->mbc_devfont : \
    (plogfont)->sbc_devfont)

typedef enum {
    GLYPH_ISOLATED,
    GLYPH_FINAL,
    GLYPH_INITIAL,
    GLYPH_MEDIAL
}SHAPETYPE;

typedef struct _GLYPHMAPINFO{
    int byte_index;
    int char_len;
    BOOL is_rtol;
}GLYPHMAPINFO;


#define GLYPH_INFO_TYPE      1
#define GLYPH_INFO_METRICS   2
#define GLYPH_INFO_BMP       4

/*the type of glyph bitmap*/
#define GLYPHBMP_TYPE_MONO      0
#define GLYPHBMP_TYPE_GREY      1
#define GLYPHBMP_TYPE_SUBPIXEL  2
#define GLYPHBMP_TYPE_PRERENDER 3

/*the glyph info structure. */
typedef struct _GLYPHINFO
{
    char mask;
    char glyph_type;
    char bmp_type;

    Uint8 padding;

    int height;
    int descent;

    int advance_x, advance_y;
    int bbox_x, bbox_y;
    int bbox_w, bbox_h;

    size_t bmp_size;
    /* The pitch of the glyph bitmap. */
    int bmp_pitch;
    const unsigned char* bits;

    BITMAP prbitmap;
} GLYPHINFO;

MG_EXPORT Glyph32 GUIAPI GetGlyphValue (LOGFONT* logfont, const char* mchar,
        int mchar_len, const char* pre_mchar, int pre_len);

MG_EXPORT Glyph32 GUIAPI GetGlyphShape (LOGFONT* logfont, const char* mchar,
        int mchar_len, SHAPETYPE shape_type);

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, int x, int y, \
 *      Glyph32* glyph_string, int len, int* adv_x, int* adv_y);
 * \brief Draw a glyph string.
 *
 * This function draws a glyph string to the specific postion of a DC.
 *
 * \param hdc The device context.
 * \param x The output start x position.
 * \param y The output start y position.
 * \param glyph_string The pointer to the glyph string.
 * \param len The length of the glyph string.
 * \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 DrawGlyphString (HDC hdc, int x, int y, Glyph32* glyph_string, 
        int len, int* adv_x, int* adv_y);

MG_EXPORT int GUIAPI GetGlyphInfo (LOGFONT* logfont, Glyph32 glyph_value,
        GLYPHINFO* glyph_info);

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);

MG_EXPORT int GUIAPI BIDIGetTextLogicalGlyphs(LOGFONT* log_font, 
        const char* text, int text_len, Glyph32** glyphs, 
        GLYPHMAPINFO** glyphs_map);

MG_EXPORT int GUIAPI BIDIGetTextVisualGlyphs (LOGFONT* log_font, 
        const char* text, int text_len, Glyph32** glyphs, 
        GLYPHMAPINFO** glyphs_map);

MG_EXPORT Glyph32* GUIAPI BIDILogGlyphs2VisGlyphs (LOGFONT* log_font,
        Glyph32* glyphs, int nr_glyphs, GLYPHMAPINFO* glyphs_map);

MG_EXPORT void GUIAPI GetTextRangesLog2Vis (LOGFONT* log_font, char* text, 
        int text_len, int start_index, int end_index, int** ranges, 
        int* nr_ranges);

MG_EXPORT void GUIAPI BIDIGetLogicalEmbeddLevels (LOGFONT* log_font, 
        Glyph32*  glyphs, int nr_glyphs, Uint8** embedding_level_list);

MG_EXPORT void GUIAPI BIDIGetVisualEmbeddLevels (LOGFONT* log_font, 
        Glyph32* glyphs, int nr_glyphs, Uint8**  embedding_level_list);

/*
 * \var typedef struct _COMP_CTXT COMP_CTXT
 * \brief The context information of user defined color composition operators.
 *
 * \sa SetUserCompositionOps
 * 
 */   
typedef struct _COMP_CTXT {
    int step;

    gal_uint8* cur_dst;

    gal_pixel skip_pixel;

    gal_pixel cur_pixel;

    void* user_comp_ctxt;
} 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 struct _RASTER_CTXT RASTER_CTXT
 * \brief raster context
 */
typedef struct _RASTER_CTXT {
    HDC dst_dc;
} RASTER_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);

#ifdef _MGGAL_HI3560

//#include <hi_api.h>

/* 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 */

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 GetLastMCharLen (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 MB2WCEx (PLOGFONT log_font, void* dest, BOOL wc32, 
                const unsigned char* mchar, int n);
MG_EXPORT int GUIAPI WC2MBEx (PLOGFONT log_font, unsigned char *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);
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);

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif  /* _MGUI_GDI_H */