gdi.h

Go to the documentation of this file.

/*
 * $Id: gdi.h,v 1.213.2.24 2006/06/26 05:38:23 xwyan Exp $
 *
 *             MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *                     pSOS, ThreadX, NuCleus, OSE, and Win32 version 1.6.x
 *
 *             Copyright (C) 2002-2006 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
{
#ifndef _LITE_VERSION
    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;
#ifdef _USE_NEWGAL

    struct _CLIPRECT* prev;
#endif
} CLIPRECT;
typedef CLIPRECT* PCLIPRECT;

/* Clipping Region */
#ifdef _USE_NEWGAL
#define NULLREGION      0x00
#define SIMPLEREGION    0x01
#define COMPLEXREGION   0x02
#endif

typedef struct _CLIPRGN
{
#ifdef _USE_NEWGAL

    BYTE            type;
    BYTE            reserved[3];
#endif

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

#ifdef _USE_NEWGAL

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

#endif

#define HDC_SCREEN          0

#define HDC_INVALID         0

#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

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 void GUIAPI ReleaseDC (HDC hdc);

MG_EXPORT HDC GUIAPI CreatePrivateDC (HWND hwnd);

MG_EXPORT HDC GUIAPI CreatePrivateClientDC (HWND hwnd);

MG_EXPORT HDC GUIAPI GetPrivateClientDC (HWND hwnd);

MG_EXPORT void GUIAPI DeletePrivateDC (HDC hdc);

#ifdef _USE_NEWGAL

#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_RLEACCEL     0x00004000  /* Surface is RLE encoded */

MG_EXPORT HDC GUIAPI CreateCompatibleDCEx (HDC hdc, int width, int height);

MG_EXPORT HDC GUIAPI CreateMemDC (int width, int height, int depth, DWORD flags,
                Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);

MG_EXPORT HDC GUIAPI CreateMemDCFromBitmap (HDC hdc, BITMAP* bmp);

MG_EXPORT HDC GUIAPI CreateMemDCFromMyBitmap (const MYBITMAP* my_bmp, 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);

MG_EXPORT void GUIAPI UnlockDC (HDC hdc);

#define GAL_YV12_OVERLAY  0x32315659    /* Planar mode: Y + V + U  (3 planes) */
#define GAL_IYUV_OVERLAY  0x56555949    /* Planar mode: Y + U + V  (3 planes) */
#define GAL_YUY2_OVERLAY  0x32595559    /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
#define GAL_UYVY_OVERLAY  0x59565955    /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
#define GAL_YVYU_OVERLAY  0x55595659    /* Packed mode: Y0+V0+Y1+U0 (1 plane) */

typedef struct _GAL_Overlay {
    Uint32 format;
    int w;
    int h;
    int planes;
    Uint16 *pitches;
    Uint8 **pixels;

    struct private_yuvhwfuncs *hwfuncs;
    struct private_yuvhwdata *hwdata;

    Uint32 hw_overlay :1;
    Uint32 UnusedBits :31;
} GAL_Overlay;

MG_EXPORT GAL_Overlay* GUIAPI CreateYUVOverlay (int width, int height,
                Uint32 format, HDC hdc);

int GAL_LockYUVOverlay (GAL_Overlay *overlay);

void GAL_UnlockYUVOverlay (GAL_Overlay *overlay);

#define LockYUVOverlay GAL_LockYUVOverlay

#define UnlockYUVOverlay GAL_UnlockYUVOverlay

void GAL_FreeYUVOverlay (GAL_Overlay *overlay);

#define FreeYUVOverlay GAL_FreeYUVOverlay

MG_EXPORT void GUIAPI DisplayYUVOverlay (GAL_Overlay* overlay, 
                const RECT* dstrect);

int GAL_SetGamma (float red, float green, float blue);

#define SetGamma GAL_SetGamma

int GAL_SetGammaRamp (Uint16 *red, Uint16 *green, Uint16 *blue);

#define SetGammaRamp GAL_SetGammaRamp

int GAL_GetGammaRamp (Uint16 *red, Uint16 *green, Uint16 *blue);

#define GetGammaRamp GAL_GetGammaRamp

#else

MG_EXPORT HDC GUIAPI CreateCompatibleDC (HDC hdc);
MG_EXPORT void GUIAPI DeleteCompatibleDC (HDC hdc);

#endif /* _USE_NEWGAL */

#define BM_TRANSPARENT          1
#define BM_OPAQUE               0

#ifdef _USE_NEWGAL

#define DC_ATTR_BK_COLOR        0
#define DC_ATTR_BK_MODE         1
#define DC_ATTR_PEN_COLOR       2
#define DC_ATTR_BRUSH_COLOR     3
#define DC_ATTR_TEXT_COLOR      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

#ifdef _ADV_2DAPI

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

#define DC_ATTR_BRUSH_TYPE      14

#define NR_DC_ATTRS             15

#else

#define NR_DC_ATTRS             10

#endif


MG_EXPORT Uint32 GUIAPI GetDCAttr (HDC hdc, int attr);

MG_EXPORT Uint32 GUIAPI SetDCAttr (HDC hdc, int attr, Uint32 value);

#define GetBkColor(hdc)     (gal_pixel) GetDCAttr (hdc, DC_ATTR_BK_COLOR)

#define GetBkMode(hdc)      (int)       GetDCAttr (hdc, DC_ATTR_BK_MODE)

#define GetPenColor(hdc)    (gal_pixel) GetDCAttr (hdc, DC_ATTR_PEN_COLOR)

#define GetBrushColor(hdc)  (gal_pixel) GetDCAttr (hdc, DC_ATTR_BRUSH_COLOR)

#define GetTextColor(hdc)   (gal_pixel) GetDCAttr (hdc, DC_ATTR_TEXT_COLOR)

#define GetTabStop(hdc)     (int) GetDCAttr (hdc, DC_ATTR_TAB_STOP)

#define SetBkColor(hdc, color)  \
                (gal_pixel) SetDCAttr (hdc, DC_ATTR_BK_COLOR, (DWORD) color)

#define SetBkMode(hdc, mode)    \
                (int) SetDCAttr (hdc, DC_ATTR_BK_MODE, (DWORD) mode)

#define SetPenColor(hdc, color) \
                (gal_pixel) SetDCAttr (hdc, DC_ATTR_PEN_COLOR, (DWORD) color)

#define SetBrushColor(hdc, color)   \
                (gal_pixel) SetDCAttr (hdc, DC_ATTR_BRUSH_COLOR, (DWORD) color)

#define SetTextColor(hdc, color)    \
                (gal_pixel) SetDCAttr (hdc, DC_ATTR_TEXT_COLOR, (DWORD) color)

#define SetTabStop(hdc, value)  \
                (int) SetDCAttr (hdc, DC_ATTR_TAB_STOP, (DWORD) value)

#define ROP_SET         0
#define ROP_AND         1
#define ROP_OR          2
#define ROP_XOR         3

MG_EXPORT int GUIAPI GetRasterOperation (HDC hdc);

MG_EXPORT int GUIAPI SetRasterOperation (HDC hdc, int rop);

#else

MG_EXPORT gal_pixel GUIAPI GetBkColor (HDC hdc);
MG_EXPORT int GUIAPI GetBkMode (HDC hdc);
MG_EXPORT gal_pixel GUIAPI GetTextColor (HDC hdc);
MG_EXPORT gal_pixel GUIAPI SetBkColor (HDC hdc, gal_pixel color);
MG_EXPORT int GUIAPI SetBkMode (HDC hdc, int bkmode);
MG_EXPORT gal_pixel GUIAPI SetTextColor (HDC hdc, gal_pixel color);

MG_EXPORT int GUIAPI GetTabStop (HDC hdc);
MG_EXPORT int GUIAPI SetTabStop (HDC hdc, int new_value);

/* Pen and brush support */
MG_EXPORT gal_pixel GUIAPI GetPenColor (HDC hdc);
MG_EXPORT gal_pixel GUIAPI GetBrushColor (HDC hdc);
MG_EXPORT gal_pixel GUIAPI SetPenColor (HDC hdc, gal_pixel color);
MG_EXPORT gal_pixel GUIAPI SetBrushColor (HDC hdc, gal_pixel color);

#endif /* _USE_NEWGAL */

#ifdef _USE_NEWGAL

MG_EXPORT BOOL 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 HPALETTE GUIAPI GetDefaultPalette (void);

int GUIAPI GetPaletteEntries (HPALETTE hpal, 
                int start, int len, GAL_Color* cmap);

#else

MG_EXPORT int GUIAPI GetPalette (HDC hdc, int start, int len, GAL_Color* cmap);
MG_EXPORT int GUIAPI SetPalette (HDC hdc, int start, int len, GAL_Color* cmap);
MG_EXPORT int GUIAPI SetColorfulPalette (HDC hdc);

#endif /* _USE_NEWGAL */

#ifdef _USE_NEWGAL

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 gal_pixel GUIAPI RGBA2Pixel (HDC hdc, 
                Uint8 r, Uint8 g, Uint8 b, Uint8 a);

MG_EXPORT gal_pixel GUIAPI RGB2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b);

