/*
 * wingdi.d
 *
 * This module binds wingdi.h to D. The original copyright notice is
 * preserved below.
 *
 * Author: Dave Wilkinson
 * Originated: November 24th, 2009
 *
 */

module binding.win32.wingdi;

import binding.win32.windef;
import binding.win32.winnt;
import binding.win32.winuser;

import binding.c;

extern(System):

// The original copyright from WinGDI.h:

/**************************************************************************
*                                                                         *
* wingdi.h -- GDI procedure declarations, constant definitions and macros *
*                                                                         *
* Copyright (c) Microsoft Corp. All rights reserved.                      *
*                                                                         *
**************************************************************************/

/* Binary raster ops */
const auto R2_BLACK            = 1;   /*  0       */
const auto R2_NOTMERGEPEN      = 2;   /* DPon     */
const auto R2_MASKNOTPEN       = 3;   /* DPna     */
const auto R2_NOTCOPYPEN       = 4;   /* PN       */
const auto R2_MASKPENNOT       = 5;   /* PDna     */
const auto R2_NOT              = 6;   /* Dn       */
const auto R2_XORPEN           = 7;   /* DPx      */
const auto R2_NOTMASKPEN       = 8;   /* DPan     */
const auto R2_MASKPEN          = 9;   /* DPa      */
const auto R2_NOTXORPEN        = 10;  /* DPxn     */
const auto R2_NOP              = 11;  /* D        */
const auto R2_MERGENOTPEN      = 12;  /* DPno     */
const auto R2_COPYPEN          = 13;  /* P        */
const auto R2_MERGEPENNOT      = 14;  /* PDno     */
const auto R2_MERGEPEN         = 15;  /* DPo      */
const auto R2_WHITE            = 16;  /*  1       */
const auto R2_LAST             = 16;

/* Ternary raster operations */
const auto SRCCOPY             = cast(DWORD)0x00CC0020; /* dest = source                   */
const auto SRCPAINT            = cast(DWORD)0x00EE0086; /* dest = source OR dest           */
const auto SRCAND              = cast(DWORD)0x008800C6; /* dest = source AND dest          */
const auto SRCINVERT           = cast(DWORD)0x00660046; /* dest = source XOR dest          */
const auto SRCERASE            = cast(DWORD)0x00440328; /* dest = source AND (NOT dest )   */
const auto NOTSRCCOPY          = cast(DWORD)0x00330008; /* dest = (NOT source)             */
const auto NOTSRCERASE         = cast(DWORD)0x001100A6; /* dest = (NOT src) AND (NOT dest) */
const auto MERGECOPY           = cast(DWORD)0x00C000CA; /* dest = (source AND pattern)     */
const auto MERGEPAINT          = cast(DWORD)0x00BB0226; /* dest = (NOT source) OR dest     */
const auto PATCOPY             = cast(DWORD)0x00F00021; /* dest = pattern                  */
const auto PATPAINT            = cast(DWORD)0x00FB0A09; /* dest = DPSnoo                   */
const auto PATINVERT           = cast(DWORD)0x005A0049; /* dest = pattern XOR dest         */
const auto DSTINVERT           = cast(DWORD)0x00550009; /* dest = (NOT dest)               */
const auto BLACKNESS           = cast(DWORD)0x00000042; /* dest = BLACK                    */
const auto WHITENESS           = cast(DWORD)0x00FF0062; /* dest = WHITE                    */

const auto NOMIRRORBITMAP      = cast(DWORD)0x80000000; /* Do not Mirror the bitmap in this call */
const auto CAPTUREBLT          = cast(DWORD)0x40000000; /* Include layered windows */

/* Quaternary raster codes */
template MAKEROP4(uint fore, uint back) {
	const uint MAKEROP4 = cast(uint)((((back) << 8) & 0xFF000000) | (fore));
}

const auto GDI_ERROR = (0xFFFFFFFFL);

const auto HGDI_ERROR = cast(HANDLE)(-1);

/* Region Flags */
const auto ERROR				= 0;
const auto NULLREGION			= 1;
const auto SIMPLEREGION			= 2;
const auto COMPLEXREGION		= 3;
const auto RGN_ERROR 			= ERROR;

/* CombineRgn() Styles */
const auto RGN_AND             = 1;
const auto RGN_OR              = 2;
const auto RGN_XOR             = 3;
const auto RGN_DIFF            = 4;
const auto RGN_COPY            = 5;
const auto RGN_MIN             = RGN_AND;
const auto RGN_MAX             = RGN_COPY;

/* StretchBlt() Modes */
const auto BLACKONWHITE                 = 1;
const auto WHITEONBLACK                 = 2;
const auto COLORONCOLOR                 = 3;
const auto HALFTONE                     = 4;
const auto MAXSTRETCHBLTMODE            = 4;

/* New StretchBlt() Modes */
const auto STRETCH_ANDSCANS    = BLACKONWHITE;
const auto STRETCH_ORSCANS     = WHITEONBLACK;
const auto STRETCH_DELETESCANS = COLORONCOLOR;
const auto STRETCH_HALFTONE    = HALFTONE;

/* PolyFill() Modes */
const auto ALTERNATE                    = 1;
const auto WINDING                      = 2;
const auto POLYFILL_LAST                = 2;

/* Layout Orientation Options */
const auto LAYOUT_RTL                         = 0x00000001; // Right to left
const auto LAYOUT_BTT                         = 0x00000002; // Bottom to top
const auto LAYOUT_VBH                         = 0x00000004; // Vertical before horizontal
const auto LAYOUT_ORIENTATIONMASK             = (LAYOUT_RTL | LAYOUT_BTT | LAYOUT_VBH);
const auto LAYOUT_BITMAPORIENTATIONPRESERVED  = 0x00000008;

/* Text Alignment Options */
const auto TA_NOUPDATECP                = 0;
const auto TA_UPDATECP                  = 1;

const auto TA_LEFT                      = 0;
const auto TA_RIGHT                     = 2;
const auto TA_CENTER                    = 6;

const auto TA_TOP                       = 0;
const auto TA_BOTTOM                    = 8;
const auto TA_BASELINE                  = 24;

const auto TA_RTLREADING                = 256;
const auto TA_MASK       = (TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING);

const auto VTA_BASELINE = TA_BASELINE;
const auto VTA_LEFT     = TA_BOTTOM;
const auto VTA_RIGHT    = TA_TOP;
const auto VTA_CENTER   = TA_CENTER;
const auto VTA_BOTTOM   = TA_RIGHT;
const auto VTA_TOP      = TA_LEFT;

const auto ETO_OPAQUE                   = 0x0002;
const auto ETO_CLIPPED                  = 0x0004;

const auto ETO_GLYPH_INDEX              = 0x0010;
const auto ETO_RTLREADING               = 0x0080;
const auto ETO_NUMERICSLOCAL            = 0x0400;
const auto ETO_NUMERICSLATIN            = 0x0800;
const auto ETO_IGNORELANGUAGE           = 0x1000;

const auto ETO_PDY                      = 0x2000;
const auto ETO_REVERSE_INDEX_MAP        = 0x10000;

const auto ASPECT_FILTERING             = 0x0001;

/* Bounds Accumulation APIs */

const auto DCB_RESET       = 0x0001;
const auto DCB_ACCUMULATE  = 0x0002;
const auto DCB_DIRTY       = DCB_ACCUMULATE;
const auto DCB_SET         = (DCB_RESET | DCB_ACCUMULATE);
const auto DCB_ENABLE      = 0x0004;
const auto DCB_DISABLE     = 0x0008;

