/****************************************************************************
*
*						MegaGraph Graphics Library
*
*                   Copyright (C) 1996 SciTech Software.
*							All rights reserved.
*
* Filename:		$Workfile:   mgraph.h  $
* Version:		$Revision:   1.29  $
*
* Language:		ANSI C
* Environment:	IBM PC (MS DOS)
*
* Description:	Header file for the MegaGraph Graphics Library. You can
*				defined one of the following to specify which MGL API you
*				wish to use.
*
*					MGL_LITE	- Compile for the MGL/Lite API
*					MGL_PRO		- Compile for the MGL/Pro API
*					MGL_FIX3D	- Compile for the MGL/3D API (fixed point)
*					MGL_FLT3D	- Compile for the MGL/3D API (floating point)
*
*				If you do not define any of these, MGL_FIX3D will be defined
*				automatically for compatibility with older versions of the
*				MGL.
*
* $Date:   11 Mar 1997 16:46:42  $ $Author:   KendallB  $
*
****************************************************************************/

#ifndef	__MGRAPH_H
#  define	__MGRAPH_H

#  include <stdio.h>

#  ifndef	__DEBUG_H
#    include "debug.h"
#  endif

#  if	!defined(MGL_LITE) && !defined(MGL_PRO) && !defined(MGL_FIX3D) \
	&& !defined(MGL_FLT3D)
#    define	MGL_FIX3D
#  endif

#  if	defined(MGL_FIX3D) || defined(MGL_FLT3D)
#    define	MGL_3D
#  endif

/*---------------------- Macros and type definitions ----------------------*/

#  pragma pack(1)                      /* Pack structures to byte granularity          */

/*
 * Define the version number for the MGL release 
 */

#  define MGL_VERSION_STR     "3.1"

/*
 * Define the calling conventions for all public MGL functions. If we
 * * are compiling the MGL as a DLL, then all public functions are compiled
 * * and exported with standard C calling conventions, otherwise we use
 * * the default calling conventions provided by the compiler.
 * *
 * * Note that because Watcom C++ uses register based parameter passing
 * * by default we also provide special DLL's for watcom that are compiled
 * * with register parameter passing. This is necessary to work with all
 * * the extra libraries provided as they are all compiled to call MGL
 * * functions with arguments in registers whenever possible. You can still
 * * use the standard DLL but if you do you will need to re-compile all
 * * of the extra libraries with the MGL_DLL #define to change the calling
 * * conventions for the MGL functions.
 */

#  if		defined(MGL_DLL)
#    define	MGLAPI	_EXPORT __cdecl
#  else
#    define	MGLAPI	_EXPORT _PUBAPI
#  endif
#  define	ASMAPI	_EXPORT __cdecl

/*
 * Define a type for integers used in the library. For most environments
 * * we simply define it as a normal integer (16 or 32 bits), however for
 * * 16 bit Windows it is defined as a 32 bit integer as all the real code
 * * lives in a 32 bit DLL that uses 32 bit integers.
 */

#  ifndef	__M_INT_DEFINED
#    if	defined(__WINDOWS16__)
typedef long  m_int;
typedef unsigned long m_uint;
#    else
typedef int   m_int;
typedef unsigned int m_uint;
#    endif
#    define	__M_INT_DEFINED
#  endif

/*
 * Define the graphics subsystems available     
 */

typedef enum {
    grDETECT = -1,                     /* Auto detect the graphics subsystem           */
    grNONE = 0,                        /* No graphics hardware detected                        */
    grVGA,                             /* Standard VGA                                                         */
    grVESA,                            /* VESA VBE compliant SuperVGA                          */
    grSVGA,                            /* Unaccelerated SuperVGA                                       */
    grACCEL,                           /* Accelerated SuperVGA                                         */
    grDDRAW,                           /* Unaccelerated DirectDraw                                     */
    grDDRAWACCEL,                      /* Accelerated DirectDraw                                       */
    grDDRAW3D,                         /* 3D Accelerated DirectDraw                            */
    grMAXDRIVER,                       /* Maximum driver number                                        */
} MGL_driverType;

/*
 * Graphics modes supported     - the only video modes supported by this
 * * graphics library are those that support at least 16 colors per pixel.
 */

typedef enum {
    /*
     * 16 color VGA video modes 
     */

    grVGA_320x200x16,
    grVGA_640x200x16,
    grVGA_640x350x16,
    grVGA_640x400x16,
    grVGA_640x480x16,
    grSVGA_800x600x16,

    /*
     * 256 color VGA ModeX video modes 
     */

    grVGAX_320x200x256,
    grVGAX_320x240x256,
    grVGAX_320x400x256,
    grVGAX_320x480x256,

    /*
     * 256 color VGA video modes 
     */

    grVGA_320x200x256,

    /*
     * 256 color VGA/SuperVGA video modes 
     */

    grSVGA_320x200x256,
    grSVGA_320x240x256,
    grSVGA_320x400x256,
    grSVGA_320x480x256,
    grSVGA_400x300x256,
    grSVGA_512x384x256,
    grSVGA_640x350x256,
    grSVGA_640x400x256,
    grSVGA_640x480x256,
    grSVGA_800x600x256,
    grSVGA_1024x768x256,
    grSVGA_1152x864x256,
    grSVGA_1280x960x256,
    grSVGA_1280x1024x256,
    grSVGA_1600x1200x256,

    /*
     * 32,768 color Super VGA video modes 
     */

    grSVGA_320x200x32k,
    grSVGA_320x240x32k,
    grSVGA_320x400x32k,
    grSVGA_320x480x32k,
    grSVGA_400x300x32k,
    grSVGA_512x384x32k,
    grSVGA_640x350x32k,
    grSVGA_640x400x32k,
    grSVGA_640x480x32k,
    grSVGA_800x600x32k,
    grSVGA_1024x768x32k,
    grSVGA_1152x864x32k,
    grSVGA_1280x960x32k,
    grSVGA_1280x1024x32k,
    grSVGA_1600x1200x32k,

    /*
     * 65,536 color Super VGA video modes 
     */

    grSVGA_320x200x64k,
    grSVGA_320x240x64k,
    grSVGA_320x400x64k,
    grSVGA_320x480x64k,
    grSVGA_400x300x64k,
    grSVGA_512x384x64k,
    grSVGA_640x350x64k,
    grSVGA_640x400x64k,
    grSVGA_640x480x64k,
    grSVGA_800x600x64k,
    grSVGA_1024x768x64k,
    grSVGA_1152x864x64k,
    grSVGA_1280x960x64k,
    grSVGA_1280x1024x64k,
    grSVGA_1600x1200x64k,

    /*
     * 16 million color, 24 bits per pixel Super VGA video modes 
     */

    grSVGA_320x200x16m,
    grSVGA_320x240x16m,
    grSVGA_320x400x16m,
    grSVGA_320x480x16m,
    grSVGA_400x300x16m,
    grSVGA_512x384x16m,
    grSVGA_640x350x16m,
    grSVGA_640x400x16m,
    grSVGA_640x480x16m,
    grSVGA_800x600x16m,
    grSVGA_1024x768x16m,
    grSVGA_1152x864x16m,
    grSVGA_1280x960x16m,
    grSVGA_1280x1024x16m,
    grSVGA_1600x1200x16m,

    /*
     * 16 million color, 32 bits per pixel Super VGA video modes 
     */

    grSVGA_320x200x4G,
    grSVGA_320x240x4G,
    grSVGA_320x400x4G,
    grSVGA_320x480x4G,
    grSVGA_400x300x4G,
    grSVGA_512x384x4G,
    grSVGA_640x350x4G,
    grSVGA_640x400x4G,
    grSVGA_640x480x4G,
    grSVGA_800x600x4G,
    grSVGA_1024x768x4G,
    grSVGA_1152x864x4G,
    grSVGA_1280x960x4G,
    grSVGA_1280x1024x4G,
    grSVGA_1600x1200x4G,

    /*
     * Render into Windowing System DC (Windows, OS/2 PM, X11) 
     */

    grWINDOWED,

    grMAXMODE,                         /* Maximum mode number                                  */
} MGL_modeType;

/*
 * MGL_result() error codes     
 */

typedef enum {
    grOK = 0,                          /* No error                                                                     */
    grNoInit = -1,                     /* Graphics driver has not been installed       */
    grNotDetected = -2,                /* Graphics hardware was not detected           */
    grDriverNotFound = -3,             /* Graphics driver file not found                       */
    grBadDriver = -4,                  /* File loaded was not a graphics driver        */
    grLoadMem = -5,                    /* Not enough memory to load graphics driver */
    grInvalidMode = -6,                /* Invalid graphics mode for selected driver */
    grError = -8,                      /* General graphics error                                       */
    grInvalidName = -9,                /* Invalid driver name                                          */
    grNoMem = -10,                     /* Not enough memory to perform operation       */
    grNoModeSupport = -11,             /* Select video mode not supported by hard.     */
    grInvalidFont = -12,               /* Invalid font data                                            */
    grBadFontFile = -13,               /* File loaded was not a font file                      */
    grFontNotFound = -14,              /* Font file was not found                                      */
    grOldDriver = -15,                 /* Driver file is an old version                        */
    grInvalidDevice = -16,             /* Invalid device for selected operation        */
    grInvalidDC = -17,                 /* Invalid device context                                       */
    grInvalidCursor = -18,             /* Invalid cursor file                                          */
    grCursorNotFound = -19,            /* Cursor file was not found                            */
    grInvalidIcon = -20,               /* Invalid icon file                                            */
    grIconNotFound = -21,              /* Icon file was not found                                      */
    grInvalidBitmap = -22,             /* Invalid bitmap file                                          */
    grBitmapNotFound = -23,            /* Bitmap file was not found                            */
    grZbufferTooBig = -24,             /* Zbuffer allocation is too large                      */
    grNewFontFile = -25,               /* Only Windows 2.x font files supported        */
    grNoDoubleBuff = -26,              /* Double buffering is not available            */
    grNoHardwareBlt = -28,             /* No hardware bitBlt for OffscreenDC           */
    grNoOffscreenMem = -29,            /* No available offscreen memory                        */
    grInvalidPF = -30,                 /* Invalid pixel format for memory DC           */

    grLastError = -31,                 /* Last error number in list                            */
} MGL_errorType;

#  define	MGL_CLIPON		true
#  define	MGL_CLIPOFF		false

/*
 * Color mapped modes 
 */

typedef enum {
    MGL_CMAP_MODE,                     /* Normal Color mapped mode     */
    MGL_DITHER_RGB_MODE,               /* 24 bit RGB halftone dithered */
} MGL_colorModes;

/*
 * Standard colors - this is the standard set of colors for the IBM PC. The
 * * default palette will have been programmed to contain these values when a
 * * graphics modes is started. If the palette has been changed, they will
 * * not correspond to the actual colors on the screen. Under a Windowing
 * * manage environment these colors will also not be setup by default.
 */

enum MGL_COLORS {
    MGL_BLACK,                         /* dark colors  */
    MGL_BLUE,
    MGL_GREEN,
    MGL_CYAN,
    MGL_RED,
    MGL_MAGENTA,
    MGL_BROWN,
    MGL_LIGHTGRAY,
    MGL_DARKGRAY,                      /* light colors */
    MGL_LIGHTBLUE,
    MGL_LIGHTGREEN,
    MGL_LIGHTCYAN,
    MGL_LIGHTRED,
    MGL_LIGHTMAGENTA,
    MGL_YELLOW,
    MGL_WHITE,
};

/*
 * Windows standard color indices for 256 color bitmaps. 8,9,246,247 are
 * * reserved and you should not count on these colors always being the
 * * same. For 16 color bitmaps, colors 248-255 map to colors 8-15.
 */

enum MGL_WIN_COLORS {
    MGL_WIN_BLACK = 0,
    MGL_WIN_DARKRED = 1,
    MGL_WIN_DARKGREEN = 2,
    MGL_WIN_DARKYELLOW = 3,
    MGL_WIN_DARKBLUE = 4,
    MGL_WIN_DARKMAGENTA = 5,
    MGL_WIN_DARKCYAN = 6,
    MGL_WIN_LIGHTGRAY = 7,
    MGL_WIN_TURQUOISE = 8,             /* Reserved; dont count on this */
    MGL_WIN_SKYBLUE = 9,               /* Reserved; dont count on this */
    MGL_WIN_CREAM = 246,               /* Reserved; dont count on this */
    MGL_WIN_MEDIUMGRAY = 247,          /* Reserved; dont count on this */
    MGL_WIN_DARKGRAY = 248,
    MGL_WIN_LIGHTRED = 249,
    MGL_WIN_LIGHTGREEN = 250,
    MGL_WIN_LIGHTYELLOW = 251,
    MGL_WIN_LIGHTBLUE = 252,
    MGL_WIN_LIGHTMAGENTA = 253,
    MGL_WIN_LIGHTCYAN = 254,
    MGL_WIN_WHITE = 255,
};