MG_EXPORT void GUIAPI Pixel2RGB (HDC hdc, gal_pixel pixel, 
                Uint8* r, Uint8* g, Uint8* b);

MG_EXPORT void GUIAPI Pixel2RGBA (HDC hdc, gal_pixel pixel, 
                Uint8* r, Uint8* g, Uint8* b, Uint8* a);

#else

MG_EXPORT void GUIAPI SetPixel (HDC hdc, int x, int y, gal_pixel c);
MG_EXPORT void GUIAPI SetPixelRGB (HDC hdc, int x, int y, int r, int g, int b);
MG_EXPORT gal_pixel GUIAPI GetPixel (HDC hdc, int x, int y);
MG_EXPORT void GUIAPI GetPixelRGB (HDC hdc, int x, int y, int* r, int* g, int* b);
MG_EXPORT gal_pixel GUIAPI RGB2Pixel (HDC hdc, int r, int g, int b);

#endif /* USE_NEWGAL */

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

#ifdef _USE_NEWGAL

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 PolygonGenerator (void* context, 
                const POINT* pts, int vertices, CB_POLYGON cb);

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

typedef void* (* CB_GET_LINE_BUFF) (void* context, int y);

typedef void (* CB_LINE_SCALED) (void* context, const void* line, int y);

MG_EXPORT BOOL GUIAPI BitmapDDAScaler (void* context, 
                const BITMAP* src_bmp, int dst_w, int dst_h, 
                CB_GET_LINE_BUFF cb_get_line_buff, 
                CB_LINE_SCALED cb_line_scaled);