/* Metafile Functions */
const auto META_SETBKCOLOR              = 0x0201;
const auto META_SETBKMODE               = 0x0102;
const auto META_SETMAPMODE              = 0x0103;
const auto META_SETROP2                 = 0x0104;
const auto META_SETRELABS               = 0x0105;
const auto META_SETPOLYFILLMODE         = 0x0106;
const auto META_SETSTRETCHBLTMODE       = 0x0107;
const auto META_SETTEXTCHAREXTRA        = 0x0108;
const auto META_SETTEXTCOLOR            = 0x0209;
const auto META_SETTEXTJUSTIFICATION    = 0x020A;
const auto META_SETWINDOWORG            = 0x020B;
const auto META_SETWINDOWEXT            = 0x020C;
const auto META_SETVIEWPORTORG          = 0x020D;
const auto META_SETVIEWPORTEXT          = 0x020E;
const auto META_OFFSETWINDOWORG         = 0x020F;
const auto META_SCALEWINDOWEXT          = 0x0410;
const auto META_OFFSETVIEWPORTORG       = 0x0211;
const auto META_SCALEVIEWPORTEXT        = 0x0412;
const auto META_LINETO                  = 0x0213;
const auto META_MOVETO                  = 0x0214;
const auto META_EXCLUDECLIPRECT         = 0x0415;
const auto META_INTERSECTCLIPRECT       = 0x0416;
const auto META_ARC                     = 0x0817;
const auto META_ELLIPSE                 = 0x0418;
const auto META_FLOODFILL               = 0x0419;
const auto META_PIE                     = 0x081A;
const auto META_RECTANGLE               = 0x041B;
const auto META_ROUNDRECT               = 0x061C;
const auto META_PATBLT                  = 0x061D;
const auto META_SAVEDC                  = 0x001E;
const auto META_SETPIXEL                = 0x041F;
const auto META_OFFSETCLIPRGN           = 0x0220;
const auto META_TEXTOUT                 = 0x0521;
const auto META_BITBLT                  = 0x0922;
const auto META_STRETCHBLT              = 0x0B23;
const auto META_POLYGON                 = 0x0324;
const auto META_POLYLINE                = 0x0325;
const auto META_ESCAPE                  = 0x0626;
const auto META_RESTOREDC               = 0x0127;
const auto META_FILLREGION              = 0x0228;
const auto META_FRAMEREGION             = 0x0429;
const auto META_INVERTREGION            = 0x012A;
const auto META_PAINTREGION             = 0x012B;
const auto META_SELECTCLIPREGION        = 0x012C;
const auto META_SELECTOBJECT            = 0x012D;
const auto META_SETTEXTALIGN            = 0x012E;
const auto META_CHORD                   = 0x0830;
const auto META_SETMAPPERFLAGS          = 0x0231;
const auto META_EXTTEXTOUT              = 0x0a32;
const auto META_SETDIBTODEV             = 0x0d33;
const auto META_SELECTPALETTE           = 0x0234;
const auto META_REALIZEPALETTE          = 0x0035;
const auto META_ANIMATEPALETTE          = 0x0436;
const auto META_SETPALENTRIES           = 0x0037;
const auto META_POLYPOLYGON             = 0x0538;
const auto META_RESIZEPALETTE           = 0x0139;
const auto META_DIBBITBLT               = 0x0940;
const auto META_DIBSTRETCHBLT           = 0x0b41;
const auto META_DIBCREATEPATTERNBRUSH   = 0x0142;
const auto META_STRETCHDIB              = 0x0f43;
const auto META_EXTFLOODFILL            = 0x0548;

const auto META_SETLAYOUT               = 0x0149;

const auto META_DELETEOBJECT            = 0x01f0;
const auto META_CREATEPALETTE           = 0x00f7;
const auto META_CREATEPATTERNBRUSH      = 0x01F9;
const auto META_CREATEPENINDIRECT       = 0x02FA;
const auto META_CREATEFONTINDIRECT      = 0x02FB;
const auto META_CREATEBRUSHINDIRECT     = 0x02FC;
const auto META_CREATEREGION            = 0x06FF;

struct DRAWPATRECT {
	POINT ptPosition;
	POINT ptSize;
	WORD wStyle;
	WORD wPattern;
}

typedef DRAWPATRECT* PDRAWPATRECT;

/* GDI Escapes */
const auto NEWFRAME                     = 1;
const auto ABORTDOC                     = 2;
const auto NEXTBAND                     = 3;
const auto SETCOLORTABLE                = 4;
const auto GETCOLORTABLE                = 5;
const auto FLUSHOUTPUT                  = 6;
const auto DRAFTMODE                    = 7;
const auto QUERYESCSUPPORT              = 8;
const auto SETABORTPROC                 = 9;
const auto STARTDOC                     = 10;
const auto ENDDOC                       = 11;
const auto GETPHYSPAGESIZE              = 12;
const auto GETPRINTINGOFFSET            = 13;
const auto GETSCALINGFACTOR             = 14;
const auto MFCOMMENT                    = 15;
const auto GETPENWIDTH                  = 16;
const auto SETCOPYCOUNT                 = 17;
const auto SELECTPAPERSOURCE            = 18;
const auto DEVICEDATA                   = 19;
const auto PASSTHROUGH                  = 19;
const auto GETTECHNOLGY                 = 20;
const auto GETTECHNOLOGY                = 20;
const auto SETLINECAP                   = 21;
const auto SETLINEJOIN                  = 22;
const auto SETMITERLIMIT                = 23;
const auto BANDINFO                     = 24;
const auto DRAWPATTERNRECT              = 25;
const auto GETVECTORPENSIZE             = 26;
const auto GETVECTORBRUSHSIZE           = 27;
const auto ENABLEDUPLEX                 = 28;
const auto GETSETPAPERBINS              = 29;
const auto GETSETPRINTORIENT            = 30;
const auto ENUMPAPERBINS                = 31;
const auto SETDIBSCALING                = 32;
const auto EPSPRINTING                  = 33;
const auto ENUMPAPERMETRICS             = 34;
const auto GETSETPAPERMETRICS           = 35;
const auto POSTSCRIPT_DATA              = 37;
const auto POSTSCRIPT_IGNORE            = 38;
const auto MOUSETRAILS                  = 39;
const auto GETDEVICEUNITS               = 42;

const auto GETEXTENDEDTEXTMETRICS       = 256;
const auto GETEXTENTTABLE               = 257;
const auto GETPAIRKERNTABLE             = 258;
const auto GETTRACKKERNTABLE            = 259;
const auto EXTTEXTOUT                   = 512;
const auto GETFACENAME                  = 513;
const auto DOWNLOADFACE                 = 514;
const auto ENABLERELATIVEWIDTHS         = 768;
const auto ENABLEPAIRKERNING            = 769;
const auto SETKERNTRACK                 = 770;
const auto SETALLJUSTVALUES             = 771;
const auto SETCHARSET                   = 772;

const auto STRETCHBLT                   = 2048;
const auto METAFILE_DRIVER              = 2049;
const auto GETSETSCREENPARAMS           = 3072;
const auto QUERYDIBSUPPORT              = 3073;
const auto BEGIN_PATH                   = 4096;
const auto CLIP_TO_PATH                 = 4097;
const auto END_PATH                     = 4098;
const auto EXT_DEVICE_CAPS              = 4099;
const auto RESTORE_CTM                  = 4100;
const auto SAVE_CTM                     = 4101;
const auto SET_ARC_DIRECTION            = 4102;
const auto SET_BACKGROUND_COLOR         = 4103;
const auto SET_POLY_MODE                = 4104;
const auto SET_SCREEN_ANGLE             = 4105;
const auto SET_SPREAD                   = 4106;
const auto TRANSFORM_CTM                = 4107;
const auto SET_CLIP_BOX                 = 4108;
const auto SET_BOUNDS                   = 4109;
const auto SET_MIRROR_MODE              = 4110;
const auto OPENCHANNEL                  = 4110;
const auto DOWNLOADHEADER               = 4111;
const auto CLOSECHANNEL                 = 4112;
const auto POSTSCRIPT_PASSTHROUGH       = 4115;
const auto ENCAPSULATED_POSTSCRIPT      = 4116;

const auto POSTSCRIPT_IDENTIFY          = 4117;   /* new escape for NT5 pscript driver */
const auto POSTSCRIPT_INJECTION         = 4118;   /* new escape for NT5 pscript driver */