typedef enum {
    MGL_MARKER_SQUARE,
    MGL_MARKER_CIRCLE,
    MGL_MARKER_X,
} MGL_markerStyleType;

typedef enum {                         /* Write mode operators                         */
    MGL_REPLACE_MODE,                  /* Replace mode                                         */
    MGL_AND_MODE,                      /* AND mode                                                     */
    MGL_OR_MODE,                       /* OR mode                                                      */
    MGL_XOR_MODE,                      /* XOR mode                                                     */
} MGL_writeModeType;

typedef enum {
    MGL_BITMAP_SOLID,
    MGL_BITMAP_OPAQUE,
    MGL_BITMAP_TRANSPARENT,
    MGL_PIXMAP,
} MGL_fillStyleType;

typedef enum {
    MGL_LINE_PENSTYLE,                 /* Line drawn in current pen style      */
    MGL_LINE_STIPPLE,                  /* Line drawn with current stipple      */
} MGL_lineStyleType;

typedef enum {
    MGL_CONVEX_POLYGON,                /* Monotone vertical polygon            */
    MGL_COMPLEX_POLYGON,               /* Non-Simple polygons                          */
    MGL_AUTO_POLYGON,                  /* Auto detect the polygon type         */
} MGL_polygonType;

/*
 * Text manipulation defines 
 */

typedef enum {
    MGL_LEFT_TEXT = 0,                 /* Justify from left                            */
    MGL_TOP_TEXT = 0,                  /* Justify from top                                     */
    MGL_CENTER_TEXT = 1,               /* Center the text                                      */
    MGL_RIGHT_TEXT = 2,                /* Justify from right                           */
    MGL_BOTTOM_TEXT = 2,               /* Justify from bottom                          */
    MGL_BASELINE_TEXT = 3,             /* Justify from the baseline            */
} MGL_textJustType;

typedef enum {
    MGL_LEFT_DIR = 0,                  /* Text goes to left                            */
    MGL_UP_DIR = 1,                    /* Text goes up                                         */
    MGL_RIGHT_DIR = 2,                 /* Text goes right                                      */
    MGL_DOWN_DIR = 3,                  /* Text goes down                                       */
} MGL_textDirType;

/*
 * Font types 
 */

typedef enum {
    MGL_VECTORFONT = 1,                /* Vector font                                          */
    MGL_FIXEDFONT,                     /* Fixed width bitmap font                      */
    MGL_PROPFONT,                      /* Proportional width bitmap font       */
} MGL_fontType;

/*
 * Palette rotation directions 
 */

typedef enum {
    MGL_ROTATE_UP,                     /* Rotate the palette values up         */
    MGL_ROTATE_DOWN,                   /* Rotate the palette values down       */
} MGL_palRotateType;

/*
 * Border drawing routine styles 
 */

typedef enum {
    MGL_BDR_INSET,                     /* Interior is inset into screen        */
    MGL_BDR_OUTSET,                    /* Interior is outset from screen       */
    MGL_BDR_OUTLINE,                   /* Border is 3d outline                         */
} MGL_bdrStyleType;

/*
 * Standard display driver names        
 */

#  define	MGL_VGA4NAME		"VGA4.DRV"
                                                /* Standard VGA drivers                 */
#  define	MGL_VGA8NAME		"VGA8.DRV"
#  define	MGL_VGAXNAME		"VGAX.DRV"

#  define	MGL_SVGA4NAME		"SVGA4.DRV"
                                                /* Generic SuperVGA drivers             */
#  define	MGL_SVGA8NAME		"SVGA8.DRV"
#  define	MGL_SVGA16NAME		"SVGA16.DRV"
#  define	MGL_SVGA24NAME		"SVGA24.DRV"
#  define	MGL_SVGA32NAME		"SVGA32.DRV"

#  define	MGL_LINEAR8NAME		"LINEAR8.DRV"
                                                /* Linear framebuffer drivers   */
#  define	MGL_LINEAR16NAME	"LINEAR16.DRV"
#  define	MGL_LINEAR24NAME	"LINEAR24.DRV"
#  define	MGL_LINEAR32NAME	"LINEAR32.DRV"

#  define	MGL_ACCEL8NAME		"ACCEL8.DRV"
                                                /* VBE/AF Accelerated drivers   */
#  define	MGL_ACCEL16NAME		"ACCEL16.DRV"
#  define	MGL_ACCEL24NAME		"ACCEL24.DRV"
#  define	MGL_ACCEL32NAME		"ACCEL32.DRV"

#  define	MGL_DDRAW8NAME		"DDRAW8.DRV"
                                                /* DirectDraw drivers                   */
#  define	MGL_DDRAW16NAME		"DDRAW16.DRV"
#  define	MGL_DDRAW24NAME		"DDRAW24.DRV"
#  define	MGL_DDRAW32NAME		"DDRAW32.DRV"

/*
 * Standard memory driver names         
 */

#  define	MGL_PACKED1NAME		"PACK1.DRV"
#  define	MGL_PACKED4NAME		"PACK4.DRV"
#  define	MGL_PACKED8NAME		"PACK8.DRV"
#  define	MGL_PACKED16NAME	"PACK16.DRV"
#  define	MGL_PACKED24NAME	"PACK24.DRV"
#  define	MGL_PACKED32NAME	"PACK32.DRV"

/*
 * Standard bitmap names        
 */

#  define	MGL_EMPTY_FILL	_MGL_getEmptyPat()
#  define	MGL_GRAY_FILL	_MGL_getGrayPat()
#  define	MGL_SOLID_FILL	_MGL_getSolidPat()

/*
 * Event message masks for keyDown events 
 */

#  define	EVT_ASCIIMASK	0x00FF /* Ascii code of key pressed                    */
#  define	EVT_SCANMASK	0xFF00 /* Scan code of key pressed                             */
#  define	EVT_COUNTMASK	0x7FFF0000L
                                       /* Count for KEYREPEAT's                */

#  define	EVT_asciiCode(m)	( (uchar) (m & EVT_ASCIIMASK) )
#  define	EVT_scanCode(m)		( (uchar) ( (m & EVT_SCANMASK) >> 8 ) )
#  define	EVT_repeatCount(m)	( (short) ( (m & EVT_COUNTMASK) >> 16 ) )

/*
 * Event message masks for mouse events 
 */

#  define	EVT_LEFTBMASK	0x0001 /* Left button is bit 0                                 */
#  define	EVT_RIGHTBMASK	0x0004 /* Right button is bit 1                                */
#  define	EVT_BOTHBMASK	0x0005 /* Both left and right together                 */
#  define	EVT_ALLBMASK	0x0005 /* All buttons pressed                                  */

/*
 * Modifier masks 
 */

#  define	EVT_LEFTBUT		0x0001
                                       /* Set if left button was down                  */
#  define	EVT_RIGHTBUT	0x0002 /* Set if right button was down                 */
#  define	EVT_RIGHTSHIFT	0x0008 /* Set if right shift down                              */
#  define	EVT_LEFTSHIFT	0x0010 /* Set if left shift down                               */
#  define	EVT_CTRLSTATE	0x0020 /* Set if ctrl key down                                 */
#  define	EVT_ALTSTATE	0x0040 /* Set if alt key down                                  */
#  define	EVT_LEFTCTRL	0x0080 /* Set if left ctrl key down                    */
#  define	EVT_LEFTALT		0x0100
                                       /* Set if left alt key down                             */
#  define	EVT_SHIFTKEY	0x0018 /* Any shift key                                                */

/*
 * Event codes 
 */

#  define	EVT_NULLEVT		0x0000
                                       /* A null event                                                 */
#  define	EVT_KEYDOWN		0x0001
                                       /* Key down event                                               */
#  define	EVT_KEYREPEAT	0x0002 /* Key repeat event                                             */
#  define	EVT_KEYUP		0x0004
                                       /* Key up event                                                 */
#  define	EVT_MOUSEDOWN	0x0008 /* Mouse down event                                             */
#  define	EVT_MOUSEUP		0x0010
                                       /* Mouse up event                                               */
#  define	EVT_MOUSEMOVE	0x0020 /* Mouse movement event                                 */
#  define	EVT_TIMERTICK	0x0040 /* Timer tick event                                             */
#  define	EVT_USEREVT		0x0080
                                       /* First user event                                             */

/*
 * Event code masks 
 */

#  define	EVT_KEYEVT		(EVT_KEYDOWN | EVT_KEYREPEAT | EVT_KEYUP)
#  define	EVT_MOUSEEVT	(EVT_MOUSEDOWN | EVT_MOUSEUP | EVT_MOUSEMOVE)
#  define	EVT_MOUSECLICK	(EVT_MOUSEDOWN | EVT_MOUSEUP)
#  define	EVT_EVERYEVT	0xFFFF

/*
 * Suspend Application callback type codes. This callback is called
 * * when the user presses one of the corresponding keys indicating that
 * * they wish to change the active application. The MGL will catch these
 * * events and if you have registered a callback, will call the callback to
 * * save the state of the application so that it can be properly restored
 * * when the user switches back to your application. The MGL takes care of
 * * all the details about saving and restoring the state of the hardware,
 * * and all your application needs to do is save its own state so that you can
 * * re-draw the application screen upon re-activation.
 * *
 * * NOTE: Your application suspend callback may get called twice with the
 * *             MGL_DEACTIVATE flag in order to test whether the switch should
 * *             occur (under both DirectDraw and WinDirect fullscreen modes).
 * *
 * * NOTE: When your callback is called with the MGL_DEACTIVATE flag, you
 * *             cannot assume that you have access to the display memory surfaces
 * *             as they may have been lost by the time your callback has been called.
 */

#  define	MGL_DEACTIVATE	0x0001 /* Application losing active focus              */
#  define	MGL_REACTIVATE	0x0002 /* Application regaining active focus   */

/*
 * Return codes from the suspend application callback. The normal value
 * * to be returned is MGL_SUSPEND_APP and this will cause the app to be
 * * suspended while back in GDI mode until the app is re-activated again
 * * by the user.
 * *
 * * MGL_NO_DEACTIVATE signals to WinDirect that the application does not want
 * * to allow switching to occur, and the switch request will be ignored and
 * * the app will remain in fullscreen mode.
 * *
 * * MGL_NO_SUSPEND_APP can be used to tell WinDirect to switch back to the
 * * desktop, but not to suspend the application. This must be used with
 * * care as the suspend application callback is then responsible for setting
 * * a flag in the application that will stop the application from doing any
 * * rendering to the framebuffer while the application is in GDI mode. This
 * * return value is useful for games that need to maintain network
 * * connectivity while the user has temporarily switched back to GDI mode.
 */

#  define	MGL_NO_DEACTIVATE	0
                                       /* Dont allow app to be deactivated     */
#  define	MGL_SUSPEND_APP		1
                                       /* Suspend application until restored   */
#  define	MGL_NO_SUSPEND_APP	2
                                       /* Dont suspend, but allow switch               */

/*
 * Here we define the structures used to represent points and rectangles 
 */

typedef struct {
    m_int         x, y;
} point_t;

typedef struct {
    m_int         left;
    m_int         top;
    m_int         right;
    m_int         bottom;
} rect_t;

/*
 * All colors are represented as longs by the library. This allows
 * * code to work correctly with up to 24 bit color device drivers. The
 * * device drivers themselves expect the color to be a color index if in
 * * a color mapped mode, or a 15/16/24 bit RGB tuple in a hicolor or truecolor
 * * mode. You can use the appropriate routines to pack and unpack
 * * colors into the color_t format.
 */

typedef ulong color_t;

/*
 * Define the value used to clear the software ZBuffer. The MGL always uses
 * * a > operator for the z compare, and the smallest value is 0.
 */

#  define	MGL_ZCLEARVAL	0

/*
 * Structures for passing vertex information to polygon rendering routines.
 * * All fixed point coordinates are passed in 16.16 signed fixed point
 * * format, while zbuffer coordinates are passed in 4.28 signed fixed point
 * * format. The sign bit is used purely for overflow and arithmetic
 * * internally, and all user passed zbuffer values should be greater than
 * * 0. All shaded rendering routines either take a color index in 8.16 fixed
 * * point format (range 0-255.9) or separate RGB components in 8.16 fixed
 * * point format (range 0-255.9).
 */

#  ifdef	__FX_FIXED_H
#    define	fix32_t			FXFixed
#  else
typedef long  fix32_t;
#  endif
typedef fix32_t fxcolor_t;
typedef long  zfix32_t;