MG_EXPORT BOOL GUIAPI BitmapDDAScaler2 (void* context, 
                const BITMAP* src_bmp, int dst_w, int dst_h, 
                CB_GET_LINE_BUFF cb_get_line_buff, 
                CB_LINE_SCALED cb_line_scaled);

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 _ADV_2DAPI

typedef enum
{
  PT_SOLID,
  PT_ON_OFF_DASH,
  PT_DOUBLE_DASH,
} PenType;

#define GetPenType(hdc)                 \
                (PenType) GetDCAttr (hdc, DC_ATTR_PEN_TYPE)

#define SetPenType(hdc, type)           \
                (PenType) 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)                 \
                (PTCapStyle) GetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE)

#define SetPenCapStyle(hdc, style)          \
            (PTCapStyle) SetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE, (DWORD) style)

typedef enum
{
  PT_JOIN_MITER,
  PT_JOIN_ROUND,
  PT_JOIN_BEVEL
} PTJoinStyle;

#define GetPenJoinStyle(hdc)           (PTJoinStyle) GetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE)

#define SetPenJoinStyle(hdc, style)         \
            (PTJoinStyle) SetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE, (DWORD) style)

#define GetPenWidth(hdc)                    \
                (unsigned int) GetDCAttr (hdc, DC_ATTR_PEN_WIDTH)

#define SetPenWidth(hdc, width)             \
                (unsigned int) SetDCAttr (hdc, DC_ATTR_PEN_WIDTH, (DWORD) width)

typedef enum
{
  BT_SOLID,
  BT_TILED,
  BT_STIPPLED,
  BT_OPAQUE_STIPPLED
} BrushType;

#define GetBrushType(hdc)               \
                (BrushType) GetDCAttr (hdc, DC_ATTR_BRUSH_TYPE)

#define SetBrushType(hdc, type)         \
                (BrushType) 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

#else

/* Old GDI drawing functions */
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 Circle (HDC hdc, int sx, int sy, int r);
MG_EXPORT void GUIAPI FillBox (HDC hdc, int x, int y, int w, int h);

#endif

#define MM_TEXT               0
#define MM_ANISOTROPIC        1

#ifdef _USE_NEWGAL

#define GetMapMode(hdc)         (int)GetDCAttr (hdc, DC_ATTR_MAP_MODE)

#define SetMapMode(hdc, mapmode)        \
                (int)SetDCAttr (hdc, DC_ATTR_MAP_MODE, (DWORD)mapmode)