const auto CHECKJPEGFORMAT              = 4119;
const auto CHECKPNGFORMAT               = 4120;

const auto GET_PS_FEATURESETTING        = 4121;   /* new escape for NT5 pscript driver */

const auto GDIPLUS_TS_QUERYVER          = 4122;   /* private escape */
const auto GDIPLUS_TS_RECORD            = 4123;   /* private escape */

/*
 * Return Values for MILCORE_TS_QUERYVER
 */

const auto MILCORE_TS_QUERYVER_RESULT_FALSE = 0x0;
const auto MILCORE_TS_QUERYVER_RESULT_TRUE  = 0x7FFFFFFF;

const auto SPCLPASSTHROUGH2             = 4568;   /* new escape for NT5 pscript driver */

/*
 * Parameters for POSTSCRIPT_IDENTIFY escape
 */

const auto PSIDENT_GDICENTRIC    = 0;
const auto PSIDENT_PSCENTRIC     = 1;

/*
 * Header structure for the input buffer to POSTSCRIPT_INJECTION escape
 */

struct PSINJECTDATA {

    DWORD   DataBytes;      /* number of raw data bytes (NOT including this header) */
    WORD    InjectionPoint; /* injection point */
    WORD    PageNumber;     /* page number to apply the injection */

    /* Followed by raw data to be injected */

}

typedef PSINJECTDATA* PPSINJECTDATA;

/*
 * Constants for PSINJECTDATA.InjectionPoint field
 */

const auto PSINJECT_BEGINSTREAM                = 1;
const auto PSINJECT_PSADOBE                    = 2;
const auto PSINJECT_PAGESATEND                 = 3;
const auto PSINJECT_PAGES                      = 4;

const auto PSINJECT_DOCNEEDEDRES               = 5;
const auto PSINJECT_DOCSUPPLIEDRES             = 6;
const auto PSINJECT_PAGEORDER                  = 7;
const auto PSINJECT_ORIENTATION                = 8;
const auto PSINJECT_BOUNDINGBOX                = 9;
const auto PSINJECT_DOCUMENTPROCESSCOLORS      = 10;

const auto PSINJECT_COMMENTS                   = 11;
const auto PSINJECT_BEGINDEFAULTS              = 12;
const auto PSINJECT_ENDDEFAULTS                = 13;
const auto PSINJECT_BEGINPROLOG                = 14;
const auto PSINJECT_ENDPROLOG                  = 15;
const auto PSINJECT_BEGINSETUP                 = 16;
const auto PSINJECT_ENDSETUP                   = 17;
const auto PSINJECT_TRAILER                    = 18;
const auto PSINJECT_EOF                        = 19;
const auto PSINJECT_ENDSTREAM                  = 20;
const auto PSINJECT_DOCUMENTPROCESSCOLORSATEND = 21;

const auto PSINJECT_PAGENUMBER                 = 100;
const auto PSINJECT_BEGINPAGESETUP             = 101;
const auto PSINJECT_ENDPAGESETUP               = 102;
const auto PSINJECT_PAGETRAILER                = 103;
const auto PSINJECT_PLATECOLOR                 = 104;

const auto PSINJECT_SHOWPAGE                   = 105;
const auto PSINJECT_PAGEBBOX                   = 106;
const auto PSINJECT_ENDPAGECOMMENTS            = 107;

const auto PSINJECT_VMSAVE                     = 200;
const auto PSINJECT_VMRESTORE                  = 201;

/*
 * Parameter for GET_PS_FEATURESETTING escape
 */

const auto FEATURESETTING_NUP                  = 0;
const auto FEATURESETTING_OUTPUT               = 1;
const auto FEATURESETTING_PSLEVEL              = 2;
const auto FEATURESETTING_CUSTPAPER            = 3;
const auto FEATURESETTING_MIRROR               = 4;
const auto FEATURESETTING_NEGATIVE             = 5;
const auto FEATURESETTING_PROTOCOL             = 6;

//
// The range of selectors between FEATURESETTING_PRIVATE_BEGIN and
// FEATURESETTING_PRIVATE_END is reserved by Microsoft for private use
//
const auto FEATURESETTING_PRIVATE_BEGIN = 0x1000;
const auto FEATURESETTING_PRIVATE_END   = 0x1FFF;

/*
 * Information about output options
 */

struct PSFEATURE_OUTPUT {
    BOOL bPageIndependent;
    BOOL bSetPageDevice;
}

typedef PSFEATURE_OUTPUT* PPSFEATURE_OUTPUT;

/*
 * Information about custom paper size
 */

struct PSFEATURE_CUSTPAPER {
	LONG lOrientation;
	LONG lWidth;
	LONG lHeight;
	LONG lWidthOffset;
	LONG lHeightOffset;

}

typedef PSFEATURE_CUSTPAPER* PPSFEATURE_CUSTPAPER;

/* Value returned for FEATURESETTING_PROTOCOL */
const auto PSPROTOCOL_ASCII             = 0;
const auto PSPROTOCOL_BCP               = 1;
const auto PSPROTOCOL_TBCP              = 2;
const auto PSPROTOCOL_BINARY            = 3;

/* Flag returned from QUERYDIBSUPPORT */
const auto QDI_SETDIBITS                = 1;
const auto QDI_GETDIBITS                = 2;
const auto QDI_DIBTOSCREEN              = 4;
const auto QDI_STRETCHDIB               = 8;

/* Spooler Error Codes */
const auto SP_NOTREPORTED               = 0x4000;
const auto SP_ERROR                     = (-1);
const auto SP_APPABORT                  = (-2);
const auto SP_USERABORT                 = (-3);
const auto SP_OUTOFDISK                 = (-4);
const auto SP_OUTOFMEMORY               = (-5);

const auto PR_JOBSTATUS                 = 0x0000;

/* Object Definitions for EnumObjects() */
const auto OBJ_PEN             = 1;
const auto OBJ_BRUSH           = 2;
const auto OBJ_DC              = 3;
const auto OBJ_METADC          = 4;
const auto OBJ_PAL             = 5;
const auto OBJ_FONT            = 6;
const auto OBJ_BITMAP          = 7;
const auto OBJ_REGION          = 8;
const auto OBJ_METAFILE        = 9;
const auto OBJ_MEMDC           = 10;
const auto OBJ_EXTPEN          = 11;
const auto OBJ_ENHMETADC       = 12;
const auto OBJ_ENHMETAFILE     = 13;
const auto OBJ_COLORSPACE      = 14;

const auto GDI_OBJ_LAST        = OBJ_COLORSPACE;

/* xform stuff */
const auto MWT_IDENTITY        = 1;
const auto MWT_LEFTMULTIPLY    = 2;
const auto MWT_RIGHTMULTIPLY   = 3;

const auto MWT_MIN             = MWT_IDENTITY;
const auto MWT_MAX             = MWT_RIGHTMULTIPLY;

const auto _XFORM_ = 0;
struct XFORM {
	FLOAT   eM11;
	FLOAT   eM12;
	FLOAT   eM21;
	FLOAT   eM22;
	FLOAT   eDx;
	FLOAT   eDy;
}

typedef XFORM* PXFORM;
typedef XFORM* LPXFORM;

/* Bitmap Header Definition */
struct BITMAP {
	LONG        bmType;
	LONG        bmWidth;
	LONG        bmHeight;
	LONG        bmWidthBytes;
	WORD        bmPlanes;
	WORD        bmBitsPixel;
	LPVOID      bmBits;
}

typedef BITMAP* PBITMAP;
typedef BITMAP* NPBITMAP;
typedef BITMAP* LPBITMAP;

align(1) struct RGBTRIPLE {
	BYTE    rgbtBlue;
	BYTE    rgbtGreen;
	BYTE    rgbtRed;
} 

typedef RGBTRIPLE* PRGBTRIPLE;
typedef RGBTRIPLE* NPRGBTRIPLE;
typedef RGBTRIPLE* LPRGBTRIPLE;