typedef struct {
    fix32_t       x, y;
} fxpoint_t;

typedef struct {
    fxcolor_t     r, g, b;
} fxrgb_t;

typedef struct {
    fix32_t       w, s, t;
} fxtex_t;

typedef struct {
    fxcolor_t     c;
    fxpoint_t     p;
} fxpointc_t;

typedef struct {
    fxrgb_t       c;
    fxpoint_t     p;
} fxpointrgb_t;

typedef struct {
    fxpoint_t     p;
    zfix32_t      z;
} fxpointz_t;

typedef struct {
    fxcolor_t     c;
    fxpoint_t     p;
    zfix32_t      z;
} fxpointcz_t;

typedef struct {
    fxrgb_t       c;
    fxpoint_t     p;
    zfix32_t      z;
} fxpointrgbz_t;

/*
 * Macros to convert between integer and 32 bit fixed point format 
 */

#  define	MGL_FIX_1			0x10000L
#  define	MGL_FIX_2			0x20000L
#  define	MGL_FIX_HALF		0x08000L
#  define	MGL_TOFIX(i)		((long)(i) << 16)
#  define MGL_FIXTOINT(f)		((m_int)((f) >> 16))
#  define	MGL_FIXROUND(f) 	((m_int)(((f) + MGL_FIX_HALF) >> 16))

#  define	MGL_ZFIX_1			0x10000000L
#  define	MGL_ZFIX_HALF		0x08000000L
#  define MGL_FIXTOZ(i)		((i) << 12)
#  define	MGL_ZTOFIX(i)		((i) >> 12)
#  define	MGL_TOZFIX(i)		((long)(i) << 28)
#  define MGL_ZFIXTOINT(f)	((m_int)((f) >> 28))
#  define	MGL_ZFIXROUND(f) 	((m_int)(((f) + MGL_ZFIX_HALF) >> 28))

/*
 * Region structure 
 */

#  ifdef	BUILD_MGL
struct _span_t;
typedef struct _span_t span_t;
#  else
typedef void  span_t;
#  endif

typedef struct {
    rect_t        rect;                /* Bounding rectangle for region                */
    span_t       *spans;               /* Start of span list for region                */
} region_t;

/*
 * Palette entry structure      
 */

typedef struct {
    uchar         blue;                /* Blue component of color                              */
    uchar         green;               /* Green component of color                             */
    uchar         red;                 /* Blue component of color                              */
    uchar         alpha;               /* Alpha or alignment byte                              */
} palette_t;

/*
 * Maximum value for each palette entry component 
 */

#  define	PALMAX		255    /* Max value for palette components     */

/*
 * Pixel format structure 
 */

typedef struct {
    uchar         redMask, greenMask;  /* Mask values for pixels                       */
    uchar         blueMask, rsvdMask;
    m_int         redPos, redAdjust;   /* Red position and adjustment          */
    m_int         greenPos, greenAdjust;        /* Green position and adjustment        */
    m_int         bluePos, blueAdjust; /* Blue position and adjustment         */
    m_int         rsvdPos, rsvdAdjust; /* Reserved position and adjustment */
} pixel_format_t;

/*
 * Structure to hold arc coordinate information 
 */

typedef struct {
    m_int         x, y;                /* Centre point of the arc                      */
    m_int         startX, startY;      /* Starting point on arc                        */
    m_int         endX, endY;          /* Ending point on arc                          */
} arc_coords_t;

/*
 * Mouse cursor structure 
 */

typedef struct {
    ulong         xorMask[32];
    ulong         andMask[32];
    m_int         xHotSpot;
    m_int         yHotSpot;
} cursor_t;

/*
 * Bitmap structure - always packed pixel DIB format 
 */

typedef struct {
    m_int         width;               /* Width of bitmap in pixels            */
    m_int         height;              /* Height of bitmap in pixels           */
    m_int         bitsPerPixel;        /* Pixel width                                          */
    m_int         bytesPerLine;        /* Bytes per line value for surface */
    uchar        *surface;             /* Pointer to bitmap surface            */
    palette_t    *pal;                 /* Palette (NULL if not loaded)         */
    pixel_format_t *pf;                /* Pixel format (NULL if none)          */

    /*
     * ... palette, pixel format and bitmap data are store contiguously 
     */
} bitmap_t;

/*
 * Icon structure - can be 32x23, 64x64 or in fact any size 
 */

typedef struct {
    m_int         byteWidth;           /* Byte with for AND mask                       */
    uchar        *andMask;             /* Hold punch mask for icon                     */
    bitmap_t      xorMask;             /* XOR mask for the icon                        */

    /*
     * ... AND mask and bitmap structure are stored contiguously 
     */
} icon_t;

/*
 * Default cursor name 
 */

#  define	MGL_DEF_CURSOR		_MGL_getDefCursor()

/*
 * Generic Font structure 
 */

#  define	_MGL_FNAMESIZE		58

typedef struct {
    char          name[_MGL_FNAMESIZE]; /* Name of the font                        */
    short         fontType;            /* Type of font                                         */
    short         maxWidth;            /* Maximum character width                      */
    short         maxKern;             /* Maximum character kern                       */
    short         fontWidth;           /* Font width                                           */
    short         fontHeight;          /* Font height                                          */
    short         ascent;              /* Font ascent value                            */
    short         descent;             /* Font descent value                           */
    short         leading;             /* Font leading value                           */
} font_t;

/*
 * Character and font metrics structure 
 */

typedef struct {
    m_int         width;               /* Width of character or font           */
    m_int         fontWidth;           /* Character width (tightest fit)       */
    m_int         fontHeight;          /* Height of the font                           */
    m_int         ascent;              /* Ascent value                                         */
    m_int         descent;             /* Descent value                                        */
    m_int         leading;             /* Leading value                                        */
    m_int         kern;                /* Kern value                                           */
} metrics_t;

/*
 * Text settings structure 
 */

typedef struct {
    m_int         horizJust;           /* Horizontal justfication                      */
    m_int         vertJust;            /* Vertical justification                       */
    m_int         dir;                 /* Text drawing direction                       */
    m_int         szNumerx;            /* Text x size numerator                        */
    m_int         szNumery;            /* Text y size numerator                        */
    m_int         szDenomx;            /* Text x size denominator                      */
    m_int         szDenomy;            /* Text y size denominator                      */
    m_int         spaceExtra;          /* Space extra term                                     */
    font_t       *font;                /* Currently selected font                      */
} text_settings_t;

/*
 * Macros to access the (left,top) and (right,bottom) points of a
 * * rectangle.
 */

#  define	MGL_leftTop(r)		(((point_t *) &(r))[0])
#  define	MGL_rightBottom(r)	(((point_t *) &(r))[1])

typedef uchar pattern_t[8];
typedef color_t pixpattern_t[8][8];

/*
 * Attributes structure 
 */

typedef struct {
    color_t       color;               /* Foreground color                                     */
    color_t       backColor;           /* Background color                                     */
    m_int         colorMode;           /* Current color mode                           */
    m_int         markerSize;          /* Size of markers in pixels            */
    m_int         markerStyle;         /* Style of markers                                     */
    color_t       markerColor;         /* Color to draw markers in                     */
    color_t       bdrBright;           /* Border bright color                          */
    color_t       bdrDark;             /* Border dark color                            */
    point_t       CP;                  /* Graphics pen position                        */
    m_int         writeMode;           /* Scan conversion write mode op.       */
    m_int         penStyle;            /* Pen style                                            */
    m_int         penHeight;           /* Height of pen                                        */
    m_int         penWidth;            /* Width of pen                                         */
    pattern_t     penPat;              /* Pattern for pen                                      */
    pixpattern_t  penPixPat;           /* Pixmap pattern for pen                       */
    m_int         lineStyle;           /* Line style                                           */
    ushort        lineStipple;         /* Line stipple                                         */
    m_uint        stippleCount;        /* Current line stipple count           */
    rect_t        viewPort;            /* Viewport dimensions                          */
    point_t       viewPortOrg;         /* Logical viewport origin                      */
    rect_t        clipRect;            /* Clipping rectangle dimensions        */
    m_int         clip;                /* Is clipping on?                                      */
    m_int         polyType;            /* Polygon drawing type                         */
    text_settings_t ts;                /* Text drawing attributes                      */
} attributes_t;

/*
 * Mode specific format information. This structrure can be used by
 * * the device driver to build tables of values for all supported modes
 */

typedef struct {
    m_int         xRes;                /* Device x resolution - 1                                      */
    m_int         yRes;                /* Device y resolution - 1                                      */
    m_int         bitsPerPixel;        /* Number of bits per pixel                                     */
    m_int         numberOfPlanes;      /* Number of planes in image                            */
    color_t       maxColor;            /* Maximum number of colors - 1                         */
    m_int         maxPage;             /* Maximum number of video pages - 1            */
    m_int         bytesPerLine;        /* Number of bytes in a line                            */
    m_int         aspectRatio;         /* Mode aspect ratio (horiz/vert * 1000)        */
    long          pageSize;            /* Number of bytes in a page                            */
    m_int         scratch1;            /* Scratch pad value 1                                          */
    m_int         scratch2;            /* Scratch pad value 2                                          */
    char          redMaskSize;         /* Size of direct color red mask    */
    char          redFieldPosition;    /* Bit posn of lsb of red mask      */
    char          greenMaskSize;       /* Size of direct color green mask  */
    char          greenFieldPosition;  /* Bit posn of lsb of green mask    */
    char          blueMaskSize;        /* Size of direct color blue mask   */
    char          blueFieldPosition;   /* Bit posn of lsb of blue mask     */
    char          rsvdMaskSize;        /* Size of reserved mask                        */
    char          rsvdFieldPosition;   /* Bit posn of reserved mask            */
} gmode_t;

/*
 * Public Device Context Structure. The 'surface' member along with the
 * * gmode_t information block, provides direct access to the active
 * * display surface for user applications. The MGL virtualises the surface
 * * in SuperVGA modes that dont have a real linear framebuffer.
 */

typedef struct {
    attributes_t  a;                   /* Active device attributes                                     */
    void         *surface;             /* Pointer to active device surface                     */
    void         *zbuffer;             /* Pointer to Z-buffer if allocated                     */
    m_int         zbits;               /* Bits per zbuffer element                                     */
    m_int         zwidth;              /* Width of the zbuffer in pixels                       */
    gmode_t       mi;                  /* Mode specific information block                      */
    pixel_format_t pf;                 /* Current pixel format for device context      */
    color_t      *colorTab;            /* Color lookup table cache                                     */
    color_t      *shadeTab;            /* Currently active shade table                         */
    m_int         bankOffset;          /* Offset of starting bank number                       */

    /*
     * Remainder of Device Context structure is private and internal        
     */
} publicDevCtx_t;

#  ifndef	BUILD_MGL
typedef publicDevCtx_t MGLDC;
#  else
struct internalDevCtx_t;
typedef struct internalDevCtx_t MGLDC;
#  endif

typedef struct {
    ulong         which;               /* Which window for window manager code */
    m_uint        what;                /* Event code                                                   */
    ulong         when;                /* Clock ticks since midnight                   */
    m_int         where_x;             /* Mouse location                                               */
    m_int         where_y;
    ulong         message;             /* Event specific message                               */
    ulong         modifiers;           /* Modifier flags                                               */
    m_int         next;                /* Next event in queue                                  */
    m_int         prev;                /* Previous event in queue                              */
} event_t;

/*
 * Structure containing file I/O functions allowing the user application to
 * * completely replace the MGL's file I/O functions with their own. This
 * * allows the app to store all MGL related files in a single large file,
 * * with encryption or compression is desired. By default normal file I/O
 * * functions will be used.
 */

typedef struct {
    FILE         *(*fopen) (const char *filename, const char *mode);
    int           (*fclose) (FILE * f);
    int           (*fseek) (FILE * f, long offset, int whence);
    long          (*ftell) (FILE * f);
                  size_t (*fread) (void *ptr, size_t size, size_t n, FILE * f);
                  size_t (*fwrite) (const void *ptr, size_t size, size_t n, FILE * f);
} fileio_t;

/*
 * Define the flags for the types of direct surface access provided 
 */

#  define	MGL_NO_ACCESS		0x0
                                       /* Surface cannot be accessed           */
#  define	MGL_VIRTUAL_ACCESS	0x1
                                       /* Surface is virtualised                       */
#  define	MGL_LINEAR_ACCESS	0x2
                                       /* Surface can be linearly accessed     */
#  define	MGL_SURFACE_FLAGS	0x3

/*
 * Define the flags for the types of direct zbuffer access provided 
 */

#  define	MGL_NO_ZACCESS		0x0
                                       /* Zbuffer cannot be accessed           */
#  define	MGL_VIRTUAL_ZACCESS	0x4
                                       /* Zbuffer is virtualised in            */