#else

MG_EXPORT int GUIAPI GetMapMode (HDC hdc);
MG_EXPORT void GUIAPI SetMapMode (HDC hdc, int mapmode);

#endif /* _USE_NEWGAL */

#ifdef _USE_NEWGAL

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)

#else

MG_EXPORT void GUIAPI GetViewportExt (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI GetViewportOrg (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI GetWindowExt (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI GetWindowOrg (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI SetViewportExt (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI SetViewportOrg (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI SetWindowExt (HDC hdc, POINT* pPt);
MG_EXPORT void GUIAPI SetWindowOrg (HDC hdc, POINT* pPt);

#endif /* _USE_NEWGAL */

MG_EXPORT void GUIAPI DPtoLP (HDC hdc, POINT* pPt);

MG_EXPORT void GUIAPI LPtoDP (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);

MG_EXPORT void GUIAPI SelectClipRegion (HDC hdc, const CLIPRGN* pRgn);

MG_EXPORT void GUIAPI GetBoundsRect (HDC hdc, RECT* pRect);

MG_EXPORT BOOL GUIAPI RectVisible (HDC hdc, const RECT* pRect);

#ifdef _USE_NEWGAL

MG_EXPORT BOOL GUIAPI GetBitmapFromDC (HDC hdc, 
                int x, int y, int w, int h, BITMAP* bmp);

#else

MG_EXPORT void GUIAPI SaveScreenBox (int x, int y, int w, int h, void* vbuf);
MG_EXPORT void* GUIAPI SaveCoveredScreenBox (int x, int y, int w, int h);
MG_EXPORT void GUIAPI PutSavedBoxOnScreen (int x, int y, int w, int h, void* vbuf);
MG_EXPORT void GUIAPI PutSavedBoxOnDC (HDC hdc, int x, int y, int w, int h, void* vbuf);

MG_EXPORT void GUIAPI ScreenCopy (int sx, int sy, HDC hdc, int dx, int dy);

#endif /* _USE_NEWGAL */

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 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 ScaleBitmap (BITMAP* dst, const BITMAP* src);

MG_EXPORT gal_pixel GUIAPI GetPixelInBitmap (const BITMAP* bmp, int x, int y);

MG_EXPORT BOOL GUIAPI SetPixelInBitmap (const BITMAP* bmp, 
                int x, int y, gal_pixel pixel);

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

#ifdef _USE_NEWGAL

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

#else

MG_EXPORT void GUIAPI SetRect (RECT* prc, int left, int top, 
                int right, int bottom);
MG_EXPORT void GUIAPI SetRectEmpty (RECT* prc);
MG_EXPORT void GUIAPI CopyRect (RECT* pdrc, const RECT* psrc);
MG_EXPORT void GUIAPI OffsetRect (RECT* prc, int x, int y);
MG_EXPORT void GUIAPI InflateRect (RECT* prc, int cx, int cy);
MG_EXPORT void GUIAPI InflateRectToPt (RECT* prc, int x, int y);
MG_EXPORT BOOL GUIAPI PtInRect (const RECT* prc, int x, int y);

#endif

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               15
#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 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_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 FS_OTHER_MASK               0x000F0000
#define FS_OTHER_AUTOSCALE          0x00010000
#define FS_OTHER_TTFNOCACHE         0x00020000

/* 
 * 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_BITMAP_RAW   "rbf"
#define FONT_TYPE_NAME_BITMAP_VAR   "vbf"
#define FONT_TYPE_NAME_BITMAP_QPF   "qpf"
#define FONT_TYPE_NAME_SCALE_TTF    "ttf"
#define FONT_TYPE_NAME_SCALE_T1F    "t1f"
#define FONT_TYPE_NAME_ALL          "*"

#define FONT_TYPE_BITMAP_RAW        0x0001  /* "rbf" */
#define FONT_TYPE_BITMAP_VAR        0x0002  /* "vbf" */
#define FONT_TYPE_BITMAP_QPF        0x0003  /* "qpf" */
#define FONT_TYPE_SCALE_TTF         0x0010  /* "ttf" */
#define FONT_TYPE_SCALE_T1F         0x0011  /* "t1f" */
#define FONT_TYPE_ALL               0xFFFF  /* "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_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;
    unsigned short sbc_scale;
    unsigned short mbc_scale;
    DEVFONT* sbc_devfont;
    DEVFONT* mbc_devfont;
} LOGFONT;
typedef LOGFONT*    PLOGFONT;

struct _WORDINFO;
typedef struct _WORDINFO WORDINFO;

#define MAX_LEN_MCHAR               4

typedef struct _CHARSETOPS
{
    int nr_chars;
    int bytes_per_char;
    int bytes_maxlen_char;
    const char* name;
    char def_char [MAX_LEN_MCHAR];

    int (*len_first_char) (const unsigned char* mstr, int mstrlen);
    unsigned int (*char_offset) (const unsigned char* mchar);

    int (*nr_chars_in_str) (const unsigned char* mstr, int mstrlen);

    int (*is_this_charset) (const unsigned char* charset);

    int (*len_first_substr) (const unsigned char* mstr, int mstrlen);
    const unsigned char* (*get_next_word) (const unsigned char* mstr, 
                int strlen, WORDINFO* word_info);

    int (*pos_first_char) (const unsigned char* mstr, int mstrlen);

#ifdef _UNICODE_SUPPORT
    unsigned short (*conv_to_uc16) (const unsigned char* mchar, int len);
    int (*conv_from_uc16) (unsigned short wc, unsigned char* mchar);
#endif /* LITE_VERSION */
} CHARSETOPS;

typedef struct _FONTOPS
{
    int (*get_char_width) (LOGFONT* logfont, DEVFONT* devfont, 
            const unsigned char* mchar, int len);
    int (*get_ave_width) (LOGFONT* logfont, DEVFONT* devfont);
    int (*get_max_width) (LOGFONT* logfont, DEVFONT* devfont);
    int (*get_font_height) (LOGFONT* logfont, DEVFONT* devfont);
    int (*get_font_size) (LOGFONT* logfont, DEVFONT* devfont, int expect);
    int (*get_font_ascent) (LOGFONT* logfont, DEVFONT* devfont);
    int (*get_font_descent) (LOGFONT* logfont, DEVFONT* devfont);

    const void* (*get_char_bitmap) (LOGFONT* logfont, DEVFONT* devfont, 
            const unsigned char* mchar, int len, unsigned short* scale);
    
    const void* (*get_char_pixmap) (LOGFONT* logfont, DEVFONT* devfont, 
            const unsigned char* mchar, int len, 
            int* pitch, unsigned short* scale);
         /* Can be NULL */

    void (*start_str_output) (LOGFONT* logfont, DEVFONT* devfont);
         /* Can be NULL */
    int (*get_char_bbox) (LOGFONT* logfont, DEVFONT* devfont,
            const unsigned char* mchar, int len,
            int* px, int* py, int* pwidth, int* pheight);
         /* Can be NULL */
    void (*get_char_advance) (LOGFONT* logfont, DEVFONT* devfont,
            const unsigned char* mchar, int len, int* px, int* py);
         /* Can be NULL */

    DEVFONT* (*new_instance) (LOGFONT* logfont, DEVFONT* devfont, 
            BOOL need_sbc_font);
         /* Can be NULL */
    void (*delete_instance) (DEVFONT* devfont);
         /* Can be NULL */
} FONTOPS;

struct _DEVFONT
{
    char             name [LEN_UNIDEVFONT_NAME + 1];
    DWORD            style;
    FONTOPS*         font_ops;
    CHARSETOPS*      charset_ops;
    struct _DEVFONT* sbc_next;
    struct _DEVFONT* mbc_next;
    void*            data;
};

#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 unsigned char* mchar, int mchar_len, 
                GLYPHBITMAP* glyph_bitmap);

#ifdef _LITE_VERSION

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

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

#include <stdlib.h>

MG_EXPORT int GUIAPI MB2WC (PLOGFONT log_font, 
                wchar_t* dest, const unsigned char* mstr, int n);

MG_EXPORT int GUIAPI WC2MB (PLOGFONT log_font, unsigned char *s, wchar_t wc);

MG_EXPORT int GUIAPI MBS2WCS (PLOGFONT log_font, wchar_t* dest, 
                const unsigned char* mstr, int mstr_len, int n);

MG_EXPORT int GUIAPI WCS2MBS (PLOGFONT log_font, unsigned char* dest, 
                const wchar_t *wcs, int wcs_len, int n);

#endif /* _UNICODE_SUPPORT */

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 void GUIAPI GetTextExtent (HDC hdc, 
                const char* spText, int len, SIZE* pSize);

MG_EXPORT void GUIAPI GetTabbedTextExtent (HDC hdc, 
                const char* spText, int len, SIZE* pSize);

#ifdef _USE_NEWGAL

#define GetTextCharacterExtra(hdc)  (int)GetDCAttr (hdc, DC_ATTR_CHAR_EXTRA)

#define GetTextAboveLineExtra(hdc)  (int)GetDCAttr (hdc, DC_ATTR_ALINE_EXTRA)

#define GetTextBellowLineExtra(hdc) (int)GetDCAttr (hdc, DC_ATTR_BLINE_EXTRA)

#define SetTextCharacterExtra(hdc, extra)       \
                (int)SetDCAttr (hdc, DC_ATTR_CHAR_EXTRA, (DWORD) extra)

#define SetTextAboveLineExtra(hdc, extra)       \
                (int)SetDCAttr (hdc, DC_ATTR_ALINE_EXTRA, (DWORD) extra)

#define SetTextBellowLineExtra(hdc, extra)      \
                (int)SetDCAttr (hdc, DC_ATTR_BLINE_EXTRA, (DWORD) extra)

#else

MG_EXPORT int GUIAPI GetTextCharacterExtra (HDC hdc);
MG_EXPORT int GUIAPI SetTextCharacterExtra (HDC hdc, int extra);
MG_EXPORT int GUIAPI GetTextAboveLineExtra (HDC hdc);
MG_EXPORT int GUIAPI SetTextAboveLineExtra (HDC hdc, int extra);
MG_EXPORT int GUIAPI GetTextBellowLineExtra (HDC hdc);
MG_EXPORT int GUIAPI SetTextBellowLineExtra (HDC hdc, int extra);

#endif /* _USE_NEWGAL */

MG_EXPORT int GUIAPI TextOutLen (HDC hdc, int x, int y, 
                const char* spText, int len);

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

#ifdef _USE_NEWGAL

#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_PRIV_PIXEL     0x20

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

#else

#define BMP_TYPE_NORMAL         0x00
#define BMP_TYPE_COLORKEY       0x01

/* expanded bitmap struct */
struct _BITMAP
{
    Uint8   bmType;
    Uint8   bmBitsPerPixel;
    Uint8   bmBytesPerPixel;
    Uint8   bmReserved;

    Uint32  bmColorKey;

    Uint32  bmWidth;
    Uint32  bmHeight;
    Uint32  bmPitch;

    void*   bmBits;
    Uint32  bmReserved1;
};

#endif /* _USE_NEWGAL */

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


void GUIAPI HFlipBitmap (BITMAP* bmp, unsigned char* inter_buff);
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 _SAVE_BITMAP

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

#ifdef _USE_NEWGAL

MG_EXPORT BOOL GUIAPI InitBitmapPixelFormat (HDC hdc, PBITMAP bmp);

MG_EXPORT void GUIAPI DeleteBitmapAlphaPixel (PBITMAP bmp);

MG_EXPORT int GUIAPI ExpandMyBitmap (HDC hdc, PBITMAP bmp, 
                const MYBITMAP* my_bmp, const RGB* pal, int frame);

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

#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 _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 /*_FIXED_MATH*/

#else

MG_EXPORT int GUIAPI ExpandMyBitmap (HDC hdc, const MYBITMAP* pMyBitmap, 
                const RGB* pal, PBITMAP pBitmap);
MG_EXPORT void GUIAPI ExpandMonoBitmap (HDC hdc, int w, int h, 
                const BYTE* my_bits, int my_pitch, int bits_flow, 
                BYTE* bitmap, int pitch, int bg, int fg);
MG_EXPORT void GUIAPI Expand16CBitmap (HDC hdc, int w, int h, 
                const BYTE* my_bits, int my_pitch, int bits_flow,
                BYTE* bitmap, int pitch, const RGB* pal);
MG_EXPORT void GUIAPI Expand256CBitmap (HDC hdc, int w, int h, 
                const BYTE* my_bits, int my_pitch, int bits_flow,
                BYTE* bitmap, int pitch, const RGB* pal);
MG_EXPORT void GUIAPI CompileRGBBitmap (HDC hdc, int w, int h, 
                const BYTE* my_bits, int my_pitch, int bits_flow,
                BYTE* bitmap, int pitch, int rgb_order);

#endif /* _USE_NEWGAL */

#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif  /* _MGUI_GDI_H */

---