struct RGBQUAD {
	BYTE    rgbBlue;
	BYTE    rgbGreen;
	BYTE    rgbRed;
	BYTE    rgbReserved;
}
typedef RGBQUAD* LPRGBQUAD;

/* Image Color Matching color definitions */

const auto CS_ENABLE                       = 0x00000001;
const auto CS_DISABLE                      = 0x00000002;
const auto CS_DELETE_TRANSFORM             = 0x00000003;

/* Logcolorspace signature */

const auto LCS_SIGNATURE           = "PSOC"c;

/* Logcolorspace lcsType values */

const auto LCS_sRGB                = "sRGB"c;
const auto LCS_WINDOWS_COLOR_SPACE = "Win "c;  // Windows default color space

typedef LONG LCSCSTYPE;
const auto LCS_CALIBRATED_RGB              = 0x00000000;

typedef LONG LCSGAMUTMATCH;
const auto LCS_GM_BUSINESS                 = 0x00000001;
const auto LCS_GM_GRAPHICS                 = 0x00000002;
const auto LCS_GM_IMAGES                   = 0x00000004;
const auto LCS_GM_ABS_COLORIMETRIC         = 0x00000008;

/* ICM Defines for results from CheckColorInGamut() */
const auto CM_OUT_OF_GAMUT                 = 255;
const auto CM_IN_GAMUT                     = 0;

/* UpdateICMRegKey Constants               */
const auto ICM_ADDPROFILE                  = 1;
const auto ICM_DELETEPROFILE               = 2;
const auto ICM_QUERYPROFILE                = 3;
const auto ICM_SETDEFAULTPROFILE           = 4;
const auto ICM_REGISTERICMATCHER           = 5;
const auto ICM_UNREGISTERICMATCHER         = 6;
const auto ICM_QUERYMATCH                  = 7;

/* Macros to retrieve CMYK values from a COLORREF */
template GetKValue(COLORREF cmyk) {
	const BYTE GetKValue = cast(BYTE)(cmyk);
}

template GetYValue(COLORREF cmyk) {
	const BYTE GetYValue = cast(BYTE)(cmyk >> 8);
}

template GetYValue(COLORREF cmyk) {
	const BYTE GetMValue = cast(BYTE)(cmyk >> 16);
}

template GetYValue(COLORREF cmyk) {
	const BYTE GetCValue = cast(BYTE)(cmyk >> 24);
}

template CMYK(BYTE c, BYTE m, BYTE y, BYTE k) {
	const COLORREF CMYK = cast(COLORREF)(cast(uint)k | (cast(uint)y) << 8 | (cast(uint)m) << 16 | (cast(uint)c) << 24);
}

typedef Clong_t FXPT16DOT16;
typedef Clong_t* LPFXPT16DOT16;
typedef Clong_t FXPT2DOT30;
typedef Clong_t* LPFXPT2DOT30;

/* ICM Color Definitions */
// The following two structures are used for defining RGB's in terms of CIEXYZ.

struct CIEXYZ {
	FXPT2DOT30 ciexyzX;
	FXPT2DOT30 ciexyzY;
	FXPT2DOT30 ciexyzZ;
}

typedef CIEXYZ* LPCIEXYZ;

struct CIEXYZTRIPLE {
	CIEXYZ  ciexyzRed;
	CIEXYZ  ciexyzGreen;
	CIEXYZ  ciexyzBlue;
}

typedef CIEXYZTRIPLE* LPCIEXYZTRIPLE;

// The next structures the logical color space. Unlike pens and brushes,
// but like palettes, there is only one way to create a LogColorSpace.
// A pointer to it must be passed, its elements can't be pushed as
// arguments.

struct LOGCOLORSPACEA {
	DWORD lcsSignature;
	DWORD lcsVersion;
    DWORD lcsSize;
    LCSCSTYPE lcsCSType;
    LCSGAMUTMATCH lcsIntent;
    CIEXYZTRIPLE lcsEndpoints;
    DWORD lcsGammaRed;
    DWORD lcsGammaGreen;
    DWORD lcsGammaBlue;
    CHAR   lcsFilename[MAX_PATH];
}

typedef LOGCOLORSPACEA* LPLOGCOLORSPACEA;

struct LOGCOLORSPACEW {
    DWORD lcsSignature;
    DWORD lcsVersion;
    DWORD lcsSize;
    LCSCSTYPE lcsCSType;
    LCSGAMUTMATCH lcsIntent;
    CIEXYZTRIPLE lcsEndpoints;
    DWORD lcsGammaRed;
    DWORD lcsGammaGreen;
    DWORD lcsGammaBlue;
    WCHAR  lcsFilename[MAX_PATH];
}

typedef LOGCOLORSPACEW* LPLOGCOLORSPACEW;

version(UNICODE) {
	typedef LOGCOLORSPACEW LOGCOLORSPACE;
	typedef LPLOGCOLORSPACEW LPLOGCOLORSPACE;
}
else {
	typedef LOGCOLORSPACEA LOGCOLORSPACE;
	typedef LPLOGCOLORSPACEA LPLOGCOLORSPACE;
}

/* structures for defining DIBs */
struct BITMAPCOREHEADER {
	DWORD   bcSize;                 /* used to get to color table */
	WORD    bcWidth;
	WORD    bcHeight;
	WORD    bcPlanes;
	WORD    bcBitCount;
} 

typedef BITMAPCOREHEADER* LPBITMAPCOREHEADER;
typedef BITMAPCOREHEADER* PBITMAPCOREHEADER;

struct BITMAPINFOHEADER{
	DWORD      biSize;
	LONG       biWidth;
	LONG       biHeight;
	WORD       biPlanes;
	WORD       biBitCount;
	DWORD      biCompression;
	DWORD      biSizeImage;
	LONG       biXPelsPerMeter;
	LONG       biYPelsPerMeter;
	DWORD      biClrUsed;
	DWORD      biClrImportant;
} 

typedef BITMAPINFOHEADER* LPBITMAPINFOHEADER;
typedef BITMAPINFOHEADER* PBITMAPINFOHEADER;

struct BITMAPV4HEADER {
	DWORD        bV4Size;
	LONG         bV4Width;
	LONG         bV4Height;
	WORD         bV4Planes;
	WORD         bV4BitCount;
	DWORD        bV4V4Compression;
	DWORD        bV4SizeImage;
	LONG         bV4XPelsPerMeter;
	LONG         bV4YPelsPerMeter;
	DWORD        bV4ClrUsed;
	DWORD        bV4ClrImportant;
	DWORD        bV4RedMask;
	DWORD        bV4GreenMask;
	DWORD        bV4BlueMask;
	DWORD        bV4AlphaMask;
	DWORD        bV4CSType;
	CIEXYZTRIPLE bV4Endpoints;
	DWORD        bV4GammaRed;
	DWORD        bV4GammaGreen;
	DWORD        bV4GammaBlue;
}

typedef BITMAPV4HEADER* LPBITMAPV4HEADER;
typedef BITMAPV4HEADER* PBITMAPV4HEADER;

struct BITMAPV5HEADER {
	DWORD        bV5Size;
	LONG         bV5Width;
	LONG         bV5Height;
	WORD         bV5Planes;
	WORD         bV5BitCount;
	DWORD        bV5Compression;
	DWORD        bV5SizeImage;
	LONG         bV5XPelsPerMeter;
	LONG         bV5YPelsPerMeter;
	DWORD        bV5ClrUsed;
	DWORD        bV5ClrImportant;
	DWORD        bV5RedMask;
	DWORD        bV5GreenMask;
	DWORD        bV5BlueMask;
	DWORD        bV5AlphaMask;
	DWORD        bV5CSType;
	CIEXYZTRIPLE bV5Endpoints;
	DWORD        bV5GammaRed;
	DWORD        bV5GammaGreen;
	DWORD        bV5GammaBlue;
	DWORD        bV5Intent;
	DWORD        bV5ProfileData;
	DWORD        bV5ProfileSize;
	DWORD        bV5Reserved;
}