#  define	MGL_LINEAR_ZACCESS	0x8
                                       /* Zbuffer can be linearly accessed     */
#  define	MGL_ZBUFFER_FLAGS	0xC

/*
 * Define the flags for the types of hardware acceleration supported by
 * * the device context. This will allow the application to tailor the use of
 * * MGL functions depending upon whether specific hardware support is
 * * available. Hence applications can use specialised software rendering
 * * support if the desired hardware support is not available.
 * *
 * * NOTE: If the hardware flags are not MGL_HW_NONE, you *must* call
 * *             the MGL_beginDirectAccess() and MGL_endDirectAccess() functions
 * *             before and after any custom code that does direct framebuffer
 * *             rendering!!
 * *
 * *             This is not necessary for non-accelerated device context, so you
 * *             might want to optimise these calls out if there is no hardware
 * *             acceleration support.
 */

#  define	MGL_HW_NONE			0x0000
                                                /* No hardware acceleration                     */
#  define	MGL_HW_LINE			0x0010
                                                /* Hardware line drawing                        */
#  define	MGL_HW_STIPPLE_LINE	0x0020
                                       /* Hardware stippled line drawing       */
#  define	MGL_HW_POLY			0x0040
                                                /* Hardware polygon filling                     */
#  define	MGL_HW_RECT			0x0080
                                                /* Hardware rectangle fill                      */
#  define	MGL_HW_PATT_RECT	0x0100
                                       /* Hardware pattern rectangle fill      */
#  define	MGL_HW_CLRPATT_RECT	0x0200
                                       /* Hardware color pattern fill          */
#  define	MGL_HW_SCR_BLT		0x0400
                                       /* Hardware screen/screen bitBlt        */
#  define	MGL_HW_SRCTRANS_BLT	0x0800
                                       /* Hardware source transparent blt      */
#  define	MGL_HW_DSTTRANS_BLT	0x1000
                                       /* Hardware dest. transparent blt       */
#  define	MGL_HW_MONO_BLT		0x2000
                                       /* Hardware monochrome blt                      */
#  define	MGL_HW_CLIP			0x4000
                                                /* Hardware clipping                            */
#  define	MGL_HW_FLAGS		0xFFF0

#  ifdef	__cplusplus
extern        "C" {                    /* Use "C" linkage when in C++ mode     */
#  endif

/*------------------------- Function Prototypes ---------------------------*/

/*---------------------------------------------------------------------------
 * Routines bound to a specific device context. These routines all take
 * an MGLDC as a parmeter for the context to work with and hence dont work
 * with the current context. If however the context passed is the currently
 * active context, all changes to that context are reflected in the
 * currently active context as well.
 *-------------------------------------------------------------------------*/

    /*
     * Environment detection and initialisation 
     */

    m_int MGLAPI  MGL_registerDriver (const char *name, void *driver);
    void MGLAPI   MGL_unregisterAllDrivers (void);
    void MGLAPI   MGL_registerAllDispDrivers (bool useLinear, bool useDirectDraw, bool useWinDirect);
    void MGLAPI   MGL_registerAllMemDrivers (void);
    void MGLAPI   MGL_detectGraph (m_int * driver, m_int * mode);
    uchar        *MGLAPI MGL_availableModes (void);
    m_int MGLAPI  MGL_availablePages (m_int mode);
    m_int MGLAPI  MGL_modeResolution (m_int mode, m_int * xRes, m_int * yRes, m_int * bitsPerPixel);
    bool MGLAPI   MGL_isDisplayDC (MGLDC * dc);
    bool MGLAPI   MGL_isWindowedDC (MGLDC * dc);
    bool MGLAPI   MGL_isMemoryDC (MGLDC * dc);
    void MGLAPI   MGL_exit (void);
    void MGLAPI   MGL_setBufSize (unsigned size);
    void MGLAPI   MGL_fatalError (const char *msg);
    m_int MGLAPI  MGL_result (void);
    void MGLAPI   MGL_setResult (m_int result);
    const char   *MGLAPI MGL_errorMsg (m_int err);
    const char   *MGLAPI MGL_modeName (m_int mode);
    const char   *MGLAPI MGL_modeDriverName (m_int mode);
    const char   *MGLAPI MGL_driverName (m_int driver);
    m_int MGLAPI  MGL_getDriver (MGLDC * dc);
    m_int MGLAPI  MGL_getMode (MGLDC * dc);
    m_int MGLAPI  MGL_surfaceAccessType (MGLDC * dc);
    m_int MGLAPI  MGL_zbufferAccessType (MGLDC * dc);
    long MGLAPI   MGL_getHardwareFlags (MGLDC * dc);
    void MGLAPI   MGL_defaultAttributes (MGLDC * dc);
    void MGLAPI   MGL_makeSubDC (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom);

    /*
     * Viewport and clip rectangle manipulation bound to a specific DC 
     */

    void MGLAPI   MGL_setViewportDC (MGLDC * dc, rect_t view);
    void MGLAPI   MGL_setRelViewportDC (MGLDC * dc, rect_t view);
    void MGLAPI   MGL_getViewportDC (MGLDC * dc, rect_t * view);
    void MGLAPI   MGL_setViewportOrgDC (MGLDC * dc, point_t org);
    void MGLAPI   MGL_getViewportOrgDC (MGLDC * dc, point_t * org);
    void MGLAPI   MGL_globalToLocalDC (MGLDC * dc, point_t * p);
    void MGLAPI   MGL_localToGlobalDC (MGLDC * dc, point_t * p);
    m_int MGLAPI  MGL_maxxDC (MGLDC * dc);
    m_int MGLAPI  MGL_maxyDC (MGLDC * dc);
    void MGLAPI   MGL_setClipRectDC (MGLDC * dc, rect_t clip);
    void MGLAPI   MGL_getClipRectDC (MGLDC * dc, rect_t * clip);
    void MGLAPI   MGL_setClipModeDC (MGLDC * dc, bool mode);
    bool MGLAPI   MGL_getClipModeDC (MGLDC * dc);

    /*
     * Color and palette manipulation 
     */

    color_t MGLAPI MGL_realColor (MGLDC * dc, m_int color);
    color_t MGLAPI MGL_rgbColor (MGLDC * dc, uchar R, uchar G, uchar B);
    void MGLAPI   MGL_setPaletteEntry (MGLDC * dc, m_int entry, uchar red, uchar green, uchar blue);
    void MGLAPI   MGL_getPaletteEntry (MGLDC * dc, m_int entry, uchar * red, uchar * green, uchar * blue);
    void MGLAPI   MGL_setPalette (MGLDC * dc, palette_t * pal, m_int numColors, m_int startIndex);
    void MGLAPI   MGL_getPalette (MGLDC * dc, palette_t * pal, m_int numColors, m_int startIndex);
    void ASMAPI   MGL_rotatePalette (MGLDC * dc, m_int numColors, m_int startIndex, m_int direction);
    bool ASMAPI   MGL_fadePalette (MGLDC * dc, palette_t * fullIntensity, m_int numColors, m_int startIndex,
                                   uchar intensity);
    void MGLAPI   MGL_realizePalette (MGLDC * dc, m_int numColors, m_int startIndex, m_int waitVRT);
    m_int MGLAPI  MGL_getPaletteSize (MGLDC * dc);
    void MGLAPI   MGL_getDefaultPalette (MGLDC * dc, palette_t * pal);
    void MGLAPI   MGL_setDefaultPalette (MGLDC * dc);
#  ifndef	MGL_LITE
    bool MGLAPI   MGL_checkIdentityPalette (bool enable);
    void MGLAPI   MGL_mapToPalette (MGLDC * dc, palette_t * pal);
#  endif

    /*
     * Generic device context information and manipulation 
     */

    bool MGLAPI   MGL_haveWidePalette (MGLDC * dc);
    m_int MGLAPI  MGL_getBitsPerPixel (MGLDC * dc);
    color_t MGLAPI MGL_maxColor (MGLDC * dc);
    m_int MGLAPI  MGL_maxPage (MGLDC * dc);
    m_int MGLAPI  MGL_sizex (MGLDC * dc);
    m_int MGLAPI  MGL_sizey (MGLDC * dc);
    void MGLAPI   MGL_getPixelFormat (MGLDC * dc, pixel_format_t * pf);
    void         *MGLAPI MGL_computePixelAddr (MGLDC * dc, int x, int y);

    /*
     * Double buffering support 
     */

    void MGLAPI   MGL_setActivePage (MGLDC * dc, m_int page);
    m_int MGLAPI  MGL_getActivePage (MGLDC * dc);
    void MGLAPI   MGL_setVisualPage (MGLDC * dc, m_int page, m_int waitVRT);
    m_int MGLAPI  MGL_getVisualPage (MGLDC * dc);
    void MGLAPI   MGL_setDisplayStart (MGLDC * dc, m_int x, m_int y, m_int waitFlag);
    void MGLAPI   MGL_getDisplayStart (MGLDC * dc, m_int * x, m_int * y);
    void MGLAPI   MGL_vSync (MGLDC * dc);
    bool MGLAPI   MGL_doubleBuffer (MGLDC * dc);
    void MGLAPI   MGL_singleBuffer (MGLDC * dc);
    void MGLAPI   MGL_swapBuffers (MGLDC * dc, m_int waitVRT);

    /*
     * Zbuffering support 
     */

#  ifdef	MGL_3D
    m_int MGLAPI  MGL_getHardwareZBufferDepth (MGLDC * dc);
    bool ASMAPI   MGL_zBegin (MGLDC * dc, m_int zbits);
    bool MGLAPI   MGL_zShareZBuffer (MGLDC * dc, MGLDC * dcShared, m_int zbits);
#  endif

    /*
     * Event handling support 
     */

    bool MGLAPI   EVT_getNext (event_t * evt, m_uint mask);
    bool MGLAPI   EVT_peekNext (event_t * evt, m_uint mask);
    bool MGLAPI   EVT_post (ulong which, m_uint what, ulong message, ulong modifiers);
    void MGLAPI   EVT_flush (m_uint mask);
    void MGLAPI   EVT_halt (event_t * evt, m_uint mask);
    m_int MGLAPI  EVT_setTimerTick (m_int ticks);

/*---------------------------------------------------------------------------
 * Routines bound to the currently active context. All these routines work
 * with the currently active context and do not reflect any changes made
 * to the global context to the original user supplied context (because it
 * may be cached). The cached DC is automatically flushed back to the
 * original DC when a new context is enabled with MGL_makeCurrentDC().
 *
 * Before destroying a DC that is current, make sure you call
 * MGL_makeCurrentDC(NULL) first!
 *-------------------------------------------------------------------------*/

    /*
     * Routines to change the active global device context 
     */

    MGLDC        *MGLAPI MGL_makeCurrentDC (MGLDC * dc);
    bool MGLAPI   MGL_isCurrentDC (MGLDC * dc);

    /*
     * Current device context information and manipulation 
     */

    m_int MGLAPI  MGL_getAspectRatio (void);
    void MGLAPI   MGL_setAspectRatio (m_int aspectRatio);
    void ASMAPI   MGL_setColor (color_t color);
    void MGLAPI   MGL_setColorRGB (uchar R, uchar G, uchar B);
    void MGLAPI   MGL_setColorCI (m_int index);
    color_t MGLAPI MGL_getColor (void);
    void ASMAPI   MGL_setBackColor (color_t color);
    color_t MGLAPI MGL_getBackColor (void);
    color_t ASMAPI MGL_packColor (pixel_format_t * pf, uchar R, uchar G, uchar B);
    void MGLAPI   MGL_unpackColor (pixel_format_t * pf, color_t color, uchar * R, uchar * G, uchar * B);
    color_t ASMAPI MGL_packColorRGB (uchar R, uchar G, uchar B);
    void MGLAPI   MGL_unpackColorRGB (color_t color, uchar * R, uchar * G, uchar * B);
    color_t MGLAPI MGL_defaultColor (void);
#  ifndef	MGL_LITE
    void MGLAPI   MGL_setMarkerSize (m_int size);
    m_int MGLAPI  MGL_getMarkerSize (void);
    void MGLAPI   MGL_setMarkerStyle (m_int style);
    m_int MGLAPI  MGL_getMarkerStyle (void);
    void MGLAPI   MGL_setMarkerColor (color_t color);
    color_t MGLAPI MGL_getMarkerColor (void);
    void MGLAPI   MGL_setBorderColors (color_t bright, color_t dark);
    void MGLAPI   MGL_getBorderColors (color_t * bright, color_t * dark);
    void ASMAPI   MGL_setWriteMode (m_int mode);
    m_int MGLAPI  MGL_getWriteMode (void);
    void ASMAPI   MGL_setPenStyle (m_int style);
    m_int MGLAPI  MGL_getPenStyle (void);
    void MGLAPI   MGL_setLineStyle (m_int style);
    m_int MGLAPI  MGL_getLineStyle (void);
    void ASMAPI   MGL_setLineStipple (ushort stipple);
    ushort MGLAPI MGL_getLineStipple (void);
    void ASMAPI   MGL_setLineStippleCount (m_uint stippleCount);
    m_uint MGLAPI MGL_getLineStippleCount (void);
    void ASMAPI   MGL_setPenBitmapPattern (const pattern_t * pat);
    void MGLAPI   MGL_getPenBitmapPattern (pattern_t * pat);
    void ASMAPI   MGL_setPenPixmapPattern (const pixpattern_t * pat);
    void MGLAPI   MGL_getPenPixmapPattern (pixpattern_t * pat);
    void MGLAPI   MGL_setPenSize (m_int height, m_int width);
    void MGLAPI   MGL_getPenSize (m_int * height, m_int * width);
#    ifndef	MGL_LITE
    void MGLAPI   MGL_setColorMapMode (m_int mode);
    m_int MGLAPI  MGL_getColorMapMode (void);
#    endif
    void MGLAPI   MGL_setPolygonType (m_int type);
    m_int MGLAPI  MGL_getPolygonType (void);
#  endif
    void MGLAPI   MGL_getAttributes (attributes_t * attr);
    void MGLAPI   MGL_restoreAttributes (attributes_t * attr);

    /*
     * Device clearing 
     */

    void ASMAPI   MGL_clearDevice (void);
    void MGLAPI   MGL_clearViewport (void);

    /*
     * Viewport and clip rectangle manipulation 
     */

    void MGLAPI   MGL_setViewport (rect_t view);
    void MGLAPI   MGL_setRelViewport (rect_t view);
    void MGLAPI   MGL_getViewport (rect_t * view);
    void MGLAPI   MGL_setViewportOrg (point_t org);
    void MGLAPI   MGL_getViewportOrg (point_t * org);
    void MGLAPI   MGL_globalToLocal (point_t * p);
    void MGLAPI   MGL_localToGlobal (point_t * p);
    m_int MGLAPI  MGL_maxx (void);
    m_int MGLAPI  MGL_maxy (void);
    void MGLAPI   MGL_setClipRect (rect_t clip);
    void MGLAPI   MGL_getClipRect (rect_t * clip);
    void MGLAPI   MGL_setClipMode (bool mode);
    bool MGLAPI   MGL_getClipMode (void);

    /*
     * Pixel plotting 
     */

    void MGLAPI   MGL_pixelCoord (m_int x, m_int y);
    color_t MGLAPI MGL_getPixelCoord (m_int x, m_int y);
    void ASMAPI   MGL_beginPixel (void);
    void MGLAPI   MGL_pixelCoordFast (m_int x, m_int y);
    color_t MGLAPI MGL_getPixelCoordFast (m_int x, m_int y);
    void ASMAPI   MGL_endPixel (void);

    /*
     * Line drawing and clipping 
     */

    void MGLAPI   MGL_moveToCoord (m_int x, m_int y);
    void MGLAPI   MGL_moveRelCoord (m_int dx, m_int dy);
    void MGLAPI   MGL_lineToCoord (m_int x, m_int y);
    void MGLAPI   MGL_lineRelCoord (m_int dx, m_int dy);
    m_int MGLAPI  MGL_getX (void);
    m_int MGLAPI  MGL_getY (void);
    void MGLAPI   MGL_getCP (point_t * CP);
    void MGLAPI   MGL_lineCoord (m_int x1, m_int y1, m_int x2, m_int y2);
    void MGLAPI   MGL_lineCoordFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2);
    void MGLAPI   MGL_lineCoordFast (m_int x1, m_int y1, m_int x2, m_int y2);
    void MGLAPI   MGL_lineCoordFastFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2);
    void MGLAPI   MGL_lineEngine (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2,
                                  void (ASMAPI * plotPoint) (m_int x, m_int y));
    bool MGLAPI   MGL_clipLineFX (fix32_t * x1, fix32_t * y1, fix32_t * x2, fix32_t * y2, fix32_t left, fix32_t top,
                                  fix32_t right, fix32_t bottom);
#  ifndef	MGL_LITE
    void ASMAPI   MGL_scanLine (m_int y, m_int x1, m_int x2);
#  endif

    /*
     * Routines to perform bank switching for banked framebuffers for custom
     * * rendering code. The first version is callable only from assembler and
     * * requires the new bank value to be passed in the DL register. The second
     * * version is callable directly from C. DO NOT CALL THESE FUNCTIONS WHEN
     * * RUNNING WITH A LINEAR FRAMEBUFFER!!!
     */

    void _ASMAPI  SVGA_setBank (void);
    void _ASMAPI  SVGA_setBankC (int bank);

    /*
     * Routines to begin/end direct framebuffer access. You must call these
     * * functions is you wish to render directly to a hardware accelerated
     * * device surface.
     */

    void ASMAPI   MGL_beginDirectAccess (void);
    void ASMAPI   MGL_endDirectAccess (void);

    /*
     * Routines to begin/end fast rendering of flat shaded lines, scanlines
     * * and polygons.
     */

    void ASMAPI   MGL_beginDrawing (void);
    void ASMAPI   MGL_endDrawing (void);

    /*
     * Routines to begin/end fast rendering of smooth shaded lines, scanlines
     * * and polygons.
     */

#  ifdef	MGL_3D
    void ASMAPI   MGL_beginShadedDrawing (void);
    void ASMAPI   MGL_endShadedDrawing (void);
#  endif

    /*
     * Routines to begin/end fast rendering of flat shaded, zbuffered lines and
     * * polygons.
     */

#  ifdef	MGL_3D
    void ASMAPI   MGL_beginZDrawing (void);
    void ASMAPI   MGL_endZDrawing (void);
#  endif

    /*
     * Routines to begin/end fast rendering of smooth shaded, zbuffered lines and
     * * polygons.
     */

#  ifdef	MGL_3D
    void ASMAPI   MGL_beginZShadedDrawing (void);
    void ASMAPI   MGL_endZShadedDrawing (void);
#  endif

    /*
     * Polygon drawing: Note that the following fast polygon routines
     * * only work with convex polygons. The integer coordinate versions are
     * * provided for compatibility only, and convert the coordinates to fixed
     * * point and call the appropriate fixed point routines below.
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_fillPolygon (m_int count, point_t * vArray, m_int xOffset, m_int yOffset);
    void MGLAPI   MGL_fillPolygonFast (m_int count, point_t * vArray, m_int xOffset, m_int yOffset);
    void ASMAPI   MGL_fillPolygonFX (m_int count, fxpoint_t * vArray, m_int vinc, fix32_t xOffset, fix32_t yOffset);
    void ASMAPI   MGL_fillPolygonFastFX (m_int count, fxpoint_t * vArray, m_int vinc, fix32_t xOffset, fix32_t yOffset);
#  endif

    /*
     * 3D rasterization routines 
     */

#  ifdef	MGL_3D
    void MGLAPI   MGL_zClearCoord (m_int left, m_int top, m_int right, m_int bottom, zfix32_t clearVal);
#  endif