typedef BITMAPV5HEADER* LPBITMAPV5HEADER;
typedef BITMAPV5HEADER* PBITMAPV5HEADER;

// Values for bV5CSType
const auto PROFILE_LINKED          = "LINK"c;
const auto PROFILE_EMBEDDED        = "MBED"c;

/* constants for the biCompression field */
const auto BI_RGB        = 0;
const auto BI_RLE8       = 1;
const auto BI_RLE4       = 2;
const auto BI_BITFIELDS  = 3;
const auto BI_JPEG       = 4;
const auto BI_PNG        = 5;

struct BITMAPINFO {
	BITMAPINFOHEADER    bmiHeader;
	RGBQUAD             bmiColors[1];
}

typedef BITMAPINFO* LPBITMAPINFO;
typedef BITMAPINFO* PBITMAPINFO;

struct BITMAPCOREINFO {
	BITMAPCOREHEADER    bmciHeader;
	RGBTRIPLE           bmciColors[1];
}

typedef BITMAPCOREINFO* LPBITMAPCOREINFO;
typedef BITMAPCOREINFO* PBITMAPCOREINFO;

align(2) struct BITMAPFILEHEADER {
	WORD    bfType;
	DWORD   bfSize;
	WORD    bfReserved1;
	WORD    bfReserved2;
	DWORD   bfOffBits;
}
typedef BITMAPFILEHEADER* LPBITMAPFILEHEADER;
typedef BITMAPFILEHEADER* PBITMAPFILEHEADER;

POINTS* MAKEPOINTS(ref DWORD val) {
	return cast(POINTS*)(&val);
}

struct FONTSIGNATURE {
	DWORD fsUsb[4];
	DWORD fsCsb[2];
}

typedef FONTSIGNATURE* LPFONTSIGNATURE;
typedef FONTSIGNATURE* PFONTSIGNATURE;

struct CHARSETINFO {
	UINT ciCharset;
	UINT ciACP;
	FONTSIGNATURE fs;
}

typedef CHARSETINFO* NPCHARSETINFO;
typedef CHARSETINFO* LPCHARSETINFO;
typedef CHARSETINFO* PCHARSETINFO;

const auto TCI_SRCCHARSET  = 1;
const auto TCI_SRCCODEPAGE = 2;
const auto TCI_SRCFONTSIG  = 3;

const auto TCI_SRCLOCALE   = 0x1000;

struct LOCALESIGNATURE {
	DWORD lsUsb[4];
	DWORD lsCsbDefault[2];
	DWORD lsCsbSupported[2];
}

typedef LOCALESIGNATURE* LPLOCALESIGNATURE;
typedef LOCALESIGNATURE* PLOCALESIGNATURE;

/* Clipboard Metafile Picture Structure */
struct HANDLETABLE {
	HGDIOBJ     objectHandle[1];
}

typedef HANDLETABLE* PHANDLETABLE;
typedef HANDLETABLE* LPHANDLETABLE;

struct METARECORD {
	DWORD       rdSize;
	WORD        rdFunction;
	WORD        rdParm[1];
}
typedef METARECORD* PMETARECORD;
typedef METARECORD* LPMETARECORD;

struct METAFILEPICT {
	LONG        mm;
	LONG        xExt;
	LONG        yExt;
	HMETAFILE   hMF;
}

typedef METAFILEPICT* LPMETAFILEPICT;

align(2) struct METAHEADER {
	WORD        mtType;
	WORD        mtHeaderSize;
	WORD        mtVersion;
	DWORD       mtSize;
	WORD        mtNoObjects;
	DWORD       mtMaxRecord;
	WORD        mtNoParameters;
}

typedef METAHEADER* PMETAHEADER;
typedef METAHEADER* LPMETAHEADER;

/* Enhanced Metafile structures */
struct ENHMETARECORD {
	DWORD   iType;              // Record type EMR_XXX
	DWORD   nSize;              // Record size in bytes
	DWORD   dParm[1];           // Parameters
}

typedef ENHMETARECORD* PENHMETARECORD;
typedef ENHMETARECORD* LPENHMETARECORD;

struct ENHMETAHEADER {
	DWORD   iType;              // Record typeEMR_HEADER
	DWORD   nSize;              // Record size in bytes.  This may be greater
	                            // than the sizeof(ENHMETAHEADER).
	RECTL   rclBounds;          // Inclusive-inclusive bounds in device units
	RECTL   rclFrame;           // Inclusive-inclusive Picture Frame of metafile in .01 mm units
	DWORD   dSignature;         // Signature.  Must be ENHMETA_SIGNATURE.
	DWORD   nVersion;           // Version number
	DWORD   nBytes;             // Size of the metafile in bytes
	DWORD   nRecords;           // Number of records in the metafile
	WORD    nHandles;           // Number of handles in the handle table
	                            // Handle index zero is reserved.
	WORD    sReserved;          // Reserved.  Must be zero.
	DWORD   nDescription;       // Number of chars in the unicode description string
	                            // This is 0 if there is no description string
	DWORD   offDescription;     // Offset to the metafile description record.
	                            // This is 0 if there is no description string
	DWORD   nPalEntries;        // Number of entries in the metafile palette.
	SIZEL   szlDevice;          // Size of the reference device in pels
	SIZEL   szlMillimeters;     // Size of the reference device in millimeters
	DWORD   cbPixelFormat;      // Size of PIXELFORMATDESCRIPTOR information
	                            // This is 0 if no pixel format is set
	DWORD   offPixelFormat;     // Offset to PIXELFORMATDESCRIPTOR
	                            // This is 0 if no pixel format is set
	DWORD   bOpenGL;            // TRUE if OpenGL commands are present in
	                            // the metafile, otherwise FALSE
	SIZEL   szlMicrometers;     // Size of the reference device in micrometers
}

typedef ENHMETAHEADER* PENHMETAHEADER;
typedef ENHMETAHEADER* LPENHMETAHEADER;

/* tmPitchAndFamily flags */
const auto TMPF_FIXED_PITCH	= 0x01;
const auto TMPF_VECTOR		= 0x02;
const auto TMPF_DEVICE		= 0x08;
const auto TMPF_TRUETYPE	= 0x04;

//
// BCHAR definition for APPs
//
version(UNICODE) {
	typedef WCHAR BCHAR;
}
else {
	typedef BYTE BCHAR;
}

align(4) struct TEXTMETRICA {
    LONG        tmHeight;
    LONG        tmAscent;
    LONG        tmDescent;
    LONG        tmInternalLeading;
    LONG        tmExternalLeading;
    LONG        tmAveCharWidth;
    LONG        tmMaxCharWidth;
    LONG        tmWeight;
    LONG        tmOverhang;
    LONG        tmDigitizedAspectX;
    LONG        tmDigitizedAspectY;
    BYTE        tmFirstChar;
    BYTE        tmLastChar;
    BYTE        tmDefaultChar;
    BYTE        tmBreakChar;
    BYTE        tmItalic;
    BYTE        tmUnderlined;
    BYTE        tmStruckOut;
    BYTE        tmPitchAndFamily;
    BYTE        tmCharSet;
}

typedef TEXTMETRICA* PTEXTMETRICA;
typedef TEXTMETRICA* NPTEXTMETRICA;
typedef TEXTMETRICA* LPTEXTMETRICA;

align(4) struct TEXTMETRICW {
    LONG        tmHeight;
    LONG        tmAscent;
    LONG        tmDescent;
    LONG        tmInternalLeading;
    LONG        tmExternalLeading;
    LONG        tmAveCharWidth;
    LONG        tmMaxCharWidth;
    LONG        tmWeight;
    LONG        tmOverhang;
    LONG        tmDigitizedAspectX;
    LONG        tmDigitizedAspectY;
    WCHAR       tmFirstChar;
    WCHAR       tmLastChar;
    WCHAR       tmDefaultChar;
    WCHAR       tmBreakChar;
    BYTE        tmItalic;
    BYTE        tmUnderlined;
    BYTE        tmStruckOut;
    BYTE        tmPitchAndFamily;
    BYTE        tmCharSet;
}