#  ifdef	MGL_FIX3D
    void ASMAPI   MGL_cLineCoordFast (fix32_t x1, fix32_t y1, fix32_t c1, fix32_t x2, fix32_t y2, fix32_t c2);
    void ASMAPI   MGL_rgbLineCoordFast (fix32_t x1, fix32_t y1, fix32_t r1, fix32_t g1, fix32_t b1, fix32_t x2,
                                        fix32_t y2, fix32_t r2, fix32_t g2, fix32_t b2);
    void ASMAPI   MGL_zLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t x2, fix32_t y2, zfix32_t z2);
    void ASMAPI   MGL_czLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t c1, fix32_t x2, fix32_t y2,
                                       zfix32_t z2, fix32_t c2);
    void ASMAPI   MGL_rgbzLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t r1, fix32_t g1, fix32_t b1,
                                         fix32_t x2, fix32_t y2, zfix32_t z2, fix32_t r2, fix32_t g2, fix32_t b2);

    void ASMAPI   MGL_triFast (fxpoint_t * v1, fxpoint_t * v2, fxpoint_t * v3, fix32_t xOffset, fix32_t yOffset);
    void ASMAPI   MGL_cTriFast (fxpointc_t * v1, fxpointc_t * v2, fxpointc_t * v3, fix32_t xOffset, fix32_t yOffset);
    void ASMAPI   MGL_rgbTriFast (fxpointrgb_t * v1, fxpointrgb_t * v2, fxpointrgb_t * v3, fix32_t xOffset,
                                  fix32_t yOffset);
    void ASMAPI   MGL_zTriFast (fxpointz_t * v1, fxpointz_t * v2, fxpointz_t * v3, fix32_t xOffset, fix32_t yOffset,
                                zfix32_t zOffset);
    void ASMAPI   MGL_czTriFast (fxpointcz_t * v1, fxpointcz_t * v2, fxpointcz_t * v3, fix32_t xOffset, fix32_t yOffset,
                                 zfix32_t zOffset);
    void ASMAPI   MGL_rgbzTriFast (fxpointrgbz_t * v1, fxpointrgbz_t * v2, fxpointrgbz_t * v3, fix32_t xOffset,
                                   fix32_t yOffset, zfix32_t zOffset);

    void ASMAPI   MGL_quadFast (fxpoint_t * v1, fxpoint_t * v2, fxpoint_t * v3, fxpoint_t * v4, fix32_t xOffset,
                                fix32_t yOffset);
    void ASMAPI   MGL_cQuadFast (fxpointc_t * v1, fxpointc_t * v2, fxpointc_t * v3, fxpointc_t * v4, fix32_t xOffset,
                                 fix32_t yOffset);
    void ASMAPI   MGL_rgbQuadFast (fxpointrgb_t * v1, fxpointrgb_t * v2, fxpointrgb_t * v3, fxpointrgb_t * v4,
                                   fix32_t xOffset, fix32_t yOffset);
    void ASMAPI   MGL_zQuadFast (fxpointz_t * v1, fxpointz_t * v2, fxpointz_t * v3, fxpointz_t * v4, fix32_t xOffset,
                                 fix32_t yOffset, zfix32_t zOffset);
    void ASMAPI   MGL_czQuadFast (fxpointcz_t * v1, fxpointcz_t * v2, fxpointcz_t * v3, fxpointcz_t * v4,
                                  fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
    void ASMAPI   MGL_rgbzQuadFast (fxpointrgbz_t * v1, fxpointrgbz_t * v2, fxpointrgbz_t * v3, fxpointrgbz_t * v4,
                                    fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
#  endif

    /*
     * Routine to set the currently active shade table. In HiColor and TrueColor
     * * video modes, you must set a valid shadeTable before you call any of the
     * * color index shaded rendering routines (MGL_cTri() etc). These routines
     * * will interpolate an index into the current shade table rather than
     * * each of the RGB color channels, and the appropriate full RGB color is
     * * extracted directly from the shade table. The shade table can be any size,
     * * but the application must ensure that the indices passed in are within
     * * the range of the current shade table.
     */

#  ifdef	MGL_3D
    void MGLAPI   MGL_setShadeTable (color_t * shadeTab);
#  endif

    /*
     * Polyline drawing 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_marker (point_t p);
    void MGLAPI   MGL_polyPoint (m_int count, point_t * vArray);
    void MGLAPI   MGL_polyMarker (m_int count, point_t * vArray);
    void MGLAPI   MGL_polyLine (m_int count, point_t * vArray);
#  endif

    /*
     * Rectangle drawing 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_rectCoord (m_int left, m_int top, m_int right, m_int bottom);
    void MGLAPI   MGL_fillRectCoord (m_int left, m_int top, m_int right, m_int bottom);
#  endif

    /*
     * Scanline color scanning. Thee routines are primitive, and do not perform
     * * any clipping or viewport mapping, so can be used to build you own
     * * high performance floodfilling routines (see the example file ffill.c
     * * for pre-built high speed floodfill routines).
     */

#  ifndef	MGL_LITE
    m_int ASMAPI  MGL_scanRightForColor (m_int x, m_int y, color_t color);
    m_int ASMAPI  MGL_scanLeftForColor (m_int x, m_int y, color_t color);
    m_int ASMAPI  MGL_scanRightWhileColor (m_int x, m_int y, color_t color);
    m_int ASMAPI  MGL_scanLeftWhileColor (m_int x, m_int y, color_t color);
#  endif

    /*
     * Psuedo 3D border drawing 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_drawBorderCoord (m_int left, m_int top, m_int right, m_int bottom, m_int style, m_int thickness);
    void MGLAPI   MGL_drawHDivider (m_int y, m_int x1, m_int x2);
    void MGLAPI   MGL_drawVDivider (m_int x, m_int y1, m_int y2);
#  endif

    /*
     * Ellipse drawing 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_ellipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
    void MGLAPI   MGL_ellipseArcCoord (m_int x, m_int y, m_int xradius, m_int yradius, m_int startAngle,
                                       m_int endAngle);
    void ASMAPI   MGL_getArcCoords (arc_coords_t * coords);
    void MGLAPI   MGL_ellipse (rect_t extentRect);
    void MGLAPI   MGL_ellipseCoord (m_int x, m_int y, m_int xradius, m_int yradius);
    void MGLAPI   MGL_fillEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
    void MGLAPI   MGL_fillEllipseArcCoord (m_int x, m_int y, m_int xradius, m_int yradius, m_int startAngle,
                                           m_int endAngle);
    void MGLAPI   MGL_fillEllipse (rect_t extentRect);
    void MGLAPI   MGL_fillEllipseCoord (m_int x, m_int y, m_int xradius, m_int yradius);
    void MGLAPI   MGL_ellipseEngine (rect_t extentRect,
                                     void (ASMAPI * setup) (m_int topY, m_int botY, m_int left, m_int right),
                                     void (ASMAPI * set4pixels) (bool inc_x, bool inc_y, bool region1),
                                     void (ASMAPI * finished) (void));
    void MGLAPI   MGL_ellipseArcEngine (rect_t extentRect, m_int startAngle, m_int endAngle, arc_coords_t * ac,
                                        void (ASMAPI * plotPoint) (m_int x, m_int y));
#  endif

    /*
     * Text attribute manipulation 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_setTextJustify (m_int horiz, m_int vert);
    void MGLAPI   MGL_getTextJustify (m_int * horiz, m_int * vert);
    void MGLAPI   MGL_setTextDirection (m_int direction);
    m_int MGLAPI  MGL_getTextDirection (void);
    void MGLAPI   MGL_setTextSize (m_int numerx, m_int denomx, m_int numery, m_int denomy);
    void MGLAPI   MGL_getTextSize (m_int * numerx, m_int * denomx, m_int * numery, m_int * denomy);
    void MGLAPI   MGL_setSpaceExtra (m_int extra);
    m_int MGLAPI  MGL_getSpaceExtra (void);
    void MGLAPI   MGL_setTextSettings (text_settings_t * settings);
    void MGLAPI   MGL_getTextSettings (text_settings_t * settings);
    m_int MGLAPI  MGL_textHeight (void);
    m_int MGLAPI  MGL_textWidth (const char *str);
    void MGLAPI   MGL_textBounds (m_int x, m_int y, const char *str, rect_t * bounds);
    m_int MGLAPI  MGL_charWidth (char ch);
    void MGLAPI   MGL_getFontMetrics (metrics_t * metrics);
    void MGLAPI   MGL_getCharMetrics (char ch, metrics_t * metrics);
    m_int MGLAPI  MGL_maxCharWidth (void);
    void MGLAPI   MGL_underScoreLocation (m_int * x, m_int * y, const char *str);
#  endif

    /*
     * Text drawing 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_drawStr (const char *str);
    void MGLAPI   MGL_drawStrXY (m_int x, m_int y, const char *str);
    bool MGLAPI   MGL_useFont (font_t * font);
    font_t       *MGLAPI MGL_getFont (void);
    bool MGLAPI   MGL_vecFontEngine (m_int x, m_int y, const char *str, void (ASMAPI * move) (m_int x, m_int y),
                                     void (ASMAPI * draw) (m_int x, m_int y));
#  endif

    /*
     * BitBlt support 
     */

    void MGLAPI   MGL_bitBltCoord (MGLDC * dst, MGLDC * src, m_int left, m_int top, m_int right, m_int bottom,
                                   m_int dstLeft, m_int dstTop, m_int op);
    void MGLAPI   MGL_stretchBltCoord (MGLDC * dst, MGLDC * src, m_int left, m_int top, m_int right, m_int bottom,
                                       m_int dstLeft, m_int dstTop, m_int dstRight, m_int dstBottom);
#  ifndef	MGL_LITE
    void MGLAPI   MGL_getDivotCoord (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom, void *divot);
    void MGLAPI   MGL_putDivot (MGLDC * dc, void *divot);
    long MGLAPI   MGL_divotSizeCoord (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom);
    void MGLAPI   MGL_putMonoImage (MGLDC * dc, m_int x, m_int y, m_int byteWidth, m_int height, void *image);
    void MGLAPI   MGL_putBitmap (MGLDC * dc, m_int x, m_int y, const bitmap_t * bitmap, m_int op);
    void MGLAPI   MGL_putBitmapSection (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft,
                                        m_int dstTop, const bitmap_t * bitmap, m_int op);
    void MGLAPI   MGL_putBitmapTransparent (MGLDC * dc, m_int x, m_int y, const bitmap_t * bitmap, color_t transparent,
                                            bool sourceTrans);
    void MGLAPI   MGL_putBitmapTransparentSection (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom,
                                                   m_int dstLeft, m_int dstTop, const bitmap_t * bitmap,
                                                   color_t transparent, bool sourceTrans);
    void MGLAPI   MGL_putBitmapMask (MGLDC * dc, m_int x, m_int y, const bitmap_t * mask, color_t color);
    void MGLAPI   MGL_stretchBitmap (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom,
                                     const bitmap_t * bitmap);
    void MGLAPI   MGL_putIcon (MGLDC * dc, m_int x, m_int y, const icon_t * icon);
    void MGLAPI   MGL_transBltCoord (MGLDC * dst, MGLDC * src, m_int left, m_int top, m_int right, m_int bottom,
                                     m_int dstLeft, m_int dstTop, color_t transparent, bool sourceTrans);
#  endif

    /*
     * Linear offscreen DC BitBlt support 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_bitBltLinCoord (MGLDC * dst, MGLDC * src, ulong srcOfs, m_int dstLeft, m_int dstTop,
                                      m_int dstRight, m_int dstBottom, m_int op);
    void MGLAPI   MGL_transBltLinCoord (MGLDC * dst, MGLDC * src, ulong srcOfs, m_int dstLeft, m_int dstTop,
                                        m_int dstRight, m_int dstBottom, color_t transparent, bool sourceTrans);
#  endif

    /*
     * Monochrome bitmap manipulation 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_drawGlyph (font_t * g, m_int x, m_int y, uchar glyph);
    m_int MGLAPI  MGL_getGlyphWidth (font_t * font, uchar glyph);
    m_int MGLAPI  MGL_getGlyphHeight (font_t * font);
    void MGLAPI   MGL_rotateGlyph (uchar * dst, uchar * src, m_int * byteWidth, m_int * height, m_int rotation);
    void MGLAPI   MGL_mirrorGlyph (uchar * dst, uchar * src, m_int byteWidth, m_int height);
#  endif

    /*
     * Region management 
     */

#  ifndef	MGL_LITE
    region_t     *MGLAPI MGL_newRegion (void);
    region_t     *MGLAPI MGL_copyRegion (const region_t * s);
    void MGLAPI   MGL_clearRegion (region_t * r);
    void MGLAPI   MGL_freeRegion (region_t * r);
    void MGLAPI   MGL_drawRegion (m_int x, m_int y, const region_t * r);
#  endif

    /*
     * Region generation primitives 
     */

#  ifndef	MGL_LITE
    region_t     *MGLAPI MGL_rgnLineCoord (m_int x1, m_int y1, m_int x2, m_int y2, const region_t * pen);
    region_t     *MGLAPI MGL_rgnLineCoordFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2, const region_t * pen);
    /*
     * region_t * MGLAPI MGL_rgnPolygon(m_int count,point_t *vArray);
     */
    /*
     * region_t * MGLAPI MGL_rgnPolygonFast(m_int count,point_t *vArray);
     */
    region_t     *MGLAPI MGL_rgnSolidRectCoord (m_int left, m_int top, m_int right, m_int bottom);
    region_t     *MGLAPI MGL_rgnEllipse (rect_t extentRect, const region_t * pen);
    region_t     *MGLAPI MGL_rgnEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle, const region_t * pen);
    void MGLAPI   MGL_rgnGetArcCoords (arc_coords_t * coords);
    region_t     *MGLAPI MGL_rgnSolidEllipse (rect_t extentRect);
    region_t     *MGLAPI MGL_rgnSolidEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
#  endif

    /*
     * Region alegbra 
     */

#  ifndef	MGL_LITE
    region_t     *MGLAPI MGL_sectRegion (const region_t * r1, const region_t * r2);
    region_t     *MGLAPI MGL_sectRegionRect (const region_t * r1, const rect_t * r2);
    bool MGLAPI   MGL_unionRegion (region_t * r1, const region_t * r2);
    bool MGLAPI   MGL_unionRegionRect (region_t * r1, const rect_t * r2);
    bool MGLAPI   MGL_unionRegionOfs (region_t * r1, const region_t * r2, m_int xOffset, m_int yOffset);
    bool MGLAPI   MGL_diffRegion (region_t * r1, const region_t * r2);
    bool MGLAPI   MGL_diffRegionRect (region_t * r1, const rect_t * r2);
    void MGLAPI   MGL_optimizeRegion (region_t * r);
    void MGLAPI   MGL_offsetRegion (region_t * r, m_int dx, m_int dy);
    bool MGLAPI   MGL_emptyRegion (const region_t * r);
    bool MGLAPI   MGL_equalRegion (const region_t * r1, const region_t * r2);
    bool MGLAPI   MGL_ptInRegionCoord (m_int x, m_int y, const region_t * r);
#  endif

    /*
     * Region traversal 
     */

#  ifndef	MGL_LITE
    typedef void  (ASMAPI * rgncallback_t) (const rect_t * r);

    void MGLAPI   MGL_traverseRegion (region_t * rgn, rgncallback_t doRect);
#  endif

    /*
     * RGB to 8 bit halftone dithering routines 
     */

#  ifndef	MGL_LITE
    void MGLAPI   MGL_getHalfTonePalette (palette_t * pal);
    uchar MGLAPI  MGL_halfTonePixel (m_int x, m_int y, uchar R, uchar G, uchar B);
#  endif

    /*
     * Resource loading/unloading 
     */

    font_t       *MGLAPI MGL_loadFont (const char *fontname);
    bool MGLAPI   MGL_availableFont (const char *fontname);
    void MGLAPI   MGL_unloadFont (font_t * font);
    cursor_t     *MGLAPI MGL_loadCursor (const char *cursorName);
    bool MGLAPI   MGL_availableCursor (const char *cursorName);
    void MGLAPI   MGL_unloadCursor (cursor_t * cursor);
#  ifndef	MGL_LITE
    icon_t       *MGLAPI MGL_loadIcon (const char *iconName, bool loadPalette);
    bool MGLAPI   MGL_availableIcon (const char *iconName);
    void MGLAPI   MGL_unloadIcon (icon_t * icon);
#  endif

    /*
     * Windows BMP bitmap loading/unloading/saving 
     */

#  ifndef	MGL_LITE
    bitmap_t     *MGLAPI MGL_loadBitmap (const char *bitmapName, bool loadPalette);
    bool MGLAPI   MGL_availableBitmap (const char *bitmapName);
    void MGLAPI   MGL_unloadBitmap (bitmap_t * bitmap);
    bool MGLAPI   MGL_getBitmapSize (const char *bitmapName, m_int * width, m_int * height, m_int * bitsPerPixel,
                                     pixel_format_t * pf);
    bool MGLAPI   MGL_loadBitmapIntoDC (MGLDC * dc, const char *bitmapName, m_int dstLeft, m_int dstTop,
                                        bool loadPalette);
    bool MGLAPI   MGL_saveBitmapFromDC (MGLDC * dc, const char *bitmapName, m_int left, m_int top, m_int right,
                                        m_int bottom);
    bitmap_t     *MGLAPI MGL_getBitmapFromDC (MGLDC * dc, m_int left, m_int top, m_int right, m_int bottom,
                                              bool savePalette);
    bitmap_t     *MGLAPI MGL_buildMonoMask (bitmap_t * bitmap, color_t transparent);
#  endif

    /*
     * PCX bitmap loading/unloading/saving (1/4/8 bpp only) 
     */

#  ifndef	MGL_LITE
    bitmap_t     *MGLAPI MGL_loadPCX (const char *bitmapName, bool loadPalette);
    bool MGLAPI   MGL_availablePCX (const char *bitmapName);
    bool MGLAPI   MGL_getPCXSize (const char *bitmapName, m_int * width, m_int * height, m_int * bitsPerPixel);
    bool MGLAPI   MGL_loadPCXIntoDC (MGLDC * dc, const char *bitmapName, m_int dstLeft, m_int dstTop, bool loadPalette);
    bool MGLAPI   MGL_savePCXFromDC (MGLDC * dc, const char *bitmapName, m_int left, m_int top, m_int right,
                                     m_int bottom);
#  endif

    /*
     * Random number generation routines for shorts and longs with full range 
     */

    void ASMAPI   MGL_srand (m_uint seed);
    ushort ASMAPI MGL_random (ushort max);
    ulong ASMAPI  MGL_randoml (ulong max);

    /*
     * Mouse support 
     */

    bool MGLAPI   MS_available (void);
    void MGLAPI   MS_show (void);
    void MGLAPI   MS_hide (void);
    void MGLAPI   MS_obscure (void);
    void MGLAPI   MS_setCursor (cursor_t * curs);
    void MGLAPI   MS_setCursorColor (color_t color);
    void MGLAPI   MS_moveTo (m_int x, m_int y);
    void MGLAPI   MS_getPos (m_int * x, m_int * y);
    void MGLAPI   MS_drawCursor (void);

    /*
     * Rectangle and Point manipulation 
     */

    rect_t MGLAPI MGL_defRect (m_int left, m_int top, m_int right, m_int bottom);
    rect_t MGLAPI MGL_defRectPt (point_t leftTop, point_t rightBottom);
    bool MGLAPI   MGL_sectRect (rect_t s1, rect_t s2, rect_t * d);
    bool MGLAPI   MGL_sectRectCoord (m_int left1, m_int top1, m_int right1, m_int bottom1, m_int left2, m_int top2,
                                     m_int right2, m_int bottom2, rect_t * d);
    void MGLAPI   MGL_unionRect (rect_t s1, rect_t s2, rect_t * d);
    void MGLAPI   MGL_unionRectCoord (m_int left1, m_int top1, m_int right1, m_int bottom1, m_int left2, m_int top2,
                                      m_int right2, m_int bottom2, rect_t * d);

    /*
     * Built-in patterns and mouse cursor 
     */

#  ifndef	MGL_LITE
    pattern_t    *MGLAPI _MGL_getEmptyPat (void);
    pattern_t    *MGLAPI _MGL_getGrayPat (void);
    pattern_t    *MGLAPI _MGL_getSolidPat (void);
#  endif
    cursor_t     *MGLAPI _MGL_getDefCursor (void);

    /*
     * Fixed point multiplication/divide routines 
     */

#  if defined(__WATCOMC__) && defined(__386__)

    /*
     * For Watcom C++ we can use special inline assembler code that is much
     * * faster than calling the 386 assembler functions. Currently this is the
     * * the only compiler that will allow inline assembler to be expanded
     * * directly as inline functions.
     */

    fix32_t       MGL_FixMul (fix32_t a, fix32_t b);
#    pragma aux MGL_FixMul =			\
	"imul	edx"					\
	"add	eax,8000h"				\
	"adc	edx,0"					\
	"shrd	eax,edx,16"				\
	parm [eax] [edx]				\
	value [eax]						\
	modify exact [eax edx];

    fix32_t       MGL_FixDiv (fix32_t a, fix32_t b);
#    pragma aux MGL_FixDiv =			\
	"xor	eax,eax"				\
	"shrd	eax,edx,16"				\
	"sar	edx,16"					\
	"idiv	ebx"              		\
	parm [edx] [ebx] 				\
	value [eax]             		\
	modify exact [eax edx];

    fix32_t       MGL_FixMulDiv (fix32_t a, fix32_t b, fix32_t c);
#    pragma aux MGL_FixMulDiv =			\
	"imul	ebx"					\
	"idiv	ecx"              		\
	parm [eax] [ebx] [ecx] 			\
	value [eax]             		\
	modify exact [eax edx];

    m_int         MGL_backfacing (fix32_t dx1, fix32_t dy1, fix32_t dx2, fix32_t dy2);
#    pragma aux MGL_backfacing =		\
	"imul	ebx"					\
	"mov	ebx,eax"				\
	"mov	ecx,edx"				\
	"mov	eax,esi"				\
	"imul	edi"					\
	"sub	eax,ebx"				\
	"mov	eax,1"					\
	"sbb	edx,ecx"				\
	"jns	@@Backfacing"			\
	"xor	eax,eax"				\
	"@@Backfacing:"					\
	parm [eax] [esi] [edi] [ebx]	\
	value [eax]             		\
	modify exact [eax ecx edx];

    void          MGL_memcpy (void *dst, void *src, m_int n);
#    pragma aux MGL_memcpy =            \
	"mov	eax,ecx"				\
	"shr    ecx,2"                  \
	"rep    movsd"                  \
	"mov	cl,al"					\
	"and	cl,3"					\
	"rep	movsb"					\
	parm [edi] [esi] [ecx]			\
	modify exact [eax ecx esi edi];

#  else

    fix32_t ASMAPI MGL_FixMul (fix32_t a, fix32_t b);
    fix32_t ASMAPI MGL_FixDiv (fix32_t a, fix32_t b);
    fix32_t ASMAPI MGL_FixMulDiv (fix32_t a, fix32_t b, fix32_t c);
    m_int ASMAPI  MGL_backfacing (fix32_t dx1, fix32_t dy1, fix32_t dx2, fix32_t dy2);
    void ASMAPI   MGL_memcpy (void *dst, void *src, m_int n);

#  endif

    /*
     * The following are special memcpy routines that properly handler reading
     * * and writing to virtual linear buffer memory by forcing the proper
     * * alignment. Note that the copy is extended to use a DWORD copy of speed.
     */

    void ASMAPI   MGL_memcpyVIRTSRC (void *dst, void *src, m_int n);
    void ASMAPI   MGL_memcpyVIRTDST (void *dst, void *src, m_int n);

    /*
     * Function to find an MGL system file's full pathname 
     */

    bool MGLAPI   _MGL_findFile (char *validpath, const char *dir, const char *filename, const char *mode);

    /*
     * Override the internal MGL file I/O functions 
     */

    void MGLAPI   MGL_setFileIO (fileio_t * fio);

    /*
     * The following dummy symbols are used to link in driver files to be used. A
     * * driver is not active until it is linked in with the MGL_registerDriver
     * * call. Because we dont export globals in DLLs, we provide functions to
     * * get the address of the drivers. However for a static link library we
     * * need to use globals so that if the driver data is unreferenced, it will
     * * not be linked in with the code.
     */

#  ifndef	BUILD_MGL
#    if	defined(MGL_DLL) && !defined(BUILD_MGLDLL)
    void         *MGLAPI VGA4_getDriverAddr (void);
    void         *MGLAPI VGAX_getDriverAddr (void);
    void         *MGLAPI SVGA4_getDriverAddr (void);
    void         *MGLAPI SVGA8_getDriverAddr (void);
    void         *MGLAPI SVGA16_getDriverAddr (void);
    void         *MGLAPI SVGA24_getDriverAddr (void);
    void         *MGLAPI SVGA32_getDriverAddr (void);
#      if !defined(__16BIT__)
    void         *MGLAPI VGA8_getDriverAddr (void);
    void         *MGLAPI LINEAR8_getDriverAddr (void);
    void         *MGLAPI LINEAR16_getDriverAddr (void);
    void         *MGLAPI LINEAR24_getDriverAddr (void);
    void         *MGLAPI LINEAR32_getDriverAddr (void);
    void         *MGLAPI ACCEL8_getDriverAddr (void);
    void         *MGLAPI ACCEL16_getDriverAddr (void);
    void         *MGLAPI ACCEL24_getDriverAddr (void);
    void         *MGLAPI ACCEL32_getDriverAddr (void);
#        if defined(MGLWIN) || defined(__WINDOWS__)
    void         *MGLAPI DDRAW8_getDriverAddr (void);
    void         *MGLAPI DDRAW16_getDriverAddr (void);
    void         *MGLAPI DDRAW24_getDriverAddr (void);
    void         *MGLAPI DDRAW32_getDriverAddr (void);
#        endif
#      endif
    void         *MGLAPI PACKED1_getDriverAddr (void);
    void         *MGLAPI PACKED4_getDriverAddr (void);
    void         *MGLAPI PACKED8_getDriverAddr (void);
    void         *MGLAPI PACKED16_getDriverAddr (void);
    void         *MGLAPI PACKED24_getDriverAddr (void);
    void         *MGLAPI PACKED32_getDriverAddr (void);
#      define VGA4_driver			VGA4_getDriverAddr()
#      define VGAX_driver			VGAX_getDriverAddr()
#      define SVGA4_driver		SVGA4_getDriverAddr()
#      define SVGA8_driver		SVGA8_getDriverAddr()
#      define SVGA16_driver		SVGA16_getDriverAddr()
#      define SVGA24_driver		SVGA24_getDriverAddr()
#      define SVGA32_driver		SVGA32_getDriverAddr()
#      if !defined(__16BIT__)
#        define VGA8_driver			VGA8_getDriverAddr()
#        define LINEAR8_driver		LINEAR8_getDriverAddr()
#        define LINEAR16_driver		LINEAR16_getDriverAddr()
#        define LINEAR24_driver     LINEAR24_getDriverAddr()
#        define LINEAR32_driver     LINEAR32_getDriverAddr()
#        define ACCEL8_driver       ACCEL8_getDriverAddr()
#        define ACCEL16_driver      ACCEL16_getDriverAddr()
#        define ACCEL24_driver      ACCEL24_getDriverAddr()
#        define ACCEL32_driver      ACCEL32_getDriverAddr()
#        if defined(MGLWIN) || defined(__WINDOWS__)
#          define DDRAW8_driver       DDRAW8_getDriverAddr()
#          define DDRAW16_driver      DDRAW16_getDriverAddr()
#          define DDRAW24_driver      DDRAW24_getDriverAddr()
#          define DDRAW32_driver      DDRAW32_getDriverAddr()
#        endif
#      endif
#      define PACKED1_driver      PACKED1_getDriverAddr()
#      define PACKED4_driver      PACKED4_getDriverAddr()
#      define PACKED8_driver      PACKED8_getDriverAddr()
#      define PACKED16_driver     PACKED16_getDriverAddr()
#      define PACKED24_driver     PACKED24_getDriverAddr()
#      define PACKED32_driver		PACKED32_getDriverAddr()
#    else
    extern m_int _VARAPI VGA4_driver[];
    extern m_int _VARAPI VGAX_driver[];
    extern m_int _VARAPI SVGA4_driver[];
    extern m_int _VARAPI SVGA8_driver[];
    extern m_int _VARAPI SVGA16_driver[];
    extern m_int _VARAPI SVGA24_driver[];
    extern m_int _VARAPI SVGA32_driver[];
#      if !defined(__16BIT__)
    extern m_int _VARAPI VGA8_driver[];
    extern m_int _VARAPI LINEAR8_driver[];
    extern m_int _VARAPI LINEAR16_driver[];
    extern m_int _VARAPI LINEAR24_driver[];
    extern m_int _VARAPI LINEAR32_driver[];
    extern m_int _VARAPI ACCEL8_driver[];
    extern m_int _VARAPI ACCEL16_driver[];
    extern m_int _VARAPI ACCEL24_driver[];
    extern m_int _VARAPI ACCEL32_driver[];
#        if defined(MGLWIN) || defined(__WINDOWS__)
    extern m_int _VARAPI DDRAW8_driver[];
    extern m_int _VARAPI DDRAW16_driver[];
    extern m_int _VARAPI DDRAW24_driver[];
    extern m_int _VARAPI DDRAW32_driver[];
#        endif
#      endif
    extern m_int _VARAPI PACKED1_driver[];
    extern m_int _VARAPI PACKED4_driver[];
    extern m_int _VARAPI PACKED8_driver[];
    extern m_int _VARAPI PACKED16_driver[];
    extern m_int _VARAPI PACKED24_driver[];
    extern m_int _VARAPI PACKED32_driver[];
#    endif
#  endif

/*---------------------------------------------------------------------------
 * Memory allocation and utility functions.
 *-------------------------------------------------------------------------*/

#  ifndef	__16BIT__
#    define	_HUGE
#  else
#    define	_HUGE	_huge
#  endif

    void          MGL_availableMemory (ulong * physical, ulong * total);
    void          MGL_useLocalMalloc (void _HUGE * (*malloc) (long size), void (*free) (void _HUGE * p));
    void         *MGLAPI MGL_malloc (long size);
    void         *MGLAPI MGL_calloc (long size, long n);
    void MGLAPI   MGL_free (void _HUGE * p);
    void MGLAPI   MGL_memset (void _HUGE * s, m_int c, long n);
    void MGLAPI   MGL_memsetw (void _HUGE * s, m_int c, long n);
    void MGLAPI   MGL_memsetl (void _HUGE * s, long c, long n);