typedef TEXTMETRICW* PTEXTMETRICW;
typedef TEXTMETRICW* NPTEXTMETRICW;
typedef TEXTMETRICW* LPTEXTMETRICW;

version(UNICODE) {
	typedef TEXTMETRICW TEXTMETRIC;
	typedef PTEXTMETRICW PTEXTMETRIC;
	typedef NPTEXTMETRICW NPTEXTMETRIC;
	typedef LPTEXTMETRICW LPTEXTMETRIC;
}
else {
	typedef TEXTMETRICA TEXTMETRIC;
	typedef PTEXTMETRICA PTEXTMETRIC;
	typedef NPTEXTMETRICA NPTEXTMETRIC;
	typedef LPTEXTMETRICA LPTEXTMETRIC;
}

/* ntmFlags field flags */
const auto NTM_REGULAR     = 0x00000040;
const auto NTM_BOLD        = 0x00000020;
const auto NTM_ITALIC      = 0x00000001;

/* new in NT 5.0 */

const auto NTM_NONNEGATIVE_AC  = 0x00010000;
const auto NTM_PS_OPENTYPE     = 0x00020000;
const auto NTM_TT_OPENTYPE     = 0x00040000;
const auto NTM_MULTIPLEMASTER  = 0x00080000;
const auto NTM_TYPE1           = 0x00100000;
const auto NTM_DSIG            = 0x00200000;

align(4) struct NEWTEXTMETRICA {
	LONG        tmHeight;
	LONG        tmAscent;
	LONG        tmDescent;
	LONG        tmInternalLeading;
	LONG        tmExternalLeading;
	LONG        tmAveCharWidth;
	LONG        tmMaxCharWidth;
	LONG        tmWeight;
	LONG        tmOverhang;
	LONG        tmDigitizedAspectX;
	LONG        tmDigitizedAspectY;
	BYTE        tmFirstChar;
	BYTE        tmLastChar;
	BYTE        tmDefaultChar;
	BYTE        tmBreakChar;
	BYTE        tmItalic;
	BYTE        tmUnderlined;
	BYTE        tmStruckOut;
	BYTE        tmPitchAndFamily;
	BYTE        tmCharSet;
	DWORD   ntmFlags;
	UINT    ntmSizeEM;
	UINT    ntmCellHeight;
	UINT    ntmAvgWidth;
}

typedef NEWTEXTMETRICA* PNEWTEXTMETRICA;
typedef NEWTEXTMETRICA* NPNEWTEXTMETRICA;
typedef NEWTEXTMETRICA* LPNEWTEXTMETRICA;

struct NEWTEXTMETRICW {
	LONG        tmHeight;
	LONG        tmAscent;
	LONG        tmDescent;
	LONG        tmInternalLeading;
	LONG        tmExternalLeading;
	LONG        tmAveCharWidth;
	LONG        tmMaxCharWidth;
	LONG        tmWeight;
	LONG        tmOverhang;
	LONG        tmDigitizedAspectX;
	LONG        tmDigitizedAspectY;
	WCHAR       tmFirstChar;
	WCHAR       tmLastChar;
	WCHAR       tmDefaultChar;
	WCHAR       tmBreakChar;
	BYTE        tmItalic;
	BYTE        tmUnderlined;
	BYTE        tmStruckOut;
	BYTE        tmPitchAndFamily;
	BYTE        tmCharSet;
	DWORD   ntmFlags;
	UINT    ntmSizeEM;
	UINT    ntmCellHeight;
	UINT    ntmAvgWidth;
}

typedef NEWTEXTMETRICW* PNEWTEXTMETRICW;
typedef NEWTEXTMETRICW* NPNEWTEXTMETRICW;
typedef NEWTEXTMETRICW* LPNEWTEXTMETRICW;

version(UNICODE) {
	typedef NEWTEXTMETRICW NEWTEXTMETRIC;
	typedef PNEWTEXTMETRICW PNEWTEXTMETRIC;
	typedef NPNEWTEXTMETRICW NPNEWTEXTMETRIC;
	typedef LPNEWTEXTMETRICW LPNEWTEXTMETRIC;
}
else {
	typedef NEWTEXTMETRICA NEWTEXTMETRIC;
	typedef PNEWTEXTMETRICA PNEWTEXTMETRIC;
	typedef NPNEWTEXTMETRICA NPNEWTEXTMETRIC;
	typedef LPNEWTEXTMETRICA LPNEWTEXTMETRIC;
}

struct NEWTEXTMETRICEXA {
    NEWTEXTMETRICA  ntmTm;
    FONTSIGNATURE   ntmFontSig;
}

struct NEWTEXTMETRICEXW {
    NEWTEXTMETRICW  ntmTm;
    FONTSIGNATURE   ntmFontSig;
}

version(UNICODE) {
	typedef NEWTEXTMETRICEXW NEWTEXTMETRICEX;
}
else {
	typedef NEWTEXTMETRICEXA NEWTEXTMETRICEX;
}

/* GDI Logical Objects: */

/* Pel Array */
struct PELARRAY {
    LONG        paXCount;
    LONG        paYCount;
    LONG        paXExt;
    LONG        paYExt;
    BYTE        paRGBs;
}

typedef PELARRAY* PPELARRAY;
typedef PELARRAY* NPPELARRAY;
typedef PELARRAY* LPPELARRAY;

/* Logical Brush (or Pattern) */
struct LOGBRUSH {
    UINT        lbStyle;
    COLORREF    lbColor;
    ULONG_PTR    lbHatch;    // Sundown: lbHatch could hold a HANDLE
} 

typedef LOGBRUSH* PLOGBRUSH;
typedef LOGBRUSH* NPLOGBRUSH;
typedef LOGBRUSH* LPLOGBRUSH;

struct LOGBRUSH32 {
	UINT        lbStyle;
	COLORREF    lbColor;
	ULONG       lbHatch;
}

typedef LOGBRUSH32* PLOGBRUSH32;
typedef LOGBRUSH32* NPLOGBRUSH32;
typedef LOGBRUSH32* LPLOGBRUSH32;

typedef LOGBRUSH            PATTERN;
typedef PATTERN             *PPATTERN;
typedef PATTERN *NPPATTERN;
typedef PATTERN *LPPATTERN;

/* Logical Pen */
struct LOGPEN {
	UINT        lopnStyle;
	POINT       lopnWidth;
	COLORREF    lopnColor;
}

typedef LOGPEN* PLOGPEN;
typedef LOGPEN* NPLOGPEN;
typedef LOGPEN* LPLOGPEN;

struct EXTLOGPEN {
	DWORD       elpPenStyle;
	DWORD       elpWidth;
	UINT        elpBrushStyle;
	COLORREF    elpColor;
	ULONG_PTR   elpHatch;     //Sundown: elpHatch could take a HANDLE
	DWORD       elpNumEntries;
	DWORD[1]    elpStyleEntry;
}

typedef EXTLOGPEN* PEXTLOGPEN;
typedef EXTLOGPEN* NPEXTLOGPEN;
typedef EXTLOGPEN* LPEXTLOGPEN;

struct PALETTEENTRY {
	BYTE        peRed;
	BYTE        peGreen;
	BYTE        peBlue;
	BYTE        peFlags;
}

typedef PALETTEENTRY* PPALETTEENTRY;
typedef PALETTEENTRY* LPPALETTEENTRY;

/* Logical Palette */
struct LOGPALETTE {
    WORD        palVersion;
    WORD        palNumEntries;
	PALETTEENTRY[1]        palPalEntry;
}

typedef LOGPALETTE* PLOGPALETTE;
typedef LOGPALETTE* NPLOGPALETTE;
typedef LOGPALETTE* LPLOGPALETTE;

/* Logical Font */
const auto LF_FACESIZE         = 32;