/*---------------------------------------------------------------------------
 * Set a fullscreen suspend application callback function. This is used in
 * fullscreen video modes to allow switching back to the normal operating
 * system graphical shell (such as Windows GDI, OS/2 PM etc).
 *-------------------------------------------------------------------------*/

    typedef       m_int (ASMAPI * MGL_suspend_cb_t) (MGLDC * dc, m_int flags);
    void MGLAPI   MGL_setSuspendAppCallback (MGL_suspend_cb_t staveState);

/*---------------------------------------------------------------------------
 * Tell the MGL to use a pre-loaded ACCEL.DRV driver file. This allows
 * you to link with the SciTech WinDirect/Pro and WinDirect/Ultra device
 * support libraries and tell the MGL to use the device support drivers.
 * If the user has a real ACCEL.DRV driver file in the standard location
 * on their machine, this driver file will still be used.
 *-------------------------------------------------------------------------*/

    void MGLAPI   MGL_setACCELDriver (void *driver);

/*---------------------- Inline functions as Macros -----------------------*/

#  define	MGL_equalPoint(p1,p2)	((p1).x == (p2).x && (p1).y == (p2).y)

#  define	MGL_equalRect(r1,r2)	((r1).left == (r2).left &&			\
								 (r1).top == (r2).top &&			\
								 (r1).right == (r2).right &&		\
								 (r1).bottom == (r2).bottom)

#  define	MGL_emptyRect(r)		((r).bottom <= (r).top || 			\
								 (r).right <= (r).left)

#  define	MGL_disjointRect(r1,r2)	((r1).right <= (r2).left ||			\
								 (r1).left >= (r2).right ||			\
								 (r1).bottom <= (r2).top ||			\
								 (r1).top >= (r2).bottom)

#  define	MGL_sectRect(s1,s2,d)										\
   ((d)->left = MAX((s1).left,(s2).left),                           \
	(d)->right = MIN((s1).right,(s2).right),                        \
	(d)->top = MAX((s1).top,(s2).top),                              \
	(d)->bottom = MIN((s1).bottom,(s2).bottom),                     \
	!MGL_emptyRect(*d))

#  define	MGL_sectRectFast(s1,s2,d)									\
	(d)->left = MAX((s1).left,(s2).left);                           \
	(d)->right = MIN((s1).right,(s2).right);                        \
	(d)->top = MAX((s1).top,(s2).top);                              \
	(d)->bottom = MIN((s1).bottom,(s2).bottom)

#  define	MGL_sectRectCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)				\
   ((d)->left = MAX(l1,l2),											\
	(d)->right = MIN(r1,r2),										\
	(d)->top = MAX(t1,t2),											\
	(d)->bottom = MIN(b1,b2),										\
	!MGL_emptyRect(*d))

#  define	MGL_sectRectFastCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)			\
	(d)->left = MAX(l1,l2);											\
	(d)->right = MIN(r1,r2);										\
	(d)->top = MAX(t1,t2);											\
	(d)->bottom = MIN(b1,b2)

#  define	MGL_unionRect(s1,s2,d)										\
	(d)->left = MIN((s1).left,(s2).left);                           \
	(d)->right = MAX((s1).right,(s2).right);                        \
	(d)->top = MIN((s1).top,(s2).top);                              \
	(d)->bottom = MAX((s1).bottom,(s2).bottom)

#  define MGL_unionRectCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)				\
	(d)->left = MIN(l1,l2);                                 		\
	(d)->right = MAX(r1,r2);                              			\
	(d)->top = MIN(t1,t2);                                    		\
	(d)->bottom = MAX(b1,b2)

#  define	MGL_offsetRect(r,dx,dy)										\
	{	(r).left += dx; (r).right += dx;							\
		(r).top += dy; (r).bottom += dy; }

#  define	MGL_insetRect(r,dx,dy)										\
	{	(r).left += dx; (r).right -= dx;							\
		(r).top += dy; (r).bottom -= dy;							\
		if (MGL_emptyRect(r))										\
			(r).left = (r).right = (r).top = (r).bottom = 0; }

#  define	MGL_ptInRect(p,r)		((p).x >= (r).left &&				\
								 (p).x < (r).right &&				\
								 (p).y >= (r).top &&				\
								 (p).y < (r).bottom)

#  define	MGL_ptInRectCoord(x,y,r)	((x) >= (r).left &&				\
									 (x) < (r).right &&				\
									 (y) >= (r).top &&				\
									 (y) < (r).bottom)

#  define	MGL_ptInRegion(p,r)		MGL_ptInRegionCoord((p).x,(p).y,r)

#  define	MGL_pixel(p)			MGL_pixelCoord((p).x,(p).y)
#  define	MGL_getPixel(p)			MGL_getPixelCoord((p).x,(p).y)
#  define	MGL_pixelFast(p)		MGL_pixelCoordFast((p).x,(p).y)
#  define	MGL_getPixelFast(p)		MGL_getPixelCoordFast((p).x,(p).y)
#  define	MGL_moveTo(p)			MGL_moveToCoord((p).x,(p).y)
#  define MGL_moveRel(p)			MGL_moveRelCoord((p).x,(p).y)
#  define	MGL_line(p1,p2)			MGL_lineCoord((p1).x,(p1).y,(p2).x,(p2).y)
#  define	MGL_lineFast(p1,p2)		MGL_lineCoordFast((p1).x,(p1).y,(p2).x,(p2).y)
#  define	MGL_lineFX(p1,p2)		MGL_lineCoordFX((p1).x,(p1).y,(p2).x,(p2).y)
#  define	MGL_lineFastFX(p1,p2)	MGL_lineCoordFastFX((p1).x,(p1).y,(p2).x,(p2).y)
#  define	MGL_cLineFast(p1,p2)	MGL_cLineCoordFast((p1).p.x,(p1).p.y,(p1).c,(p2).p.x,(p2).p.y,(p2).c)
#  define	MGL_rgbLineFast(p1,p2)	MGL_rgbLineCoordFast((p1).p.x,(p1).p.y,(p1).c.r,(p1).c.g,(p1).c.b,(p2).p.x,(p2).p.y,(p2).c.r,(p2).c.g,(p2).c.b)
#  define	MGL_zLineFast(p1,p2)	MGL_zLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p2).p.x,(p2).p.y,(p2).z)
#  define	MGL_czLineFast(p1,p2)	MGL_czLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p1).c,(p2).p.x,(p2).p.y,(p2).z,(p2).c)
#  define	MGL_rgbzLineFast(p1,p2)	MGL_rgbzLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p1).c.r,(p1).c.g,(p1).c.b,(p2).p.x,(p2).p.y,(p2).z,(p2).c.r,(p2).c.g,(p2).c.b)

#  define	MGL_zClearPt(lt,rb,z)	MGL_zClearCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y,z)
#  define	MGL_zClear(r,z)			MGL_zClearCoord((r).left,(r).top,	\
									(r).right,(r).bottom,z)
#  define	MGL_lineTo(p)			MGL_lineToCoord((p).x,(p).y)
#  define	MGL_lineRel(p)			MGL_lineRelCoord((p).x,(p).y);
#  define	MGL_rectPt(lt,rb)		MGL_rectCoord((lt).x,(lt).y,(rb).x,(rb).y)
#  define	MGL_rect(r)				MGL_rectCoord((r).left,(r).top,			\
									(r).right,(r).bottom)
#  define	MGL_drawBorder(r,s,t)	MGL_drawBorderCoord((r).left,(r).top,	\
									(r).right,(r).bottom,(s),(t))
#  define	MGL_fillRectPt(lt,rb)	MGL_fillRectCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y)
#  define	MGL_fillRect(r)			MGL_fillRectCoord((r).left,(r).top,	\
									(r).right,(r).bottom)
#  define	MGL_bitBlt(d,s,r,dl,dt,op) 	MGL_bitBltCoord((d),(s),(r).left,		\
									(r).top,(r).right,(r).bottom,dl,dt,op)
#  define	MGL_bitBltLin(d,s,so,r,op) MGL_bitBltLinCoord((d),(s),so,			\
									(r).left,(r).top,(r).right,(r).bottom,op)
#  define	MGL_stretchBlt(d,s,sr,dr) 	MGL_stretchBltCoord((d),(s),(sr).left,		\
									(sr).top,(sr).right,(sr).bottom,	\
									(dr).left,(dr).top,(dr).right,(dr).bottom)
#  define	MGL_transBlt(d,s,r,dl,dt,c,st)	MGL_transBltCoord((d),(s),(r).left,		\
									(r).top,(r).right,(r).bottom,dl,dt,c,st)
#  define	MGL_transBltLin(d,s,so,r,c,st) MGL_transBltLinCoord((d),(s),so,	\
									(r).left,(r).top,(r).right,(r).bottom,c,st)
#  define	MGL_getDivot(dc,r,divot) MGL_getDivotCoord(dc,(r).left,(r).top,	\
									(r).right,(r).bottom,divot)
#  define	MGL_divotSize(dc,r)		MGL_divotSizeCoord(dc,(r).left,(r).top,\
									(r).right,(r).bottom)
#  define	MGL_isSimpleRegion(r)	(((region_t*)(r))->spans == NULL)
#  define	MGL_rgnLine(p1,p2,p)	MGL_rgnLineCoord((p1).x,(p1).y,(p2).x,(p2).y,p)
#  define	MGL_rgnLineFX(p1,p2,p)	MGL_rgnLineCoordFX((p1).x,(p1).y,(p2).x,(p2).y,p)
#  define	MGL_rgnSolidRectPt(lt,rb)	MGL_rgnSolidRectCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y)
#  define	MGL_rgnSolidRect(r)			MGL_rgnSolidRectCoord((r).left,(r).top,	\
									(r).right,(r).bottom)

    /*
     * Fast color packing/unpacking routines implemented as macros 
     */

#  define	MGL_packColorFast(pf,R,G,B)													\
 ((ulong)(((uchar)(R) >> (pf)->redAdjust) & (pf)->redMask) << (pf)->redPos)			\
 | ((ulong)(((uchar)(G) >> (pf)->greenAdjust) & (pf)->greenMask) << (pf)->greenPos)	\
 | ((ulong)(((uchar)(B) >> (pf)->blueAdjust) & (pf)->blueMask) << (pf)->bluePos)

#  define	MGL_unpackColorFast(pf,c,R,G,B)												\
{																					\
 (R) = (uchar)((((ulong)(c) >> (pf)->redPos) & (pf)->redMask) << (pf)->redAdjust);		\
 (G) = (uchar)((((ulong)(c) >> (pf)->greenPos) & (pf)->greenMask) << (pf)->greenAdjust);\
 (B) = (uchar)((((ulong)(c) >> (pf)->bluePos) & (pf)->blueMask) << (pf)->blueAdjust);	\
}

    /*
     * Macros to access the RGB components in a packed 24 bit RGB tuple 
     */

#  define	MGL_rgbRed(c)	(((uchar*)&(c))[2])
#  define	MGL_rgbGreen(c)	(((uchar*)&(c))[1])
#  define	MGL_rgbBlue(c)	(((uchar*)&(c))[0])

    /*
     * Fast 24 bit color packing/unpacking routines implemented as macros 
     */

#  define	MGL_packColorRGBFast(R,G,B)											\
 (((ulong)((uchar)(R)) << 16) | ((ulong)((uchar)(G)) << 8) | (uchar)(B))

#  define	MGL_packColorRGBFast2(c,R,G,B)										\
{																			\
 MGL_rgbRed(c) = (uchar)(R);												\
 MGL_rgbGreen(c) = (uchar)(G);												\
 MGL_rgbBlue(c) = (uchar)(B);												\
}

#  define	MGL_unpackColorRGBFast(c,R,G,B)										\
{																			\
 (R) = MGL_rgbRed(c);														\
 (G) = MGL_rgbGreen(c);														\
 (B) = MGL_rgbBlue(c);														\
}

#  ifdef	__cplusplus
}                                      /* End of "C" linkage for C++   */
#    include "mglrect.hpp"             /* Include C++ point/rectangle classes                  */
#  endif                               /* __cplusplus */
/*
 * Include appropriate platform specific bindings 
 */
#  if defined(MGLWIN) || defined(__WINDOWS__)
#    include "mglwin.h"
#  elif defined(MGLPM) || defined(__OS2__)
/*
 * #include "mglpm.h"
 */
#  elif defined(MGLX) || defined(__UNIX__)
/*
 * #include "mglx.h"
 */
#  else
#    include "mgldos.h"
#  endif
#  pragma pack()                       /* Return to default packing                            */
#endif                                 /* __MGRAPH_H */