struct LOGFONTA {
	LONG      lfHeight;
	LONG      lfWidth;
	LONG      lfEscapement;
	LONG      lfOrientation;
	LONG      lfWeight;
	BYTE      lfItalic;
	BYTE      lfUnderline;
	BYTE      lfStrikeOut;
	BYTE      lfCharSet;
	BYTE      lfOutPrecision;
	BYTE      lfClipPrecision;
	BYTE      lfQuality;
	BYTE      lfPitchAndFamily;
	CHAR      lfFaceName[LF_FACESIZE];
}

typedef LOGFONTA* PLOGFONTA;
typedef LOGFONTA* NPLOGFONTA;
typedef LOGFONTA* LPLOGFONTA;

struct LOGFONTW {
	LONG      lfHeight;
	LONG      lfWidth;
	LONG      lfEscapement;
	LONG      lfOrientation;
	LONG      lfWeight;
	BYTE      lfItalic;
	BYTE      lfUnderline;
	BYTE      lfStrikeOut;
	BYTE      lfCharSet;
	BYTE      lfOutPrecision;
	BYTE      lfClipPrecision;
	BYTE      lfQuality;
	BYTE      lfPitchAndFamily;
	WCHAR     lfFaceName[LF_FACESIZE];
}

typedef LOGFONTW* PLOGFONTW;
typedef LOGFONTW* NPLOGFONTW;
typedef LOGFONTW* LPLOGFONTW;

version(UNICODE) {
	typedef LOGFONTW LOGFONT;
	typedef PLOGFONTW PLOGFONT;
	typedef NPLOGFONTW NPLOGFONT;
	typedef LPLOGFONTW LPLOGFONT;
}
else {
	typedef LOGFONTA LOGFONT;
	typedef PLOGFONTA PLOGFONT;
	typedef NPLOGFONTA NPLOGFONT;
	typedef LPLOGFONTA LPLOGFONT;
}

const auto LF_FULLFACESIZE     = 64;

/* Structure passed to FONTENUMPROC */
struct ENUMLOGFONTA {
    LOGFONTA elfLogFont;
    BYTE     elfFullName[LF_FULLFACESIZE];
    BYTE     elfStyle[LF_FACESIZE];
}

typedef ENUMLOGFONTA* LPENUMLOGFONTA;

/* Structure passed to FONTENUMPROC */
struct ENUMLOGFONTW {
    LOGFONTW elfLogFont;
    WCHAR[LF_FULLFACESIZE]    elfFullName;
    WCHAR[LF_FACESIZE]    elfStyle;
}

typedef ENUMLOGFONTW* LPENUMLOGFONTW;

version(UNICODE) {
	typedef ENUMLOGFONTW ENUMLOGFONT;
	typedef LPENUMLOGFONTW LPENUMLOGFONT;
}
else {
	typedef ENUMLOGFONTA ENUMLOGFONT;
	typedef LPENUMLOGFONTA LPENUMLOGFONT;
}

struct ENUMLOGFONTEXA {
    LOGFONTA    elfLogFont;
    BYTE        elfFullName[LF_FULLFACESIZE];
    BYTE        elfStyle[LF_FACESIZE];
    BYTE        elfScript[LF_FACESIZE];
}

typedef ENUMLOGFONTEXA* LPENUMLOGFONTEXA;

struct ENUMLOGFONTEXW {
    LOGFONTW    elfLogFont;
    WCHAR[LF_FULLFACESIZE]       elfFullName;
    WCHAR[LF_FACESIZE]       elfStyle;
    WCHAR[LF_FACESIZE]       elfScript;
}

typedef ENUMLOGFONTEXW* LPENUMLOGFONTEXW;

version(UNICODE) {
	typedef ENUMLOGFONTEXW ENUMLOGFONTEX;
	typedef LPENUMLOGFONTEXW LPENUMLOGFONTEX;
}
else {
	typedef ENUMLOGFONTEXA ENUMLOGFONTEX;
	typedef LPENUMLOGFONTEXA LPENUMLOGFONTEX;
}

const auto OUT_DEFAULT_PRECIS          = 0;
const auto OUT_STRING_PRECIS           = 1;
const auto OUT_CHARACTER_PRECIS        = 2;
const auto OUT_STROKE_PRECIS           = 3;
const auto OUT_TT_PRECIS               = 4;
const auto OUT_DEVICE_PRECIS           = 5;
const auto OUT_RASTER_PRECIS           = 6;
const auto OUT_TT_ONLY_PRECIS          = 7;
const auto OUT_OUTLINE_PRECIS          = 8;
const auto OUT_SCREEN_OUTLINE_PRECIS   = 9;
const auto OUT_PS_ONLY_PRECIS          = 10;

const auto CLIP_DEFAULT_PRECIS     = 0;
const auto CLIP_CHARACTER_PRECIS   = 1;
const auto CLIP_STROKE_PRECIS      = 2;
const auto CLIP_MASK               = 0xf;
const auto CLIP_LH_ANGLES          = (1<<4);
const auto CLIP_TT_ALWAYS          = (2<<4);

const auto CLIP_DFA_DISABLE        = (4<<4);

const auto CLIP_EMBEDDED           = (8<<4);

const auto DEFAULT_QUALITY         = 0;
const auto DRAFT_QUALITY           = 1;
const auto PROOF_QUALITY           = 2;

const auto NONANTIALIASED_QUALITY  = 3;
const auto ANTIALIASED_QUALITY     = 4;

const auto CLEARTYPE_QUALITY         = 5;
const auto CLEARTYPE_NATURAL_QUALITY       = 6;

const auto DEFAULT_PITCH           = 0;
const auto FIXED_PITCH             = 1;
const auto VARIABLE_PITCH          = 2;

const auto MONO_FONT               = 8;

const auto ANSI_CHARSET            = 0;
const auto DEFAULT_CHARSET         = 1;
const auto SYMBOL_CHARSET          = 2;
const auto SHIFTJIS_CHARSET        = 128;
const auto HANGEUL_CHARSET         = 129;
const auto HANGUL_CHARSET          = 129;
const auto GB2312_CHARSET          = 134;
const auto CHINESEBIG5_CHARSET     = 136;
const auto OEM_CHARSET             = 255;

const auto JOHAB_CHARSET           = 130;
const auto HEBREW_CHARSET          = 177;
const auto ARABIC_CHARSET          = 178;
const auto GREEK_CHARSET           = 161;
const auto TURKISH_CHARSET         = 162;
const auto VIETNAMESE_CHARSET      = 163;
const auto THAI_CHARSET            = 222;
const auto EASTEUROPE_CHARSET      = 238;
const auto RUSSIAN_CHARSET         = 204;

const auto MAC_CHARSET             = 77;
const auto BALTIC_CHARSET          = 186;

const auto FS_LATIN1               = 0x00000001;
const auto FS_LATIN2               = 0x00000002;
const auto FS_CYRILLIC             = 0x00000004;
const auto FS_GREEK                = 0x00000008;
const auto FS_TURKISH              = 0x00000010;
const auto FS_HEBREW               = 0x00000020;
const auto FS_ARABIC               = 0x00000040;
const auto FS_BALTIC               = 0x00000080;
const auto FS_VIETNAMESE           = 0x00000100;
const auto FS_THAI                 = 0x00010000;
const auto FS_JISJAPAN             = 0x00020000;
const auto FS_CHINESESIMP          = 0x00040000;
const auto FS_WANSUNG              = 0x00080000;
const auto FS_CHINESETRAD          = 0x00100000;
const auto FS_JOHAB                = 0x00200000;
const auto FS_SYMBOL               = 0x80000000;

/* Font Families */
const auto FF_DONTCARE         = (0<<4);  /* Don't care or don't know. */
const auto FF_ROMAN            = (1<<4);  /* Variable stroke width, serifed. */
                                    /* Times Roman, Century Schoolbook, etc. */
const auto FF_SWISS            = (2<<4);  /* Variable stroke width, sans-serifed. */
                                    /* Helvetica, Swiss, etc. */
const auto FF_MODERN           = (3<<4);  /* Constant stroke width, serifed or sans-serifed. */
                                    /* Pica, Elite, Courier, etc. */
const auto FF_SCRIPT           = (4<<4);  /* Cursive, etc. */
const auto FF_DECORATIVE       = (5<<4);  /* Old English, etc. */

/* Font Weights */
const auto FW_DONTCARE         = 0;
const auto FW_THIN             = 100;
const auto FW_EXTRALIGHT       = 200;
const auto FW_LIGHT            = 300;
const auto FW_NORMAL           = 400;
const auto FW_MEDIUM           = 500;
const auto FW_SEMIBOLD         = 600;
const auto FW_BOLD             = 700;
const auto FW_EXTRABOLD        = 800;
const auto FW_HEAVY            = 900;

const auto FW_ULTRALIGHT       = FW_EXTRALIGHT;
const auto FW_REGULAR          = FW_NORMAL;
const auto FW_DEMIBOLD         = FW_SEMIBOLD;
const auto FW_ULTRABOLD        = FW_EXTRABOLD;
const auto FW_BLACK            = FW_HEAVY;

const auto PANOSE_COUNT               = 10;
const auto PAN_FAMILYTYPE_INDEX        = 0;
const auto PAN_SERIFSTYLE_INDEX        = 1;
const auto PAN_WEIGHT_INDEX            = 2;
const auto PAN_PROPORTION_INDEX        = 3;
const auto PAN_CONTRAST_INDEX          = 4;
const auto PAN_STROKEVARIATION_INDEX   = 5;
const auto PAN_ARMSTYLE_INDEX          = 6;
const auto PAN_LETTERFORM_INDEX        = 7;
const auto PAN_MIDLINE_INDEX           = 8;
const auto PAN_XHEIGHT_INDEX           = 9;

const auto PAN_CULTURE_LATIN           = 0;

struct PANOSE {
	BYTE    bFamilyType;
	BYTE    bSerifStyle;
	BYTE    bWeight;
	BYTE    bProportion;
	BYTE    bContrast;
	BYTE    bStrokeVariation;
	BYTE    bArmStyle;
	BYTE    bLetterform;
	BYTE    bMidline;
	BYTE    bXHeight;
}

typedef PANOSE* LPPANOSE;

const auto PAN_ANY                         = 0; /* Any                            */
const auto PAN_NO_FIT                      = 1; /* No Fit                         */

const auto PAN_FAMILY_TEXT_DISPLAY         = 2; /* Text and Display               */
const auto PAN_FAMILY_SCRIPT               = 3; /* Script                         */
const auto PAN_FAMILY_DECORATIVE           = 4; /* Decorative                     */
const auto PAN_FAMILY_PICTORIAL            = 5; /* Pictorial                      */

const auto PAN_SERIF_COVE                  = 2; /* Cove                           */
const auto PAN_SERIF_OBTUSE_COVE           = 3; /* Obtuse Cove                    */
const auto PAN_SERIF_SQUARE_COVE           = 4; /* Square Cove                    */
const auto PAN_SERIF_OBTUSE_SQUARE_COVE    = 5; /* Obtuse Square Cove             */
const auto PAN_SERIF_SQUARE                = 6; /* Square                         */
const auto PAN_SERIF_THIN                  = 7; /* Thin                           */
const auto PAN_SERIF_BONE                  = 8; /* Bone                           */
const auto PAN_SERIF_EXAGGERATED           = 9; /* Exaggerated                    */
const auto PAN_SERIF_TRIANGLE             = 10; /* Triangle                       */
const auto PAN_SERIF_NORMAL_SANS          = 11; /* Normal Sans                    */
const auto PAN_SERIF_OBTUSE_SANS          = 12; /* Obtuse Sans                    */
const auto PAN_SERIF_PERP_SANS            = 13; /* Prep Sans                      */
const auto PAN_SERIF_FLARED               = 14; /* Flared                         */
const auto PAN_SERIF_ROUNDED              = 15; /* Rounded                        */

const auto PAN_WEIGHT_VERY_LIGHT           = 2; /* Very Light                     */
const auto PAN_WEIGHT_LIGHT                = 3; /* Light                          */
const auto PAN_WEIGHT_THIN                 = 4; /* Thin                           */
const auto PAN_WEIGHT_BOOK                 = 5; /* Book                           */
const auto PAN_WEIGHT_MEDIUM               = 6; /* Medium                         */
const auto PAN_WEIGHT_DEMI                 = 7; /* Demi                           */
const auto PAN_WEIGHT_BOLD                 = 8; /* Bold                           */
const auto PAN_WEIGHT_HEAVY                = 9; /* Heavy                          */
const auto PAN_WEIGHT_BLACK               = 10; /* Black                          */
const auto PAN_WEIGHT_NORD                = 11; /* Nord                           */

const auto PAN_PROP_OLD_STYLE              = 2; /* Old Style                      */
const auto PAN_PROP_MODERN                 = 3; /* Modern                         */
const auto PAN_PROP_EVEN_WIDTH             = 4; /* Even Width                     */
const auto PAN_PROP_EXPANDED               = 5; /* Expanded                       */
const auto PAN_PROP_CONDENSED              = 6; /* Condensed                      */
const auto PAN_PROP_VERY_EXPANDED          = 7; /* Very Expanded                  */
const auto PAN_PROP_VERY_CONDENSED         = 8; /* Very Condensed                 */
const auto PAN_PROP_MONOSPACED             = 9; /* Monospaced                     */

const auto PAN_CONTRAST_NONE               = 2; /* None                           */
const auto PAN_CONTRAST_VERY_LOW           = 3; /* Very Low                       */
const auto PAN_CONTRAST_LOW                = 4; /* Low                            */
const auto PAN_CONTRAST_MEDIUM_LOW         = 5; /* Medium Low                     */
const auto PAN_CONTRAST_MEDIUM             = 6; /* Medium                         */
const auto PAN_CONTRAST_MEDIUM_HIGH        = 7; /* Mediim High                    */
const auto PAN_CONTRAST_HIGH               = 8; /* High                           */
const auto PAN_CONTRAST_VERY_HIGH          = 9; /* Very High                      */

const auto PAN_STROKE_GRADUAL_DIAG         = 2; /* Gradual/Diagonal               */
const auto PAN_STROKE_GRADUAL_TRAN         = 3; /* Gradual/Transitional           */
const auto PAN_STROKE_GRADUAL_VERT         = 4; /* Gradual/Vertical               */
const auto PAN_STROKE_GRADUAL_HORZ         = 5; /* Gradual/Horizontal             */
const auto PAN_STROKE_RAPID_VERT           = 6; /* Rapid/Vertical                 */
const auto PAN_STROKE_RAPID_HORZ           = 7; /* Rapid/Horizontal               */
const auto PAN_STROKE_INSTANT_VERT         = 8; /* Instant/Vertical               */

const auto PAN_STRAIGHT_ARMS_HORZ          = 2; /* Straight Arms/Horizontal       */
const auto PAN_STRAIGHT_ARMS_WEDGE         = 3; /* Straight Arms/Wedge            */
const auto PAN_STRAIGHT_ARMS_VERT          = 4; /* Straight Arms/Vertical         */
const auto PAN_STRAIGHT_ARMS_SINGLE_SERIF  = 5; /* Straight Arms/Single-Serif     */
const auto PAN_STRAIGHT_ARMS_DOUBLE_SERIF  = 6; /* Straight Arms/Double-Serif     */
const auto PAN_BENT_ARMS_HORZ              = 7; /* Non-Straight Arms/Horizontal   */
const auto PAN_BENT_ARMS_WEDGE             = 8; /* Non-Straight Arms/Wedge        */
const auto PAN_BENT_ARMS_VERT              = 9; /* Non-Straight Arms/Vertical     */
const auto PAN_BENT_ARMS_SINGLE_SERIF     = 10; /* Non-Straight Arms/Single-Serif */
const auto PAN_BENT_ARMS_DOUBLE_SERIF     = 11; /* Non-Straight Arms/Double-Serif */

const auto PA…