Mercurial > projects > ddbg_continued
diff win32/wingdi.d @ 1:4a9dcbd9e54f
-files of 0.13 beta
-fixes so that it now compiles with the current dmd version
author | marton@basel.hu |
---|---|
date | Tue, 05 Apr 2011 20:44:01 +0200 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/win32/wingdi.d Tue Apr 05 20:44:01 2011 +0200 @@ -0,0 +1,4590 @@ +/***********************************************************************\ +* wingdi.d * +* * +* Windows API header module * +* * +* Translated from MinGW Windows headers * +* * +* Placed into public domain * +\***********************************************************************/ +module win32.wingdi; +pragma(lib, "gdi32.lib"); + +// FIXME: clean up Windows version support + +private import win32.w32api, win32.windef, win32.winver; + +// BITMAPINFOHEADER.biCompression +enum : DWORD { + BI_RGB = 0, + BI_RLE8, + BI_RLE4, + BI_BITFIELDS, + BI_JPEG, + BI_PNG +} + +// --- +// COLORADJUSTMENT -- only for NT 3.1+, Win2000+ +const WORD + CA_NEGATIVE = 1, + CA_LOG_FILTER = 2; + +// COLORADJUSTMENT +enum : WORD { + ILLUMINANT_DEVICE_DEFAULT = 0, + ILLUMINANT_A, + ILLUMINANT_B, + ILLUMINANT_C, + ILLUMINANT_D50, + ILLUMINANT_D55, + ILLUMINANT_D65, + ILLUMINANT_D75, + ILLUMINANT_F2, + ILLUMINANT_MAX_INDEX = ILLUMINANT_F2, + ILLUMINANT_TUNGSTEN = ILLUMINANT_A, + ILLUMINANT_DAYLIGHT = ILLUMINANT_C, + ILLUMINANT_FLUORESCENT = ILLUMINANT_F2, + ILLUMINANT_NTSC = ILLUMINANT_C +} + +enum { + RGB_GAMMA_MIN = 2500, + RGB_GAMMA_MAX = 65000, + REFERENCE_WHITE_MIN = 6000, + REFERENCE_WHITE_MAX = 10000, + REFERENCE_BLACK_MIN = 0, + REFERENCE_BLACK_MAX = 4000, + COLOR_ADJ_MIN = -100, + COLOR_ADJ_MAX = 100, +} +//--- + +/* FIXME: move to win32.winuser ? */ +// DrawIconEx() +enum : UINT { + DI_MASK = 1, + DI_IMAGE = 2, + DI_NORMAL = 3, + DI_COMPAT = 4, + DI_DEFAULTSIZE = 8 +} + +// DOCINFO +enum : DWORD { + DI_APPBANDING = 1, + DI_ROPS_READ_DESTINATION = 2, +} + +// ENHMETAHEADER +enum : DWORD { + EMR_HEADER = 1, + EMR_POLYBEZIER, + EMR_POLYGON, + EMR_POLYLINE, + EMR_POLYBEZIERTO, + EMR_POLYLINETO, + EMR_POLYPOLYLINE, + EMR_POLYPOLYGON, + EMR_SETWINDOWEXTEX, + EMR_SETWINDOWORGEX, + EMR_SETVIEWPORTEXTEX, + EMR_SETVIEWPORTORGEX, + EMR_SETBRUSHORGEX, + EMR_EOF, + EMR_SETPIXELV, + EMR_SETMAPPERFLAGS, + EMR_SETMAPMODE, + EMR_SETBKMODE, + EMR_SETPOLYFILLMODE, + EMR_SETROP2, + EMR_SETSTRETCHBLTMODE, + EMR_SETTEXTALIGN, + EMR_SETCOLORADJUSTMENT, + EMR_SETTEXTCOLOR, + EMR_SETBKCOLOR, + EMR_OFFSETCLIPRGN, + EMR_MOVETOEX, + EMR_SETMETARGN, + EMR_EXCLUDECLIPRECT, + EMR_INTERSECTCLIPRECT, + EMR_SCALEVIEWPORTEXTEX, + EMR_SCALEWINDOWEXTEX, + EMR_SAVEDC, + EMR_RESTOREDC, + EMR_SETWORLDTRANSFORM, + EMR_MODIFYWORLDTRANSFORM, + EMR_SELECTOBJECT, + EMR_CREATEPEN, + EMR_CREATEBRUSHINDIRECT, + EMR_DELETEOBJECT, + EMR_ANGLEARC, + EMR_ELLIPSE, + EMR_RECTANGLE, + EMR_ROUNDRECT, + EMR_ARC, + EMR_CHORD, + EMR_PIE, + EMR_SELECTPALETTE, + EMR_CREATEPALETTE, + EMR_SETPALETTEENTRIES, + EMR_RESIZEPALETTE, + EMR_REALIZEPALETTE, + EMR_EXTFLOODFILL, + EMR_LINETO, + EMR_ARCTO, + EMR_POLYDRAW, + EMR_SETARCDIRECTION, + EMR_SETMITERLIMIT, + EMR_BEGINPATH, + EMR_ENDPATH, + EMR_CLOSEFIGURE, + EMR_FILLPATH, + EMR_STROKEANDFILLPATH, + EMR_STROKEPATH, + EMR_FLATTENPATH, + EMR_WIDENPATH, + EMR_SELECTCLIPPATH, + EMR_ABORTPATH, // 68 + // reserved 69 + EMR_GDICOMMENT = 70, + EMR_FILLRGN, + EMR_FRAMERGN, + EMR_INVERTRGN, + EMR_PAINTRGN, + EMR_EXTSELECTCLIPRGN, + EMR_BITBLT, + EMR_STRETCHBLT, + EMR_MASKBLT, + EMR_PLGBLT, + EMR_SETDIBITSTODEVICE, + EMR_STRETCHDIBITS, + EMR_EXTCREATEFONTINDIRECTW, + EMR_EXTTEXTOUTA, + EMR_EXTTEXTOUTW, + EMR_POLYBEZIER16, + EMR_POLYGON16, + EMR_POLYLINE16, + EMR_POLYBEZIERTO16, + EMR_POLYLINETO16, + EMR_POLYPOLYLINE16, + EMR_POLYPOLYGON16, + EMR_POLYDRAW16, + EMR_CREATEMONOBRUSH, + EMR_CREATEDIBPATTERNBRUSHPT, + EMR_EXTCREATEPEN, + EMR_POLYTEXTOUTA, + EMR_POLYTEXTOUTW, // 97 + EMR_SETICMMODE, + EMR_CREATECOLORSPACE, + EMR_SETCOLORSPACE, + EMR_DELETECOLORSPACE, + EMR_GLSRECORD, + EMR_GLSBOUNDEDRECORD, + EMR_PIXELFORMAT, // = 104 + // reserved 105 - 110 + EMR_COLORCORRECTPALETTE = 111, + EMR_SETICMPROFILEA, + EMR_SETICMPROFILEW, + EMR_ALPHABLEND, + EMR_SETLAYOUT, + EMR_TRANSPARENTBLT, // 116 + // reserved 117 + EMR_GRADIENTFILL = 118, + // reserved 119, 120 + EMR_COLORMATCHTOTARGETW = 121, + EMR_CREATECOLORSPACEW // 122 +} + +const EMR_MIN = EMR_HEADER; + +static if (WINVER >= 0x0500) + const EMR_MAX = EMR_CREATECOLORSPACEW; +else static if (WINVER >= 0x0400) + const EMR_MAX = EMR_PIXELFORMAT; +else + const EMR_MAX = EMR_POLYTEXTOUTW; + +// ENHMETAHEADER.dSignature, ENHMETAHEADER3.dSignature, +// EMRFORMAT.dSignature +enum : DWORD { + ENHMETA_SIGNATURE = 1179469088, + EPS_SIGNATURE = 0x46535045 +} + +static if (_WIN32_WINNT >= 0x0500) { + // AddFontResourceEx() + enum : DWORD { + FR_PRIVATE = 0x10, + FR_NOT_ENUM = 0x20 + } +} + +enum { + META_SAVEDC = 0x1E, + META_REALIZEPALETTE = 0x35, + META_SETPALENTRIES = 0x37, + META_CREATEPALETTE = 0xf7, + META_SETBKMODE = 0x102, + META_SETMAPMODE = 0x103, + META_SETROP2 = 0x104, + META_SETRELABS = 0x105, + META_SETPOLYFILLMODE = 0x106, + META_SETSTRETCHBLTMODE = 0x107, + META_SETTEXTCHAREXTRA = 0x108, + META_RESTOREDC = 0x127, + META_INVERTREGION = 0x12A, + META_PAINTREGION = 0x12B, + META_SELECTCLIPREGION = 0x12C, + META_SELECTOBJECT = 0x12D, + META_SETTEXTALIGN = 0x12E, + META_RESIZEPALETTE = 0x139, + META_DIBCREATEPATTERNBRUSH = 0x142, + META_SETLAYOUT = 0x149, + META_DELETEOBJECT = 0x1F0, + META_CREATEPATTERNBRUSH = 0x1F9, + META_SETBKCOLOR = 0x201, + META_SETTEXTCOLOR = 0x209, + META_SETTEXTJUSTIFICATION = 0x20A, + META_SETWINDOWORG = 0x20B, + META_SETWINDOWEXT = 0x20C, + META_SETVIEWPORTORG = 0x20D, + META_SETVIEWPORTEXT = 0x20E, + META_OFFSETWINDOWORG = 0x20F, + META_OFFSETVIEWPORTORG = 0x211, + META_LINETO = 0x213, + META_MOVETO = 0x214, + META_OFFSETCLIPRGN = 0x220, + META_FILLREGION = 0x228, + META_SETMAPPERFLAGS = 0x231, + META_SELECTPALETTE = 0x234, + META_CREATEPENINDIRECT = 0x2FA, + META_CREATEFONTINDIRECT = 0x2FB, + META_CREATEBRUSHINDIRECT = 0x2FC, + META_POLYGON = 0x324, + META_POLYLINE = 0x325, + META_SCALEWINDOWEXT = 0x410, + META_SCALEVIEWPORTEXT = 0x412, + META_EXCLUDECLIPRECT = 0x415, + META_INTERSECTCLIPRECT = 0x416, + META_ELLIPSE = 0x418, + META_FLOODFILL = 0x419, + META_RECTANGLE = 0x41B, + META_SETPIXEL = 0x41F, + META_FRAMEREGION = 0x429, + META_ANIMATEPALETTE = 0x436, + META_TEXTOUT = 0x521, + META_POLYPOLYGON = 0x538, + META_EXTFLOODFILL = 0x548, + META_ROUNDRECT = 0x61C, + META_PATBLT = 0x61D, + META_ESCAPE = 0x626, + META_CREATEREGION = 0x6FF, + META_ARC = 0x817, + META_PIE = 0x81A, + META_CHORD = 0x830, + META_BITBLT = 0x922, + META_DIBBITBLT = 0x940, + META_EXTTEXTOUT = 0xA32, + META_STRETCHBLT = 0xB23, + META_DIBSTRETCHBLT = 0xB41, + META_SETDIBTODEV = 0xD33, + META_STRETCHDIB = 0xF43 +} + +// EMRPOLYDRAW +enum : BYTE { + PT_CLOSEFIGURE = 1, + PT_LINETO = 2, + PT_BEZIERTO = 4, + PT_MOVETO = 6 +} + +// ---- +// PIXELFORMATDESCRIPTOR.iPixelType +enum : BYTE { + PFD_TYPE_RGBA = 0, + PFD_TYPE_COLORINDEX = 1 +} + +deprecated { +// PIXELFORMATDESCRIPTOR. +const byte + PFD_MAIN_PLANE = 0, + PFD_OVERLAY_PLANE = 1, + PFD_UNDERLAY_PLANE = -1; +} +// PIXELFORMATDESCRIPTOR.dwFlags +const DWORD + PFD_DOUBLEBUFFER = 0x00000001, + PFD_STEREO = 0x00000002, + PFD_DRAW_TO_WINDOW = 0x00000004, + PFD_DRAW_TO_BITMAP = 0x00000008, + PFD_SUPPORT_GDI = 0x00000010, + PFD_SUPPORT_OPENGL = 0x00000020, + PFD_GENERIC_FORMAT = 0x00000040, + PFD_NEED_PALETTE = 0x00000080, + PFD_NEED_SYSTEM_PALETTE = 0x00000100, + PFD_SWAP_EXCHANGE = 0x00000200, + PFD_SWAP_COPY = 0x00000400, + PFD_SWAP_LAYER_BUFFERS = 0x00000800, + PFD_GENERIC_ACCELERATED = 0x00001000, + PFD_SUPPORT_DIRECTDRAW = 0x00002000, + /* PIXELFORMATDESCRIPTOR flags for use in ChoosePixelFormat only */ + PFD_DEPTH_DONTCARE = 0x20000000, + PFD_DOUBLEBUFFER_DONTCARE = 0x40000000, + PFD_STEREO_DONTCARE = 0x80000000; + +// ---- + +const DWORD + BLACKNESS = 0x000042, + NOTSRCERASE = 0x1100A6, + NOTSRCCOPY = 0x330008, + SRCERASE = 0x440328, + DSTINVERT = 0x550009, + PATINVERT = 0x5A0049, + SRCINVERT = 0x660046, + SRCAND = 0x8800C6, + MERGEPAINT = 0xBB0226, + MERGECOPY = 0xC000CA, + SRCCOPY = 0xCC0020, + SRCPAINT = 0xEE0086, + PATCOPY = 0xF00021, + PATPAINT = 0xFB0A09, + WHITENESS = 0xFF0062; +static if (WINVER >= 0x0500) { + const DWORD + NOMIRRORBITMAP = 0x80000000, + CAPTUREBLT = 0x40000000; +} + +// GetROP2(), SetROP2() +enum : int { + R2_BLACK = 1, + R2_NOTMERGEPEN = 2, + R2_MASKNOTPEN = 3, + R2_NOTCOPYPEN = 4, + R2_MASKPENNOT = 5, + R2_NOT = 6, + R2_XORPEN = 7, + R2_NOTMASKPEN = 8, + R2_MASKPEN = 9, + R2_NOTXORPEN = 10, + R2_NOP = 11, + R2_MERGENOTPEN = 12, + R2_COPYPEN = 13, + R2_MERGEPENNOT = 14, + R2_MERGEPEN = 15, + R2_WHITE = 16 +} + +const R2_LAST = R2_WHITE; + +// CheckColorsInGamut() +const ubyte + CM_IN_GAMUT = 0, + CM_OUT_OF_GAMUT = 255; + +/* UpdateICMRegKey Constants */ +const int + ICM_ADDPROFILE = 1, + ICM_DELETEPROFILE = 2, + ICM_QUERYPROFILE = 3, + ICM_SETDEFAULTPROFILE = 4, + ICM_REGISTERICMATCHER = 5, + ICM_UNREGISTERICMATCHER = 6, + ICM_QUERYMATCH = 7; + +enum : int { + RGN_AND = 1, + RGN_OR = 2, + RGN_XOR = 3, + RGN_DIFF = 4, + RGN_COPY = 5 +} + +const RGN_MIN = RGN_AND; +const RGN_MAX = RGN_COPY; + +// Return values for CombineRgn() +enum { + NULLREGION = 1, + SIMPLEREGION = 2, + COMPLEXREGION = 3 +} + +const ERROR = 0; +alias ERROR RGN_ERROR; + +// CreateDIBitmap() +const DWORD CBM_INIT = 4; + +// CreateDIBitmap() +enum : UINT { + DIB_RGB_COLORS = 0, + DIB_PAL_COLORS = 1 +} + +// --- +// Values for LOGFONT and CreateFont() + +// FIXME: For D, replace with lfFaceName.length() +const LF_FACESIZE = 32; +const LF_FULLFACESIZE = 64; + +// FIXME: Not needed for D, only EXTLOGFONT +const ELF_VENDOR_SIZE = 4; + +// ??? +const ELF_VERSION = 0; +const ELF_CULTURE_LATIN = 0; + +// LOGFONT.lfWeight +const LONG + FW_DONTCARE = 0, + FW_THIN = 100, + FW_EXTRALIGHT = 200, + FW_ULTRALIGHT = FW_EXTRALIGHT, + FW_LIGHT = 300, + FW_NORMAL = 400, + FW_REGULAR = FW_NORMAL, + FW_MEDIUM = 500, + FW_SEMIBOLD = 600, + FW_DEMIBOLD = FW_SEMIBOLD, + FW_BOLD = 700, + FW_EXTRABOLD = 800, + FW_ULTRABOLD = FW_EXTRABOLD, + FW_HEAVY = 900, + FW_BLACK = FW_HEAVY; + +// LOGFONT.lfCharSet +enum : DWORD { + ANSI_CHARSET = 0, + DEFAULT_CHARSET = 1, + SYMBOL_CHARSET = 2, + MAC_CHARSET = 77, + SHIFTJIS_CHARSET = 128, + HANGEUL_CHARSET = 129, + HANGUL_CHARSET = 129, + JOHAB_CHARSET = 130, + GB2312_CHARSET = 134, + CHINESEBIG5_CHARSET = 136, + GREEK_CHARSET = 161, + TURKISH_CHARSET = 162, + VIETNAMESE_CHARSET = 163, + HEBREW_CHARSET = 177, + ARABIC_CHARSET = 178, + BALTIC_CHARSET = 186, + RUSSIAN_CHARSET = 204, + THAI_CHARSET = 222, + EASTEUROPE_CHARSET = 238, + OEM_CHARSET = 255 +} + +// LOGFONT.lfOutPrecision +enum : BYTE { + OUT_DEFAULT_PRECIS = 0, + OUT_STRING_PRECIS, + OUT_CHARACTER_PRECIS, + OUT_STROKE_PRECIS, + OUT_TT_PRECIS, + OUT_DEVICE_PRECIS, + OUT_RASTER_PRECIS, + OUT_TT_ONLY_PRECIS, + OUT_OUTLINE_PRECIS, + OUT_SCREEN_OUTLINE_PRECIS, + OUT_PS_ONLY_PRECIS, // 10 +} + +// LOGFONT.lfClipPrecision +enum : BYTE { + CLIP_DEFAULT_PRECIS = 0, + CLIP_CHARACTER_PRECIS = 1, + CLIP_STROKE_PRECIS = 2, + CLIP_MASK = 15, + CLIP_LH_ANGLES = 16, + CLIP_TT_ALWAYS = 32, + CLIP_DFA_DISABLE = 64, + CLIP_EMBEDDED = 128 +} + +// LOGFONT.lfQuality +enum : BYTE { + DEFAULT_QUALITY = 0, + DRAFT_QUALITY, + PROOF_QUALITY, + NONANTIALIASED_QUALITY, + ANTIALIASED_QUALITY +} + +// LOGFONT.lfPitchAndFamily + +const BYTE + DEFAULT_PITCH = 0, + FIXED_PITCH = 1, + VARIABLE_PITCH = 2, + MONO_FONT = 8, + FF_DONTCARE = 0, + FF_ROMAN = 16, + FF_SWISS = 32, + FF_SCRIPT = 64, + FF_MODERN = 48, + FF_DECORATIVE = 80; + +// ---- +// Enums for the PANOSE struct + +const PANOSE_COUNT=10; + +enum { + PAN_FAMILYTYPE_INDEX = 0, + PAN_SERIFSTYLE_INDEX, + PAN_WEIGHT_INDEX, + PAN_PROPORTION_INDEX, + PAN_CONTRAST_INDEX, + PAN_STROKEVARIATION_INDEX, + PAN_ARMSTYLE_INDEX, + PAN_LETTERFORM_INDEX, + PAN_MIDLINE_INDEX, + PAN_XHEIGHT_INDEX +} + +const PAN_CULTURE_LATIN=0; + +// NOTE: the first two values (PAN_ANY and PAN_NO_FIT) apply to all these enums! +enum : BYTE { + PAN_ANY = 0, + PAN_NO_FIT = 1, +} + +enum : BYTE { + PAN_FAMILY_TEXT_DISPLAY = 2, + PAN_FAMILY_SCRIPT, + PAN_FAMILY_DECORATIVE, + PAN_FAMILY_PICTORIAL +} +enum : BYTE { + PAN_SERIF_COVE = 2, + PAN_SERIF_OBTUSE_COVE, + PAN_SERIF_SQUARE_COVE, + PAN_SERIF_OBTUSE_SQUARE_COVE, + PAN_SERIF_SQUARE, + PAN_SERIF_THIN, + PAN_SERIF_BONE, + PAN_SERIF_EXAGGERATED, + PAN_SERIF_TRIANGLE, + PAN_SERIF_NORMAL_SANS, + PAN_SERIF_OBTUSE_SANS, + PAN_SERIF_PERP_SANS, + PAN_SERIF_FLARED, + PAN_SERIF_ROUNDED +} + +enum : BYTE { + PAN_WEIGHT_VERY_LIGHT = 2, + PAN_WEIGHT_LIGHT, + PAN_WEIGHT_THIN, + PAN_WEIGHT_BOOK, + PAN_WEIGHT_MEDIUM, + PAN_WEIGHT_DEMI, + PAN_WEIGHT_BOLD, + PAN_WEIGHT_HEAVY, + PAN_WEIGHT_BLACK, + PAN_WEIGHT_NORD +} + +enum : BYTE { + PAN_PROP_OLD_STYLE = 2, + PAN_PROP_MODERN, + PAN_PROP_EVEN_WIDTH, + PAN_PROP_EXPANDED, + PAN_PROP_CONDENSED, + PAN_PROP_VERY_EXPANDED, + PAN_PROP_VERY_CONDENSED, + PAN_PROP_MONOSPACED +} + +enum : BYTE { + PAN_CONTRAST_NONE = 2, + PAN_CONTRAST_VERY_LOW, + PAN_CONTRAST_LOW, + PAN_CONTRAST_MEDIUM_LOW, + PAN_CONTRAST_MEDIUM, + PAN_CONTRAST_MEDIUM_HIGH, + PAN_CONTRAST_HIGH, + PAN_CONTRAST_VERY_HIGH +} + +// PANOSE.bStrokeVariation +enum : BYTE { + PAN_STROKE_GRADUAL_DIAG = 2, + PAN_STROKE_GRADUAL_TRAN, + PAN_STROKE_GRADUAL_VERT, + PAN_STROKE_GRADUAL_HORZ, + PAN_STROKE_RAPID_VERT, + PAN_STROKE_RAPID_HORZ, + PAN_STROKE_INSTANT_VERT +} + +// PANOSE.bArmStyle +enum : BYTE { + PAN_STRAIGHT_ARMS_HORZ = 2, + PAN_STRAIGHT_ARMS_WEDGE, + PAN_STRAIGHT_ARMS_VERT, + PAN_STRAIGHT_ARMS_SINGLE_SERIF, + PAN_STRAIGHT_ARMS_DOUBLE_SERIF, + PAN_BENT_ARMS_HORZ, + PAN_BENT_ARMS_WEDGE, + PAN_BENT_ARMS_VERT, + PAN_BENT_ARMS_SINGLE_SERIF, + PAN_BENT_ARMS_DOUBLE_SERIF +} + +// PANOSE.bLetterForm +enum : BYTE { + PAN_LETT_NORMAL_CONTACT = 2, + PAN_LETT_NORMAL_WEIGHTED, + PAN_LETT_NORMAL_BOXED, + PAN_LETT_NORMAL_FLATTENED, + PAN_LETT_NORMAL_ROUNDED, + PAN_LETT_NORMAL_OFF_CENTER, + PAN_LETT_NORMAL_SQUARE, + PAN_LETT_OBLIQUE_CONTACT, + PAN_LETT_OBLIQUE_WEIGHTED, + PAN_LETT_OBLIQUE_BOXED, + PAN_LETT_OBLIQUE_FLATTENED, + PAN_LETT_OBLIQUE_ROUNDED, + PAN_LETT_OBLIQUE_OFF_CENTER, + PAN_LETT_OBLIQUE_SQUARE +} + +// PANOSE.bMidLine +enum : BYTE { + PAN_MIDLINE_STANDARD_TRIMMED = 2, + PAN_MIDLINE_STANDARD_POINTED, + PAN_MIDLINE_STANDARD_SERIFED, + PAN_MIDLINE_HIGH_TRIMMED, + PAN_MIDLINE_HIGH_POINTED, + PAN_MIDLINE_HIGH_SERIFED, + PAN_MIDLINE_CONSTANT_TRIMMED, + PAN_MIDLINE_CONSTANT_POINTED, + PAN_MIDLINE_CONSTANT_SERIFED, + PAN_MIDLINE_LOW_TRIMMED, + PAN_MIDLINE_LOW_POINTED, + PAN_MIDLINE_LOW_SERIFED +} + +// PANOSE.bXHeight +enum : BYTE { + PAN_XHEIGHT_CONSTANT_SMALL = 2, + PAN_XHEIGHT_CONSTANT_STD, + PAN_XHEIGHT_CONSTANT_LARGE, + PAN_XHEIGHT_DUCKING_SMALL, + PAN_XHEIGHT_DUCKING_STD, + PAN_XHEIGHT_DUCKING_LARGE +} + +// ---- +// ??? +const FS_LATIN1 = 0x00000001; +const FS_LATIN2 = 0x00000002; +const FS_CYRILLIC = 0x00000004; +const FS_GREEK = 0x00000008; +const FS_TURKISH = 0x00000010; +const FS_HEBREW = 0x00000020; +const FS_ARABIC = 0x00000040; +const FS_BALTIC = 0x00000080; +const FS_VIETNAMESE = 0x00000100; +const FS_THAI = 0x00010000; +const FS_JISJAPAN = 0x00020000; +const FS_CHINESESIMP = 0x00040000; +const FS_WANSUNG = 0x00080000; +const FS_CHINESETRAD = 0x00100000; +const FS_JOHAB = 0x00200000; +const FS_SYMBOL = 0x80000000; + +// ---- +// Poly Fill Mode +enum : int { + ALTERNATE = 1, + WINDING = 2 +} +const int POLYFILL_LAST = WINDING; + +//--- +// LOGBRUSH +enum : LONG { + HS_HORIZONTAL = 0, + HS_VERTICAL, + HS_FDIAGONAL, + HS_BDIAGONAL, + HS_CROSS, + HS_DIAGCROSS +} + +//LOGBRUSH.lbStyle +enum : UINT { + BS_SOLID = 0, + BS_NULL = 1, + BS_HOLLOW = BS_NULL, + BS_HATCHED, + BS_PATTERN, + BS_INDEXED, + BS_DIBPATTERN, + BS_DIBPATTERNPT, + BS_PATTERN8X8, + BS_DIBPATTERN8X8, + BS_MONOPATTERN, +} +//----- +// EXTLOGPEN, ExtCreatePen() + +// EXTLOGPEN.elpPenStyle +enum : DWORD { + PS_SOLID = 0, + PS_DASH = 1, + PS_DOT = 2, + PS_DASHDOT = 3, + PS_DASHDOTDOT = 4, + PS_NULL = 5, + PS_INSIDEFRAME = 6, + PS_USERSTYLE = 7, + PS_ALTERNATE = 8, + PS_STYLE_MASK = 15, +} + +enum : DWORD { + PS_COSMETIC = 0x00000000, + PS_GEOMETRIC = 0x00010000, + PS_TYPE_MASK = 0x000F0000, +} +enum : DWORD { + PS_ENDCAP_ROUND = 0x00000000, + PS_ENDCAP_SQUARE = 0x00000100, + PS_ENDCAP_FLAT = 0x00000200, + PS_ENDCAP_MASK = 0x00000F00, +} +enum : DWORD { + PS_JOIN_ROUND = 0x00000000, + PS_JOIN_BEVEL = 0x00001000, + PS_JOIN_MITER = 0x00002000, + PS_JOIN_MASK = 0x0000F000, +} + +// --- +// DeviceCapabilities() + +enum : WORD { + DC_FIELDS = 1, + DC_PAPERS, + DC_PAPERSIZE, + DC_MINEXTENT, + DC_MAXEXTENT, + DC_BINS, + DC_DUPLEX, + DC_SIZE, + DC_EXTRA, + DC_VERSION, + DC_DRIVER, + DC_BINNAMES, + DC_ENUMRESOLUTIONS, + DC_FILEDEPENDENCIES, + DC_TRUETYPE, + DC_PAPERNAMES, + DC_ORIENTATION, + DC_COPIES, + DC_BINADJUST, + DC_EMF_COMPLIANT, + DC_DATATYPE_PRODUCED, + DC_COLLATE, + DC_MANUFACTURER, + DC_MODEL, +} + +static if (WINVER >= 0x0500) { + enum { + DC_PERSONALITY = 25, + DC_PRINTRATE = 26, + DC_PRINTRATEUNIT = 27, + DC_PRINTERMEM = 28, + DC_MEDIAREADY = 29, + DC_STAPLE = 30, + DC_PRINTRATEPPM = 31, + DC_COLORDEVICE = 32, + DC_NUP = 33, + DC_MEDIATYPENAMES = 34, + DC_MEDIATYPES = 35, + } + enum { + PRINTRATEUNIT_PPM = 1, + PRINTRATEUNIT_CPS = 2, + PRINTRATEUNIT_LPM = 3, + PRINTRATEUNIT_IPM = 4, + } +} + + +// return from DC_TRUETYPE +const DWORD + DCTT_BITMAP = 1, + DCTT_DOWNLOAD = 2, + DCTT_SUBDEV = 4, + DCTT_DOWNLOAD_OUTLINE = 8; + +static if (WINVER >= 0x0400) { + // return from DC_BINADJUST + enum : DWORD { + DCBA_FACEUPNONE = 0x0000, + DCBA_FACEUPCENTER = 0x0001, + DCBA_FACEUPLEFT = 0x0002, + DCBA_FACEUPRIGHT = 0x0003, + DCBA_FACEDOWNNONE = 0x0100, + DCBA_FACEDOWNCENTER = 0x0101, + DCBA_FACEDOWNLEFT = 0x0102, + DCBA_FACEDOWNRIGHT = 0x0103, + } +} +//--- + +const FLOODFILLBORDER = 0; +const FLOODFILLSURFACE = 1; + +// ExtTextOut() +const UINT + ETO_OPAQUE = 0x0002, + ETO_CLIPPED = 0x0004, + ETO_GLYPH_INDEX = 0x0010, + ETO_RTLREADING = 0x0080, + ETO_NUMERICSLOCAL = 0x0400, + ETO_NUMERICSLATIN = 0x0800, + ETO_IGNORELANGUAGE = 0x1000; +static if (_WIN32_WINNT >= 0x0500) { + const UINT + ETO_PDY = 0x2000; +} + +// GdiComment() +enum { + GDICOMMENT_BEGINGROUP = 0x00000002, + GDICOMMENT_ENDGROUP = 0x00000003, + GDICOMMENT_UNICODE_STRING = 0x00000040, + GDICOMMENT_UNICODE_END = 0x00000080, + GDICOMMENT_MULTIFORMATS = 0x40000004, + GDICOMMENT_IDENTIFIER = 0x43494447, + GDICOMMENT_WINDOWS_METAFILE = 0x80000001, +} + +// Get/SetArcDirection() +enum : int { + AD_COUNTERCLOCKWISE = 1, + AD_CLOCKWISE = 2 +} + +const RDH_RECTANGLES = 1; + +// GCPRESULTS.lpClass +enum { + GCPCLASS_LATIN = 1, + GCPCLASS_HEBREW = 2, + GCPCLASS_ARABIC = 2, + GCPCLASS_NEUTRAL, + GCPCLASS_LOCALNUMBER, + GCPCLASS_LATINNUMBER, + GCPCLASS_LATINNUMERICTERMINATOR, + GCPCLASS_LATINNUMERICSEPARATOR, + GCPCLASS_NUMERICSEPARATOR, // = 8, + GCPCLASS_POSTBOUNDRTL = 16, + GCPCLASS_POSTBOUNDLTR = 32, + GCPCLASS_PREBOUNDRTL = 64, + GCPCLASS_PREBOUNDLTR = 128, + GCPGLYPH_LINKAFTER = 0x4000, + GCPGLYPH_LINKBEFORE = 0x8000 +} + +// GetBoundsRect(), SetBoundsRect() +const UINT + DCB_RESET = 1, + DCB_ACCUMULATE = 2, + DCB_SET = DCB_RESET | DCB_ACCUMULATE, + DCB_ENABLE = 4, + DCB_DISABLE = 8, + DCB_DIRTY = DCB_ACCUMULATE; + +//--- +// GetObjectType() +enum : DWORD { + OBJ_PEN = 1, + OBJ_BRUSH, + OBJ_DC, + OBJ_METADC, + OBJ_PAL, + OBJ_FONT, + OBJ_BITMAP, + OBJ_REGION, + OBJ_METAFILE, + OBJ_MEMDC, + OBJ_EXTPEN, + OBJ_ENHMETADC, + OBJ_ENHMETAFILE, + OBJ_COLORSPACE, +} + +//--------------------- +// Capabilities for GetDeviceCaps(dc, xxx) + +enum : int { + DRIVERVERSION = 0, + TECHNOLOGY = 2, + HORZSIZE = 4, + VERTSIZE = 6, + HORZRES = 8, + VERTRES = 10, + BITSPIXEL = 12, + PLANES = 14, + NUMBRUSHES = 16, + NUMPENS = 18, + NUMMARKERS = 20, + NUMFONTS = 22, + NUMCOLORS = 24, + PDEVICESIZE = 26, + CURVECAPS = 28, + LINECAPS = 30, + POLYGONALCAPS = 32, + TEXTCAPS = 34, + CLIPCAPS = 36, + RASTERCAPS = 38, + ASPECTX = 40, + ASPECTY = 42, + ASPECTXY = 44, + LOGPIXELSX = 88, + LOGPIXELSY = 90, + SIZEPALETTE = 104, + NUMRESERVED = 106, + COLORRES = 108, + PHYSICALWIDTH = 110, + PHYSICALHEIGHT = 111, + PHYSICALOFFSETX = 112, + PHYSICALOFFSETY = 113, + SCALINGFACTORX = 114, + SCALINGFACTORY = 115, + VREFRESH = 116, + DESKTOPVERTRES = 117, + DESKTOPHORZRES = 118, + BLTALIGNMENT = 119 +} +static if (WINVER >= 0x0500) { + int + SHADEBLENDCAPS = 120, + COLORMGMTCAPS = 121; +} + +// Return values for GetDeviceCaps(dc, TECHNOLOGY) +enum : int { + DT_PLOTTER = 0, + DT_RASDISPLAY, + DT_RASPRINTER, + DT_RASCAMERA, + DT_CHARSTREAM, + DT_METAFILE, + DT_DISPFILE // = 6 +} + +// Return values for GetDeviceCaps(dc, RASTERCAPS) +const int + RC_NONE = 0, + RC_BITBLT = 1, + RC_BANDING = 2, + RC_SCALING = 4, + RC_BITMAP64 = 8, + RC_GDI20_OUTPUT = 16, + RC_GDI20_STATE = 32, + RC_SAVEBITMAP = 64, + RC_DI_BITMAP = 128, + RC_PALETTE = 256, + RC_DIBTODEV = 512, + RC_BIGFONT = 1024, + RC_STRETCHBLT = 2048, + RC_FLOODFILL = 4096, + RC_STRETCHDIB = 8192, + RC_OP_DX_OUTPUT = 0x4000, + RC_DEVBITS = 0x8000; + +static if (WINVER >= 0x0500) { + /* Shading and blending caps */ + const SB_NONE = 0x00000000; + const SB_CONST_ALPHA = 0x00000001; + const SB_PIXEL_ALPHA = 0x00000002; + const SB_PREMULT_ALPHA = 0x00000004; + const SB_GRAD_RECT = 0x00000010; + const SB_GRAD_TRI = 0x00000020; + /* Color Management caps */ + const CM_NONE = 0x00000000; + const CM_DEVICE_ICM = 0x00000001; + const CM_GAMMA_RAMP = 0x00000002; + const CM_CMYK_COLOR = 0x00000004; +} + +// Return values for GetDeviceCaps(dc, CURVECAPS) +const int + CC_NONE = 0, + CC_CIRCLES = 1, + CC_PIE = 2, + CC_CHORD = 4, + CC_ELLIPSES = 8, + CC_WIDE = 16, + CC_STYLED = 32, + CC_WIDESTYLED = 64, + CC_INTERIORS = 128, + CC_ROUNDRECT = 256; + +// Return values for GetDeviceCaps(dc, LINECAPS) + +const int + LC_NONE = 0, + LC_POLYLINE = 2, + LC_MARKER = 4, + LC_POLYMARKER = 8, + LC_WIDE = 16, + LC_STYLED = 32, + LC_WIDESTYLED = 64, + LC_INTERIORS = 128; + +// Return values for GetDeviceCaps(dc, POLYGONALCAPS) + +const int + PC_NONE = 0, + PC_POLYGON = 1, + PC_RECTANGLE = 2, + PC_WINDPOLYGON = 4, + PC_TRAPEZOID = 4, + PC_SCANLINE = 8, + PC_WIDE = 16, + PC_STYLED = 32, + PC_WIDESTYLED = 64, + PC_INTERIORS = 128, + PC_POLYPOLYGON = 256, + PC_PATHS = 512; + +/* Clipping Capabilities */ +const int CP_NONE = 0, + CP_RECTANGLE = 1, + CP_REGION = 2; + +// Return values for GetDeviceCaps(dc, TEXTCAPS) + +const int + TC_OP_CHARACTER = 1, + TC_OP_STROKE = 2, + TC_CP_STROKE = 4, + TC_CR_90 = 8, + TC_CR_ANY = 16, + TC_SF_X_YINDEP = 32, + TC_SA_DOUBLE = 64, + TC_SA_INTEGER = 128, + TC_SA_CONTIN = 256, + TC_EA_DOUBLE = 512, + TC_IA_ABLE = 1024, + TC_UA_ABLE = 2048, + TC_SO_ABLE = 4096, + TC_RA_ABLE = 8192, + TC_VA_ABLE = 16384, + TC_RESERVED = 32768, + TC_SCROLLBLT = 65536; + +// End GetDeviceCaps +//--------------------- +// GetCharacterPlacement(), and GetFontLanguageInfo() +const DWORD + GCP_DBCS = 1, + GCP_REORDER = 2, + GCP_USEKERNING = 8, + GCP_GLYPHSHAPE = 16, + GCP_LIGATE = 32, + GCP_DIACRITIC = 256, + GCP_KASHIDA = 1024, + GCP_ERROR = 0x8000, + GCP_JUSTIFY = 0x10000, + GCP_CLASSIN = 0x80000, + GCP_MAXEXTENT = 0x100000, + GCP_JUSTIFYIN = 0x200000, + GCP_DISPLAYZWG = 0x400000, + GCP_SYMSWAPOFF = 0x800000, + GCP_NUMERICOVERRIDE = 0x1000000, + GCP_NEUTRALOVERRIDE = 0x2000000, + GCP_NUMERICSLATIN = 0x4000000, + GCP_NUMERICSLOCAL = 0x8000000, + // Only for GetFontLanguageInfo() + FLI_GLYPHS = 0x40000, + FLI_MASK = 0x103b; + +// GetGlyphOutline() +enum : UINT { + GGO_METRICS = 0, + GGO_BITMAP = 1, + GGO_NATIVE = 2, + GGO_BEZIER = 3, + GGO_GRAY2_BITMAP = 4, + GGO_GRAY4_BITMAP = 5, + GGO_GRAY8_BITMAP = 6, + GGO_GLYPH_INDEX = 128, + GGO_UNHINTED = 256 +} + +enum : int { + GM_COMPATIBLE = 1, + GM_ADVANCED +} +const GM_LAST = GM_ADVANCED; + +enum : int { + MM_TEXT = 1, + MM_LOMETRIC, + MM_HIMETRIC, + MM_LOENGLISH, + MM_HIENGLISH, + MM_TWIPS, + MM_ISOTROPIC, + MM_ANISOTROPIC, +} + +const int + MM_MIN = MM_TEXT, + MM_MAX = MM_ANISOTROPIC, + MM_MAX_FIXEDSCALE = MM_TWIPS; + +const ABSOLUTE = 1; +const RELATIVE = 2; + +enum : BYTE { + PC_RESERVED = 1, + PC_EXPLICIT = 2, + PC_NOCOLLAPSE = 4 +} + +/* FIXME: move to win32.commctrl ? */ +// ImageList +const COLORREF + CLR_NONE = 0xffffffff, + CLR_INVALID = CLR_NONE, + CLR_DEFAULT = 0xff000000; + +// RASTERIZER_STATUS.wFlags +const short + TT_AVAILABLE = 1, + TT_ENABLED = 2; + +// GetStockObject() +enum : int { + WHITE_BRUSH = 0, + LTGRAY_BRUSH, + GRAY_BRUSH, + DKGRAY_BRUSH, + BLACK_BRUSH, + HOLLOW_BRUSH, // = 5 + NULL_BRUSH = HOLLOW_BRUSH, + WHITE_PEN = 6, + BLACK_PEN, + NULL_PEN, // = 8 + OEM_FIXED_FONT = 10, + ANSI_FIXED_FONT, + ANSI_VAR_FONT, + SYSTEM_FONT, + DEVICE_DEFAULT_FONT, + DEFAULT_PALETTE, + SYSTEM_FIXED_FONT, +} +static if (WINVER >= 0x0400) { + enum : int { + DEFAULT_GUI_FONT = SYSTEM_FIXED_FONT + 1, + } +} +static if (_WIN32_WINNT >= 0x0500) { + enum : int { + DC_BRUSH = DEFAULT_GUI_FONT + 1, + DC_PEN, + } +} + +static if (_WIN32_WINNT >= 0x0500) { + const STOCK_LAST = DC_PEN; +} +else static if (WINVER >= 0x0400) { + const STOCK_LAST = DEFAULT_GUI_FONT; +} +else { + const STOCK_LAST = SYSTEM_FIXED_FONT; +} + +// Get/SetSystemPaletteUse() +enum : UINT { + SYSPAL_ERROR = 0, + SYSPAL_STATIC = 1, + SYSPAL_NOSTATIC = 2, + SYSPAL_NOSTATIC256 = 3, +} + +// SetTextAlign() +const UINT + TA_TOP = 0, + TA_CENTER = 6, + TA_BOTTOM = 8, + TA_BASELINE = 24, + TA_LEFT = 0, + TA_RIGHT = 2, + TA_RTLREADING = 256, + TA_NOUPDATECP = 0, + TA_UPDATECP = 1, + TA_MASK = TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING, + VTA_BASELINE = TA_BASELINE, + VTA_CENTER = TA_CENTER, + VTA_LEFT = TA_BOTTOM, + VTA_RIGHT = TA_TOP, + VTA_BOTTOM = TA_RIGHT, + VTA_TOP = TA_LEFT; + +// EMRMODIFYWORLDTRANSFORM.iMode +enum : DWORD { + MWT_IDENTITY = 1, + MWT_LEFTMULTIPLY, + MWT_RIGHTMULTIPLY +} + +const DWORD + MWT_MIN = MWT_IDENTITY, + MWT_MAX = MWT_RIGHTMULTIPLY; + +enum { + TRANSPARENT = 1, + OPAQUE = 2 +} + +// Get/SetStretchMode() +enum : int { + BLACKONWHITE = 1, + WHITEONBLACK = 2, + COLORONCOLOR = 3, + HALFTONE = 4, + + STRETCH_ANDSCANS = 1, + STRETCH_ORSCANS = 2, + STRETCH_DELETESCANS = 3, + STRETCH_HALFTONE = 4, + + MAXSTRETCHBLTMODE = 4 +} + +// TranslateCharsetInfo() +enum : DWORD { + TCI_SRCCHARSET = 1, + TCI_SRCCODEPAGE = 2, + TCI_SRCFONTSIG = 3, + TCI_SRCLOCALE = 0x1000, +} + +// SetICMMode() +enum : int { + ICM_OFF = 1, + ICM_ON = 2, + ICM_QUERY = 3, + ICM_DONE_OUTSIDEDC = 4, +} + +// ---- +// Escape() Spooler Error Codes +enum : int { + SP_NOTREPORTED = 0x4000, + SP_ERROR = -1, + SP_APPABORT = -2, + SP_USERABORT = -3, + SP_OUTOFDISK = -4, + SP_OUTOFMEMORY = -5 +} + +// Escape(), ExtEscape() +// Most of the following are deprecated (Win16 only) +enum : int { + NEWFRAME = 1, + ABORTDOC = 2, + NEXTBAND = 3, + SETCOLORTABLE = 4, + GETCOLORTABLE = 5, + FLUSHOUTPUT = 6, + DRAFTMODE = 7, + QUERYESCSUPPORT = 8, + SETABORTPROC = 9, + STARTDOC = 10, + ENDDOC = 11, + GETPHYSPAGESIZE = 12, + GETPRINTINGOFFSET = 13, + GETSCALINGFACTOR = 14, + MFCOMMENT = 15, + GETPENWIDTH = 16, + SETCOPYCOUNT = 17, + SELECTPAPERSOURCE = 18, + DEVICEDATA = 19, + PASSTHROUGH = 19, + GETTECHNOLOGY = 20, + SETLINECAP = 21, + SETLINEJOIN = 22, + SETMITERLIMIT = 23, + BANDINFO = 24, + DRAWPATTERNRECT = 25, + GETVECTORPENSIZE = 26, + GETVECTORBRUSHSIZE = 27, + ENABLEDUPLEX = 28, + GETSETPAPERBINS = 29, + GETSETPRINTORIENT = 30, + ENUMPAPERBINS = 31, + SETDIBSCALING = 32, + EPSPRINTING = 33, + ENUMPAPERMETRICS = 34, + GETSETPAPERMETRICS = 35, + POSTSCRIPT_DATA = 37, + POSTSCRIPT_IGNORE = 38, + MOUSETRAILS = 39, + GETDEVICEUNITS = 42, + GETEXTENDEDTEXTMETRICS = 256, + GETEXTENTTABLE = 257, + GETPAIRKERNTABLE = 258, + GETTRACKKERNTABLE = 259, + EXTTEXTOUT = 512, + GETFACENAME = 513, + DOWNLOADFACE = 514, + ENABLERELATIVEWIDTHS = 768, + ENABLEPAIRKERNING = 769, + SETKERNTRACK = 770, + SETALLJUSTVALUES = 771, + SETCHARSET = 772, + STRETCHBLT = 2048, + METAFILE_DRIVER = 2049, + GETSETSCREENPARAMS = 3072, + QUERYDIBSUPPORT = 3073, + BEGIN_PATH = 4096, + CLIP_TO_PATH = 4097, + END_PATH = 4098, + EXT_DEVICE_CAPS = 4099, + RESTORE_CTM = 4100, + SAVE_CTM = 4101, + SET_ARC_DIRECTION = 4102, + SET_BACKGROUND_COLOR = 4103, + SET_POLY_MODE = 4104, + SET_SCREEN_ANGLE = 4105, + SET_SPREAD = 4106, + TRANSFORM_CTM = 4107, + SET_CLIP_BOX = 4108, + SET_BOUNDS = 4109, + SET_MIRROR_MODE = 4110, + OPENCHANNEL = 4110, + DOWNLOADHEADER = 4111, + CLOSECHANNEL = 4112, + POSTSCRIPT_PASSTHROUGH = 4115, + ENCAPSULATED_POSTSCRIPT = 4116, + POSTSCRIPT_IDENTIFY = 4117, + POSTSCRIPT_INJECTION = 4118, + CHECKJPEGFORMAT = 4119, + CHECKPNGFORMAT = 4120, + GET_PS_FEATURESETTING = 4121, + SPCLPASSTHROUGH2 = 4568, +} + +enum : int { + PSIDENT_GDICENTRIC = 0, + PSIDENT_PSCENTRIC = 1, +} + +/* + * Header structure for the input buffer to POSTSCRIPT_INJECTION escape + */ +struct PSINJECTDATA { + DWORD DataBytes; + WORD InjectionPoint; + WORD PageNumber; +} +alias PSINJECTDATA* PPSINJECTDATA; + +/* Constants for PSINJECTDATA.InjectionPoint field */ +enum { + PSINJECT_BEGINSTREAM = 1, + PSINJECT_PSADOBE = 2, + PSINJECT_PAGESATEND = 3, + PSINJECT_PAGES = 4, + PSINJECT_DOCNEEDEDRES = 5, + PSINJECT_DOCSUPPLIEDRES = 6, + PSINJECT_PAGEORDER = 7, + PSINJECT_ORIENTATION = 8, + PSINJECT_BOUNDINGBOX = 9, + PSINJECT_DOCUMENTPROCESSCOLORS = 10, + PSINJECT_COMMENTS = 11, + PSINJECT_BEGINDEFAULTS = 12, + PSINJECT_ENDDEFAULTS = 13, + PSINJECT_BEGINPROLOG = 14, + PSINJECT_ENDPROLOG = 15, + PSINJECT_BEGINSETUP = 16, + PSINJECT_ENDSETUP = 17, + PSINJECT_TRAILER = 18, + PSINJECT_EOF = 19, + PSINJECT_ENDSTREAM = 20, + PSINJECT_DOCUMENTPROCESSCOLORSATEND = 21, + + PSINJECT_PAGENUMBER = 100, + PSINJECT_BEGINPAGESETUP = 101, + PSINJECT_ENDPAGESETUP = 102, + PSINJECT_PAGETRAILER = 103, + PSINJECT_PLATECOLOR = 104, + PSINJECT_SHOWPAGE = 105, + PSINJECT_PAGEBBOX = 106, + PSINJECT_ENDPAGECOMMENTS = 107, + + PSINJECT_VMSAVE = 200, + PSINJECT_VMRESTORE = 201, +} + +/* Parameter for GET_PS_FEATURESETTING escape */ +enum { + FEATURESETTING_NUP = 0, + FEATURESETTING_OUTPUT = 1, + FEATURESETTING_PSLEVEL = 2, + FEATURESETTING_CUSTPAPER = 3, + FEATURESETTING_MIRROR = 4, + FEATURESETTING_NEGATIVE = 5, + FEATURESETTING_PROTOCOL = 6, +} + +enum { + FEATURESETTING_PRIVATE_BEGIN = 0x1000, + FEATURESETTING_PRIVATE_END = 0x1FFF, +} + +/* Value returned for FEATURESETTING_PROTOCOL */ +const PSPROTOCOL_ASCII = 0; +const PSPROTOCOL_BCP = 1; +const PSPROTOCOL_TBCP = 2; +const PSPROTOCOL_BINARY = 3; + +// ---- + +const WPARAM PR_JOBSTATUS = 0; + +// ??? +const QDI_SETDIBITS = 1; +const QDI_GETDIBITS = 2; +const QDI_DIBTOSCREEN = 4; +const QDI_STRETCHDIB = 8; + +const ASPECT_FILTERING = 1; + +// LOGCOLORSPACE.lcsCSType +enum : LCSCSTYPE { + LCS_CALIBRATED_RGB = 0, + LCS_DEVICE_RGB, + LCS_DEVICE_CMYK +} /* What this for? */ + +// LOGCOLORSPACE.lcsIntent +enum : LCSGAMUTMATCH { + LCS_GM_BUSINESS = 1, + LCS_GM_GRAPHICS = 2, + LCS_GM_IMAGES = 4, + LCS_GM_ABS_COLORIMETRIC = 8, +} + +const DWORD + RASTER_FONTTYPE = 1, + DEVICE_FONTTYPE = 2, + TRUETYPE_FONTTYPE = 4; + +// --- +// DEVMODE struct + +// FIXME: Not needed for D (use .length instead) +const CCHDEVICENAME = 32; +const CCHFORMNAME = 32; + +// DEVMODE.dmSpecVersion +// current version of specification +static if (WINVER >= 0x0500 || _WIN32_WINNT >= 0x0400) { + const WORD DM_SPECVERSION = 0x0401; +} +else static if (WINVER >= 0x0400) { + const WORD DM_SPECVERSION = 0x0400; +} +else { + const WORD DM_SPECVERSION = 0x0320; +} + +// DEVMODE.dmOrientation +enum : short { + DMORIENT_PORTRAIT = 1, + DMORIENT_LANDSCAPE = 2 +} + +// DEVMODE.dmPaperSize +enum : short { + DMPAPER_LETTER = 1, + DMPAPER_LETTERSMALL, + DMPAPER_TABLOID, + DMPAPER_LEDGER, + DMPAPER_LEGAL, + DMPAPER_STATEMENT, + DMPAPER_EXECUTIVE, + DMPAPER_A3, + DMPAPER_A4, + DMPAPER_A4SMALL, + DMPAPER_A5, + DMPAPER_B4, + DMPAPER_B5, + DMPAPER_FOLIO, + DMPAPER_QUARTO, + DMPAPER_10X14, + DMPAPER_11X17, + DMPAPER_NOTE, + DMPAPER_ENV_9, + DMPAPER_ENV_10, + DMPAPER_ENV_11, + DMPAPER_ENV_12, + DMPAPER_ENV_14, + DMPAPER_CSHEET, + DMPAPER_DSHEET, + DMPAPER_ESHEET, + DMPAPER_ENV_DL, + DMPAPER_ENV_C5, + DMPAPER_ENV_C3, + DMPAPER_ENV_C4, + DMPAPER_ENV_C6, + DMPAPER_ENV_C65, + DMPAPER_ENV_B4, + DMPAPER_ENV_B5, + DMPAPER_ENV_B6, + DMPAPER_ENV_ITALY, + DMPAPER_ENV_MONARCH, + DMPAPER_ENV_PERSONAL, + DMPAPER_FANFOLD_US, + DMPAPER_FANFOLD_STD_GERMAN, + DMPAPER_FANFOLD_LGL_GERMAN, + DMPAPER_ISO_B4, + DMPAPER_JAPANESE_POSTCARD, + DMPAPER_9X11, + DMPAPER_10X11, + DMPAPER_15X11, + DMPAPER_ENV_INVITE, + DMPAPER_RESERVED_48, + DMPAPER_RESERVED_49, + DMPAPER_LETTER_EXTRA, + DMPAPER_LEGAL_EXTRA, + DMPAPER_TABLOID_EXTRA, + DMPAPER_A4_EXTRA, + DMPAPER_LETTER_TRANSVERSE, + DMPAPER_A4_TRANSVERSE, + DMPAPER_LETTER_EXTRA_TRANSVERSE, + DMPAPER_A_PLUS, + DMPAPER_B_PLUS, + DMPAPER_LETTER_PLUS, + DMPAPER_A4_PLUS, + DMPAPER_A5_TRANSVERSE, + DMPAPER_B5_TRANSVERSE, + DMPAPER_A3_EXTRA, + DMPAPER_A5_EXTRA, + DMPAPER_B5_EXTRA, + DMPAPER_A2, + DMPAPER_A3_TRANSVERSE, + DMPAPER_A3_EXTRA_TRANSVERSE // = 68 +} +static if (WINVER >= 0x0500) { + enum : short { + DMPAPER_DBL_JAPANESE_POSTCARD = 69, + DMPAPER_A6, + DMPAPER_JENV_KAKU2, + DMPAPER_JENV_KAKU3, + DMPAPER_JENV_CHOU3, + DMPAPER_JENV_CHOU4, + DMPAPER_LETTER_ROTATED, + DMPAPER_A3_ROTATED, + DMPAPER_A4_ROTATED, + DMPAPER_A5_ROTATED, + DMPAPER_B4_JIS_ROTATED, + DMPAPER_B5_JIS_ROTATED, + DMPAPER_JAPANESE_POSTCARD_ROTATED, + DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED, + DMPAPER_A6_ROTATED, + DMPAPER_JENV_KAKU2_ROTATED, + DMPAPER_JENV_KAKU3_ROTATED, + DMPAPER_JENV_CHOU3_ROTATED, + DMPAPER_JENV_CHOU4_ROTATED, + DMPAPER_B6_JIS, + DMPAPER_B6_JIS_ROTATED, + DMPAPER_12X11, + DMPAPER_JENV_YOU4, + DMPAPER_JENV_YOU4_ROTATED, + DMPAPER_P16K, + DMPAPER_P32K, + DMPAPER_P32KBIG, + DMPAPER_PENV_1, + DMPAPER_PENV_2, + DMPAPER_PENV_3, + DMPAPER_PENV_4, + DMPAPER_PENV_5, + DMPAPER_PENV_6, + DMPAPER_PENV_7, + DMPAPER_PENV_8, + DMPAPER_PENV_9, + DMPAPER_PENV_10, + DMPAPER_P16K_ROTATED, + DMPAPER_P32K_ROTATED, + DMPAPER_P32KBIG_ROTATED, + DMPAPER_PENV_1_ROTATED, + DMPAPER_PENV_2_ROTATED, + DMPAPER_PENV_3_ROTATED, + DMPAPER_PENV_4_ROTATED, + DMPAPER_PENV_5_ROTATED, + DMPAPER_PENV_6_ROTATED, + DMPAPER_PENV_7_ROTATED, + DMPAPER_PENV_8_ROTATED, + DMPAPER_PENV_9_ROTATED, + DMPAPER_PENV_10_ROTATED // 118 + } +} + +const short DMPAPER_FIRST = DMPAPER_LETTER; + +static if (WINVER >= 0x0500) + const short DMPAPER_LAST = DMPAPER_PENV_10_ROTATED; +else + const short DMPAPER_LAST = DMPAPER_A3_EXTRA_TRANSVERSE; + +const short DMPAPER_USER = 256; + + +// DEVMODE.dmDefaultSource +enum : short { + DMBIN_ONLYONE = 1, + DMBIN_UPPER = 1, + DMBIN_LOWER, + DMBIN_MIDDLE, + DMBIN_MANUAL, + DMBIN_ENVELOPE, + DMBIN_ENVMANUAL, + DMBIN_AUTO, + DMBIN_TRACTOR, + DMBIN_SMALLFMT, + DMBIN_LARGEFMT, + DMBIN_LARGECAPACITY, // = 11 + DMBIN_CASSETTE = 14, + DMBIN_FORMSOURCE, +} +short + DMBIN_FIRST = DMBIN_UPPER, + DMBIN_LAST = DMBIN_FORMSOURCE, + DMBIN_USER = 256; + +// DEVMODE.dmPrintQuality +enum : short { + DMRES_DRAFT = -1, + DMRES_LOW = -2, + DMRES_MEDIUM = -3, + DMRES_HIGH = -4 +} + +// DEVMODE.dmColor +enum : short { + DMCOLOR_MONOCHROME = 1, + DMCOLOR_COLOR = 2 +} + +// DEVMODE.dmDuplex +enum : short { + DMDUP_SIMPLEX = 1, + DMDUP_VERTICAL = 2, + DMDUP_HORIZONTAL = 3 +} + +// DEVMODE.dmTTOption +enum : short { + DMTT_BITMAP = 1, + DMTT_DOWNLOAD, + DMTT_SUBDEV, + DMTT_DOWNLOAD_OUTLINE +} + +// DEVMODE.dmCollate +enum : short { + DMCOLLATE_FALSE = 0, + DMCOLLATE_TRUE +} + +static if (WINVER >= 0x0501) { + /* DEVMODE dmDisplayOrientation specifiations */ + enum : short { + DMDO_DEFAULT = 0, + DMDO_90 = 1, + DMDO_180 = 2, + DMDO_270 = 3, + } + + /* DEVMODE dmDisplayFixedOutput specifiations */ + enum : short { + DMDFO_DEFAULT = 0, + DMDFO_STRETCH = 1, + DMDFO_CENTER = 2, + } +} + + +/* FIXME: this flags are deprecated ? */ +// DEVMODE.dmDisplayFlags +const DWORD + DM_GRAYSCALE = 1, + DM_INTERLACED = 2; + +const DWORD + DMDISPLAYFLAGS_TEXTMODE = 0x00000004; + +/* dmNup , multiple logical page per physical page options */ +const DWORD + DMNUP_SYSTEM = 1, + DMNUP_ONEUP = 2; + +// DEVMODE.dmFields +const DWORD + DM_ORIENTATION = 0x00000001, + DM_PAPERSIZE = 0x00000002, + DM_PAPERLENGTH = 0x00000004, + DM_PAPERWIDTH = 0x00000008, + DM_SCALE = 0x00000010; +static if (WINVER >= 0x0500) { + const DWORD + DM_POSITION = 0x00000020, + DM_NUP = 0x00000040; +} +static if (WINVER >= 0x0501) { + const DWORD + DM_DISPLAYORIENTATION = 0x00000080; +} +const DWORD + DM_COPIES = 0x00000100, + DM_DEFAULTSOURCE = 0x00000200, + DM_PRINTQUALITY = 0x00000400, + DM_COLOR = 0x00000800, + DM_DUPLEX = 0x00001000, + DM_YRESOLUTION = 0x00002000, + DM_TTOPTION = 0x00004000, + DM_COLLATE = 0x00008000, + DM_FORMNAME = 0x00010000, + DM_LOGPIXELS = 0x00020000, + DM_BITSPERPEL = 0x00040000, + DM_PELSWIDTH = 0x00080000, + DM_PELSHEIGHT = 0x00100000, + DM_DISPLAYFLAGS = 0x00200000, + DM_DISPLAYFREQUENCY = 0x00400000; +static if (WINVER >= 0x0400) { + const DWORD + DM_ICMMETHOD = 0x00800000, + DM_ICMINTENT = 0x01000000, + DM_MEDIATYPE = 0x02000000, + DM_DITHERTYPE = 0x04000000, + DM_PANNINGWIDTH = 0x08000000, + DM_PANNINGHEIGHT = 0x10000000; +} +static if (WINVER >= 0x0501) { + const DWORD + DM_DISPLAYFIXEDOUTPUT = 0x20000000; +} + +// DEVMODE.dmICMMethod +enum : DWORD { + DMICMMETHOD_NONE = 1, + DMICMMETHOD_SYSTEM = 2, + DMICMMETHOD_DRIVER = 3, + DMICMMETHOD_DEVICE = 4, + DMICMMETHOD_USER = 256 +} + +// DEVMODE.dmICMIntent +enum : DWORD { + DMICM_SATURATE = 1, + DMICM_CONTRAST = 2, + DMICM_COLORIMETRIC = 3, + DMICM_ABS_COLORIMETRIC = 4, + DMICM_USER = 256 +} + +// DEVMODE.dmMediaType +enum : DWORD { + DMMEDIA_STANDARD = 1, + DMMEDIA_TRANSPARENCY = 2, + DMMEDIA_GLOSSY = 3, + DMMEDIA_USER = 256 +} + +// DEVMODE.dmDitherType +enum : DWORD { + DMDITHER_NONE = 1, + DMDITHER_COARSE, + DMDITHER_FINE, + DMDITHER_LINEART, + DMDITHER_ERRORDIFFUSION, + DMDITHER_RESERVED6, + DMDITHER_RESERVED7, + DMDITHER_RESERVED8, + DMDITHER_RESERVED9, + DMDITHER_GRAYSCALE, + DMDITHER_USER = 256 +} + +// ---- +// DocumentProperties() +const DWORD + DM_UPDATE = 1, + DM_COPY = 2, + DM_PROMPT = 4, + DM_MODIFY = 8, + DM_IN_BUFFER = DM_MODIFY, + DM_IN_PROMPT = DM_PROMPT, + DM_OUT_BUFFER = DM_COPY, + DM_OUT_DEFAULT = DM_UPDATE; +// --- + +const GDI_ERROR = 0xFFFFFFFF; +const HGDI_ERROR= cast(HANDLE)GDI_ERROR; + +// TEXTMETRIC.tmPitchAndFamily +const BYTE + TMPF_FIXED_PITCH = 1, + TMPF_VECTOR = 2, + TMPF_TRUETYPE = 4, + TMPF_DEVICE = 8; + +// NEWTEXTMETRIC.ntmFlags +const DWORD + NTM_ITALIC = 0x00000001, + NTM_BOLD = 0x00000020, + NTM_REGULAR = 0x00000040, + NTM_NONNEGATIVE_AC = 0x00010000, + NTM_PS_OPENTYPE = 0x00020000, + NTM_TT_OPENTYPE = 0x00040000, + NTM_MULTIPLEMASTER = 0x00080000, + NTM_TYPE1 = 0x00100000, + NTM_DSIG = 0x00200000; + +// --- +const DWORD TT_POLYGON_TYPE = 24; + +// TTPOLYCURVE +enum : WORD { + TT_PRIM_LINE = 1, + TT_PRIM_QSPLINE = 2, + TT_PRIM_CSPLINE = 3, +} +// --- +const FONTMAPPER_MAX = 10; +const ENHMETA_STOCK_OBJECT = 0x80000000; +const WGL_FONT_LINES = 0; +const WGL_FONT_POLYGONS = 1; + +// --- +// LAYERPLANEDESCRIPTOR.dwFlags +const DWORD + LPD_DOUBLEBUFFER = 1, + LPD_STEREO = 2, + LPD_SUPPORT_GDI = 16, + LPD_SUPPORT_OPENGL = 32, + LPD_SHARE_DEPTH = 64, + LPD_SHARE_STENCIL = 128, + LPD_SHARE_ACCUM = 256, + LPD_SWAP_EXCHANGE = 512, + LPD_SWAP_COPY = 1024, + LPD_TRANSPARENT = 4096; + +// LAYERPLANEDESCRIPTOR.iPixelType +enum : BYTE { + LPD_TYPE_RGBA = 0, + LPD_TYPE_COLORINDEX = 1 +} + +// --- + +// wglSwapLayerBuffers() +const UINT + WGL_SWAP_MAIN_PLANE = 1, + WGL_SWAP_OVERLAY1 = 2, + WGL_SWAP_OVERLAY2 = 4, + WGL_SWAP_OVERLAY3 = 8, + WGL_SWAP_OVERLAY4 = 16, + WGL_SWAP_OVERLAY5 = 32, + WGL_SWAP_OVERLAY6 = 64, + WGL_SWAP_OVERLAY7 = 128, + WGL_SWAP_OVERLAY8 = 256, + WGL_SWAP_OVERLAY9 = 512, + WGL_SWAP_OVERLAY10 = 1024, + WGL_SWAP_OVERLAY11 = 2048, + WGL_SWAP_OVERLAY12 = 4096, + WGL_SWAP_OVERLAY13 = 8192, + WGL_SWAP_OVERLAY14 = 16384, + WGL_SWAP_OVERLAY15 = 32768, + WGL_SWAP_UNDERLAY1 = 65536, + WGL_SWAP_UNDERLAY2 = 0x20000, + WGL_SWAP_UNDERLAY3 = 0x40000, + WGL_SWAP_UNDERLAY4 = 0x80000, + WGL_SWAP_UNDERLAY5 = 0x100000, + WGL_SWAP_UNDERLAY6 = 0x200000, + WGL_SWAP_UNDERLAY7 = 0x400000, + WGL_SWAP_UNDERLAY8 = 0x800000, + WGL_SWAP_UNDERLAY9 = 0x1000000, + WGL_SWAP_UNDERLAY10 = 0x2000000, + WGL_SWAP_UNDERLAY11 = 0x4000000, + WGL_SWAP_UNDERLAY12 = 0x8000000, + WGL_SWAP_UNDERLAY13 = 0x10000000, + WGL_SWAP_UNDERLAY14 = 0x20000000, + WGL_SWAP_UNDERLAY15 = 0x40000000; + +const AC_SRC_OVER = 0x00; +const AC_SRC_ALPHA = 0x01; + +// ??? +const AC_SRC_NO_PREMULT_ALPHA = 0x01; +const AC_SRC_NO_ALPHA = 0x02; +const AC_DST_NO_PREMULT_ALPHA = 0x10; +const AC_DST_NO_ALPHA = 0x20; + +const LAYOUT_RTL = 1; +const LAYOUT_BTT = 2; +const LAYOUT_VBH = 4; +const LAYOUT_BITMAPORIENTATIONPRESERVED = 8; + +static if (WINVER > 0x0400) { + const CS_ENABLE = 0x00000001; + const CS_DISABLE = 0x00000002; + const CS_DELETE_TRANSFORM = 0x00000003; +} +static if (WINVER > 0x0500) { + const GRADIENT_FILL_RECT_H=0x00; + const GRADIENT_FILL_RECT_V=0x01; + const GRADIENT_FILL_TRIANGLE=0x02; + const GRADIENT_FILL_OP_FLAG=0xff; + const COLORMATCHTOTARGET_EMBEDED=0x00000001; + const CREATECOLORSPACE_EMBEDED=0x00000001; + const SETICMPROFILE_EMBEDED=0x00000001; +} + +// DISPLAY_DEVICE.StateFlags +const DWORD + DISPLAY_DEVICE_ATTACHED_TO_DESKTOP = 0x00000001, + DISPLAY_DEVICE_MULTI_DRIVER = 0x00000002, + DISPLAY_DEVICE_PRIMARY_DEVICE = 0x00000004, + DISPLAY_DEVICE_MIRRORING_DRIVER = 0x00000008, + DISPLAY_DEVICE_VGA_COMPATIBLE = 0x00000010, + DISPLAY_DEVICE_REMOVABLE = 0x00000020, + DISPLAY_DEVICE_DISCONNECT = 0x02000000, + DISPLAY_DEVICE_REMOTE = 0x04000000, + DISPLAY_DEVICE_MODESPRUNED = 0x08000000; + +/* Child device state */ +const DWORD + DISPLAY_DEVICE_ACTIVE = 0x00000001, + DISPLAY_DEVICE_ATTACHED = 0x00000002; + +static if (_WIN32_WINNT >= 0x0500) { + const GGI_MARK_NONEXISTING_GLYPHS = 1; +} + +// ---------- +// STRUCTS +// ---------- + +struct ABC { + int abcA; + UINT abcB; + int abcC; +} +alias ABC* PABC, NPABC, LPABC; + +struct ABCFLOAT { + FLOAT abcfA; + FLOAT abcfB; + FLOAT abcfC; +} +alias ABCFLOAT* PABCFLOAT, NPABCFLOAT, LPABCFLOAT; + +struct BITMAP { + LONG bmType; + LONG bmWidth; + LONG bmHeight; + LONG bmWidthBytes; + WORD bmPlanes; + WORD bmBitsPixel; + LPVOID bmBits; +} +alias BITMAP* PBITMAP, NPBITMAP, LPBITMAP; + +struct BITMAPCOREHEADER { + DWORD bcSize; + WORD bcWidth; + WORD bcHeight; + WORD bcPlanes; + WORD bcBitCount; +} +alias BITMAPCOREHEADER* PBITMAPCOREHEADER, LPBITMAPCOREHEADER; + +align(1): +struct RGBTRIPLE { + BYTE rgbtBlue; + BYTE rgbtGreen; + BYTE rgbtRed; +} +alias RGBTRIPLE* LPRGBTRIPLE; + +align(2): +struct BITMAPFILEHEADER { + WORD bfType; + DWORD bfSize; + WORD bfReserved1; + WORD bfReserved2; + DWORD bfOffBits; +} +alias BITMAPFILEHEADER* LPBITMAPFILEHEADER, PBITMAPFILEHEADER; + +align: + +struct BITMAPCOREINFO { + BITMAPCOREHEADER bmciHeader; + RGBTRIPLE[1] bmciColors; +} +alias BITMAPCOREINFO* LPBITMAPCOREINFO, PBITMAPCOREINFO; + +struct BITMAPINFOHEADER { + DWORD biSize; + LONG biWidth; + LONG biHeight; + WORD biPlanes; + WORD biBitCount; + DWORD biCompression; + DWORD biSizeImage; + LONG biXPelsPerMeter; + LONG biYPelsPerMeter; + DWORD biClrUsed; + DWORD biClrImportant; +} + +alias BITMAPINFOHEADER* LPBITMAPINFOHEADER, PBITMAPINFOHEADER; + +struct RGBQUAD { + BYTE rgbBlue; + BYTE rgbGreen; + BYTE rgbRed; + BYTE rgbReserved; +}; +alias RGBQUAD* LPRGBQUAD; + +struct BITMAPINFO { + BITMAPINFOHEADER bmiHeader; + RGBQUAD[1] bmiColors; +}; +alias BITMAPINFO* PBITMAPINFO, LPBITMAPINFO; + +alias int FXPT16DOT16; +alias int* LPFXPT16DOT16; +alias int FXPT2DOT30; +alias int* LPFXPT2DOT30; + +struct CIEXYZ { + FXPT2DOT30 ciexyzX; + FXPT2DOT30 ciexyzY; + FXPT2DOT30 ciexyzZ; +} +alias CIEXYZ* LPCIEXYZ; + +struct CIEXYZTRIPLE { + CIEXYZ ciexyzRed; + CIEXYZ ciexyzGreen; + CIEXYZ ciexyzBlue; +} +alias CIEXYZTRIPLE* LPCIEXYZTRIPLE; + +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; +} +alias BITMAPV4HEADER* LPBITMAPV4HEADER, 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; +} +alias BITMAPV5HEADER* LPBITMAPV5HEADER, PBITMAPV5HEADER; + +struct FONTSIGNATURE { + DWORD[4] fsUsb; + DWORD[2] fsCsb; +} +alias FONTSIGNATURE* PFONTSIGNATURE, LPFONTSIGNATURE; + +struct CHARSETINFO { + UINT ciCharset; + UINT ciACP; + FONTSIGNATURE fs; +} +alias CHARSETINFO* PCHARSETINFO, NPCHARSETINFO, LPCHARSETINFO; + +struct COLORADJUSTMENT { + WORD caSize; + WORD caFlags; + WORD caIlluminantIndex; + WORD caRedGamma; + WORD caGreenGamma; + WORD caBlueGamma; + WORD caReferenceBlack; + WORD caReferenceWhite; + SHORT caContrast; + SHORT caBrightness; + SHORT caColorfulness; + SHORT caRedGreenTint; +} +alias COLORADJUSTMENT* PCOLORADJUSTMENT, LPCOLORADJUSTMENT; + +struct DEVMODEA { + BYTE[CCHDEVICENAME] dmDeviceName; + WORD dmSpecVersion; + WORD dmDriverVersion; + WORD dmSize; + WORD dmDriverExtra; + DWORD dmFields; + union { + struct { + short dmOrientation; + short dmPaperSize; + short dmPaperLength; + short dmPaperWidth; + short dmScale; + short dmCopies; + short dmDefaultSource; + short dmPrintQuality; + } + POINTL dmPosition; + DWORD dmDisplayOrientation; + DWORD dmDisplayFixedOutput; + } + short dmColor; + short dmDuplex; + short dmYResolution; + short dmTTOption; + short dmCollate; + BYTE[CCHFORMNAME] dmFormName; + WORD dmLogPixels; + DWORD dmBitsPerPel; + DWORD dmPelsWidth; + DWORD dmPelsHeight; + union { + DWORD dmDisplayFlags; + DWORD dmNup; + } + DWORD dmDisplayFrequency; + static if (WINVER >= 0x0400) { + DWORD dmICMMethod; + DWORD dmICMIntent; + DWORD dmMediaType; + DWORD dmDitherType; + DWORD dmReserved1; + DWORD dmReserved2; + static if ((WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)) { + DWORD dmPanningWidth; + DWORD dmPanningHeight; + } + } +} +alias DEVMODEA* PDEVMODEA, NPDEVMODEA, LPDEVMODEA; + +struct DEVMODEW { + WCHAR[CCHDEVICENAME] dmDeviceName; + WORD dmSpecVersion; + WORD dmDriverVersion; + WORD dmSize; + WORD dmDriverExtra; + DWORD dmFields; + union { + struct { + short dmOrientation; + short dmPaperSize; + short dmPaperLength; + short dmPaperWidth; + short dmScale; + short dmCopies; + short dmDefaultSource; + short dmPrintQuality; + } + POINTL dmPosition; + DWORD dmDisplayOrientation; + DWORD dmDisplayFixedOutput; + } + + short dmColor; + short dmDuplex; + short dmYResolution; + short dmTTOption; + short dmCollate; + WCHAR[CCHFORMNAME] dmFormName; + WORD dmLogPixels; + DWORD dmBitsPerPel; + DWORD dmPelsWidth; + DWORD dmPelsHeight; + union { + DWORD dmDisplayFlags; + DWORD dmNup; + } + DWORD dmDisplayFrequency; + static if (WINVER >= 0x0400) { + DWORD dmICMMethod; + DWORD dmICMIntent; + DWORD dmMediaType; + DWORD dmDitherType; + DWORD dmReserved1; + DWORD dmReserved2; + static if ((WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)) { + DWORD dmPanningWidth; + DWORD dmPanningHeight; + } + } +} +alias DEVMODEW* PDEVMODEW, NPDEVMODEW, LPDEVMODEW; + +/* + * Information about output options + */ +struct PSFEATURE_OUTPUT { + BOOL bPageIndependent; + BOOL bSetPageDevice; +} +alias PSFEATURE_OUTPUT* PPSFEATURE_OUTPUT; + +/* + * Information about custom paper size + */ +struct PSFEATURE_CUSTPAPER { + LONG lOrientation; + LONG lWidth; + LONG lHeight; + LONG lWidthOffset; + LONG lHeightOffset; +} +alias PSFEATURE_CUSTPAPER* PPSFEATURE_CUSTPAPER; + +struct DIBSECTION { + BITMAP dsBm; + BITMAPINFOHEADER dsBmih; + DWORD[3] dsBitfields; + HANDLE dshSection; + DWORD dsOffset; +} +alias DIBSECTION* PDIBSECTION; + +struct DOCINFOA { + int cbSize = DOCINFOA.sizeof; + LPCSTR lpszDocName; + LPCSTR lpszOutput; + LPCSTR lpszDatatype; + DWORD fwType; +} +alias DOCINFOA* LPDOCINFOA; + +struct DOCINFOW { + int cbSize = DOCINFOW.sizeof; + LPCWSTR lpszDocName; + LPCWSTR lpszOutput; + LPCWSTR lpszDatatype; + DWORD fwType; +} +alias DOCINFOW* LPDOCINFOW; + + +struct PANOSE { + BYTE bFamilyType; + BYTE bSerifStyle; + BYTE bWeight; + BYTE bProportion; + BYTE bContrast; + BYTE bStrokeVariation; + BYTE bArmStyle; + BYTE bLetterform; + BYTE bMidline; + BYTE bXHeight; +} +alias PANOSE* LPPANOSE; + +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[LF_FACESIZE] lfFaceName; +} +alias LOGFONTA* PLOGFONTA, NPLOGFONTA, 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[LF_FACESIZE] lfFaceName; +} +alias LOGFONTW* PLOGFONTW, NPLOGFONTW, LPLOGFONTW; + +struct EXTLOGFONTA { + LOGFONTA elfLogFont; + BYTE[LF_FULLFACESIZE] elfFullName; + BYTE[LF_FACESIZE] elfStyle; + DWORD elfVersion; + DWORD elfStyleSize; + DWORD elfMatch; + DWORD elfReserved; + BYTE[ELF_VENDOR_SIZE] elfVendorId; + DWORD elfCulture; + PANOSE elfPanose; +} +alias EXTLOGFONTA* PEXTLOGFONTA, NPEXTLOGFONTA, LPEXTLOGFONTA; + +struct EXTLOGFONTW { + LOGFONTW elfLogFont; + WCHAR[LF_FULLFACESIZE] elfFullName; + WCHAR[LF_FACESIZE] elfStyle; + DWORD elfVersion; + DWORD elfStyleSize; + DWORD elfMatch; + DWORD elfReserved; + BYTE[ELF_VENDOR_SIZE] elfVendorId; + DWORD elfCulture; + PANOSE elfPanose; +} +alias EXTLOGFONTW* PEXTLOGFONTW, NPEXTLOGFONTW, LPEXTLOGFONTW; + +struct LOGPEN { + UINT lopnStyle; + POINT lopnWidth; + COLORREF lopnColor; +} +alias LOGPEN* PLOGPEN, NPLOGPEN, LPLOGPEN; + +// ---------------------- EMR ------------ + +struct EMR { + DWORD iType; + DWORD nSize; +} +alias EMR* PEMR; + +struct EMRANGLEARC { + EMR emr; + POINTL ptlCenter; + DWORD nRadius; + FLOAT eStartAngle; + FLOAT eSweepAngle; +} +alias EMRANGLEARC* PEMRANGLEARC; + +struct EMRARC { + EMR emr; + RECTL rclBox; + POINTL ptlStart; + POINTL ptlEnd; +} +alias EMRARC* PEMRARC; +typedef EMRARC EMRARCTO; +alias EMRARCTO* PEMRARCTO; +typedef EMRARC EMRCHORD; +alias EMRCHORD* PEMRCHORD; +typedef EMRARC EMRPIE; +alias EMRPIE* PEMRPIE; + +struct XFORM { + FLOAT eM11; + FLOAT eM12; + FLOAT eM21; + FLOAT eM22; + FLOAT eDx; + FLOAT eDy; +} +alias XFORM* PXFORM, LPXFORM; + +struct EMRBITBLT { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG cxDest; + LONG cyDest; + DWORD dwRop; + LONG xSrc; + LONG ySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; +} +alias EMRBITBLT* PEMRBITBLT; + +struct LOGBRUSH { + UINT lbStyle; + COLORREF lbColor; + LONG lbHatch; +} +typedef LOGBRUSH PATTERN; +alias LOGBRUSH* PLOGBRUSH, NPLOGBRUSH, LPLOGBRUSH; +alias PATTERN* PPATTERN, NPPATTERN, LPPATTERN; + +struct LOGBRUSH32 { + UINT lbStyle; + COLORREF lbColor; + ULONG lbHatch; +} +alias LOGBRUSH32* PLOGBRUSH32, NPLOGBRUSH32, LPLOGBRUSH32; + +struct EMRCREATEBRUSHINDIRECT { + EMR emr; + DWORD ihBrush; + LOGBRUSH32 lb; +} +alias EMRCREATEBRUSHINDIRECT* PEMRCREATEBRUSHINDIRECT; + +alias LONG LCSCSTYPE, LCSGAMUTMATCH; + +struct LOGCOLORSPACEA { + DWORD lcsSignature; + DWORD lcsVersion; + DWORD lcsSize; + LCSCSTYPE lcsCSType; + LCSGAMUTMATCH lcsIntent; + CIEXYZTRIPLE lcsEndpoints; + DWORD lcsGammaRed; + DWORD lcsGammaGreen; + DWORD lcsGammaBlue; + CHAR[MAX_PATH] lcsFilename; +} +alias LOGCOLORSPACEA* LPLOGCOLORSPACEA; + +struct LOGCOLORSPACEW { + DWORD lcsSignature; + DWORD lcsVersion; + DWORD lcsSize; + LCSCSTYPE lcsCSType; + LCSGAMUTMATCH lcsIntent; + CIEXYZTRIPLE lcsEndpoints; + DWORD lcsGammaRed; + DWORD lcsGammaGreen; + DWORD lcsGammaBlue; + WCHAR[MAX_PATH] lcsFilename; +} +alias LOGCOLORSPACEW* LPLOGCOLORSPACEW; + +alias USHORT COLOR16; +struct TRIVERTEX { + LONG x; + LONG y; + COLOR16 Red; + COLOR16 Green; + COLOR16 Blue; + COLOR16 Alpha; +} +alias TRIVERTEX* PTRIVERTEX, LPTRIVERTEX; + +static if (WINVER >= 0x0400) { + + struct EMRGLSRECORD { + EMR emr; + DWORD cbData; + BYTE[1] Data; + } + alias EMRGLSRECORD* PEMRGLSRECORD; + + struct EMRGLSBOUNDEDRECORD { + EMR emr; + RECTL rclBounds; + DWORD cbData; + BYTE[1] Data; + } + alias EMRGLSBOUNDEDRECORD* PEMRGLSBOUNDEDRECORD; + + struct EMRPIXELFORMAT { + EMR emr; + PIXELFORMATDESCRIPTOR pfd; + } + alias EMRPIXELFORMAT* PEMRPIXELFORMAT; + + struct EMRCREATECOLORSPACE { + EMR emr; + DWORD ihCS; + LOGCOLORSPACE lcs; + } + alias EMRCREATECOLORSPACE* PEMRCREATECOLORSPACE; + + struct EMRSETCOLORSPACE { + EMR emr; + DWORD ihCS; + } + alias EMRSETCOLORSPACE* PEMRSETCOLORSPACE; + typedef EMRSETCOLORSPACE EMRSELECTCOLORSPACE; + alias EMRSELECTCOLORSPACE* PEMRSELECTCOLORSPACE; + typedef EMRSETCOLORSPACE EMRDELETECOLORSPACE; + alias EMRDELETECOLORSPACE* PEMRDELETECOLORSPACE; +} + +static if (WINVER >= 0x0500) { + + struct EMREXTESCAPE { + EMR emr; + INT iEscape; + INT cbEscData; + BYTE[1] EscData; + } + alias EMREXTESCAPE* PEMREXTESCAPE; + typedef EMREXTESCAPE EMRDRAWESCAPE; + alias EMRDRAWESCAPE* PEMRDRAWESCAPE; + + struct EMRNAMEDESCAPE { + EMR emr; + INT iEscape; + INT cbDriver; + INT cbEscData; + BYTE[1] EscData; + } + alias EMRNAMEDESCAPE* PEMRNAMEDESCAPE; + + struct EMRSETICMPROFILE { + EMR emr; + DWORD dwFlags; + DWORD cbName; + DWORD cbData; + BYTE[1] Data; + } + alias EMRSETICMPROFILE* PEMRSETICMPROFILE; + typedef EMRSETICMPROFILE EMRSETICMPROFILEA; + alias EMRSETICMPROFILEA* PEMRSETICMPROFILEA; + typedef EMRSETICMPROFILE EMRSETICMPROFILEW; + alias EMRSETICMPROFILEW* PEMRSETICMPROFILEW; + + struct EMRCREATECOLORSPACEW { + EMR emr; + DWORD ihCS; + LOGCOLORSPACEW lcs; + DWORD dwFlags; + DWORD cbData; + BYTE[1] Data; + } + alias EMRCREATECOLORSPACEW* PEMRCREATECOLORSPACEW; + + struct EMRCOLORMATCHTOTARGET { + EMR emr; + DWORD dwAction; + DWORD dwFlags; + DWORD cbName; + DWORD cbData; + BYTE[1] Data; + } + alias EMRCOLORMATCHTOTARGET* PEMRCOLORMATCHTOTARGET; + + struct EMRCOLORCORRECTPALETTE { + EMR emr; + DWORD ihPalette; + DWORD nFirstEntry; + DWORD nPalEntries; + DWORD nReserved; + } + alias EMRCOLORCORRECTPALETTE* PEMRCOLORCORRECTPALETTE; + + struct EMRALPHABLEND { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG cxDest; + LONG cyDest; + DWORD dwRop; + LONG xSrc; + LONG ySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + LONG cxSrc; + LONG cySrc; + } + alias EMRALPHABLEND* PEMRALPHABLEND; + + struct EMRGRADIENTFILL { + EMR emr; + RECTL rclBounds; + DWORD nVer; + DWORD nTri; + ULONG ulMode; + TRIVERTEX[1] Ver; + } + alias EMRGRADIENTFILL* PEMRGRADIENTFILL; + + struct EMRTRANSPARENTBLT { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG cxDest; + LONG cyDest; + DWORD dwRop; + LONG xSrc; + LONG ySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + LONG cxSrc; + LONG cySrc; + } + alias EMRTRANSPARENTBLT* PEMRTRANSPARENTBLT; +} + +struct EMRCREATEDIBPATTERNBRUSHPT { + EMR emr; + DWORD ihBrush; + DWORD iUsage; + DWORD offBmi; + DWORD cbBmi; + DWORD offBits; + DWORD cbBits; +} +alias EMRCREATEDIBPATTERNBRUSHPT* PEMRCREATEDIBPATTERNBRUSHPT; + +struct EMRCREATEMONOBRUSH { + EMR emr; + DWORD ihBrush; + DWORD iUsage; + DWORD offBmi; + DWORD cbBmi; + DWORD offBits; + DWORD cbBits; +} +alias EMRCREATEMONOBRUSH* PEMRCREATEMONOBRUSH; + +struct PALETTEENTRY { + BYTE peRed; + BYTE peGreen; + BYTE peBlue; + BYTE peFlags; +} +alias PALETTEENTRY* PPALETTEENTRY, LPPALETTEENTRY; + +struct LOGPALETTE { + WORD palVersion; + WORD palNumEntries; + PALETTEENTRY[1] palPalEntry; +} +alias LOGPALETTE* PLOGPALETTE, NPLOGPALETTE, LPLOGPALETTE; + +struct EMRCREATEPALETTE { + EMR emr; + DWORD ihPal; + LOGPALETTE lgpl; +} +alias EMRCREATEPALETTE* PEMRCREATEPALETTE; + +struct EMRCREATEPEN { + EMR emr; + DWORD ihPen; + LOGPEN lopn; +} +alias EMRCREATEPEN* PEMRCREATEPEN; + +struct EMRELLIPSE { + EMR emr; + RECTL rclBox; +} +alias EMRELLIPSE* PEMRELLIPSE; + +typedef EMRELLIPSE EMRRECTANGLE; +alias EMRRECTANGLE* PEMRRECTANGLE; + +struct EMREOF { + EMR emr; + DWORD nPalEntries; + DWORD offPalEntries; + DWORD nSizeLast; +} +alias EMREOF* PEMREOF; + +struct EMREXCLUDECLIPRECT { + EMR emr; + RECTL rclClip; +} +alias EMREXCLUDECLIPRECT* PEMREXCLUDECLIPRECT; +typedef EMREXCLUDECLIPRECT EMRINTERSECTCLIPRECT; +alias EMRINTERSECTCLIPRECT* PEMRINTERSECTCLIPRECT; + +struct EMREXTCREATEFONTINDIRECTW { + EMR emr; + DWORD ihFont; + EXTLOGFONTW elfw; +} +alias EMREXTCREATEFONTINDIRECTW* PEMREXTCREATEFONTINDIRECTW; + +struct EXTLOGPEN { + UINT elpPenStyle; + UINT elpWidth; + UINT elpBrushStyle; + COLORREF elpColor; + LONG elpHatch; + DWORD elpNumEntries; + DWORD[1] elpStyleEntry; +} +alias EXTLOGPEN* PEXTLOGPEN, NPEXTLOGPEN, LPEXTLOGPEN; + +struct EMREXTCREATEPEN { + EMR emr; + DWORD ihPen; + DWORD offBmi; + DWORD cbBmi; + DWORD offBits; + DWORD cbBits; + EXTLOGPEN elp; +} +alias EMREXTCREATEPEN* PEMREXTCREATEPEN; + +struct EMREXTFLOODFILL { + EMR emr; + POINTL ptlStart; + COLORREF crColor; + DWORD iMode; +} +alias EMREXTFLOODFILL* PEMREXTFLOODFILL; + +struct EMREXTSELECTCLIPRGN { + EMR emr; + DWORD cbRgnData; + DWORD iMode; + BYTE [1]RgnData; +} +alias EMREXTSELECTCLIPRGN* PEMREXTSELECTCLIPRGN; + +struct EMRTEXT { + POINTL ptlReference; + DWORD nChars; + DWORD offString; + DWORD fOptions; + RECTL rcl; + DWORD offDx; +} +alias EMRTEXT* PEMRTEXT; + +struct EMREXTTEXTOUTA { + EMR emr; + RECTL rclBounds; + DWORD iGraphicsMode; + FLOAT exScale; + FLOAT eyScale; + EMRTEXT emrtext; +} +alias EMREXTTEXTOUTA* PEMREXTTEXTOUTA; +typedef EMREXTTEXTOUTA EMREXTTEXTOUTW; +alias EMREXTTEXTOUTW* PEMREXTTEXTOUTW; + +struct EMRFILLPATH { + EMR emr; + RECTL rclBounds; +} +alias EMRFILLPATH* PEMRFILLPATH; + +typedef EMRFILLPATH EMRSTROKEANDFILLPATH; +alias EMRSTROKEANDFILLPATH* PEMRSTROKEANDFILLPATH; + +typedef EMRFILLPATH EMRSTROKEPATH; +alias EMRSTROKEPATH* PEMRSTROKEPATH; + +struct EMRFILLRGN { + EMR emr; + RECTL rclBounds; + DWORD cbRgnData; + DWORD ihBrush; + BYTE[1] RgnData; +} +alias EMRFILLRGN* PEMRFILLRGN; + +struct EMRFORMAT { + DWORD dSignature; + DWORD nVersion; + DWORD cbData; + DWORD offData; +} +alias EMRFORMAT* PEMRFORMAT; + +struct EMRFRAMERGN { + EMR emr; + RECTL rclBounds; + DWORD cbRgnData; + DWORD ihBrush; + SIZEL szlStroke; + BYTE[1] RgnData; +} +alias EMRFRAMERGN* PEMRFRAMERGN; + +struct EMRGDICOMMENT { + EMR emr; + DWORD cbData; + BYTE[1] Data; +} +alias EMRGDICOMMENT* PEMRGDICOMMENT; + +struct EMRINVERTRGN { + EMR emr; + RECTL rclBounds; + DWORD cbRgnData; + BYTE[1] RgnData; +} +alias EMRINVERTRGN* PEMRINVERTRGN; +typedef EMRINVERTRGN EMRPAINTRGN; +alias EMRPAINTRGN* PEMRPAINTRGN; + +struct EMRLINETO { + EMR emr; + POINTL ptl; +} +alias EMRLINETO* PEMRLINETO; +typedef EMRLINETO EMRMOVETOEX; +alias EMRMOVETOEX* PEMRMOVETOEX; + +struct EMRMASKBLT { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG cxDest; + LONG cyDest; + DWORD dwRop; + LONG xSrc; + LONG ySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + LONG xMask; + LONG yMask; + DWORD iUsageMask; + DWORD offBmiMask; + DWORD cbBmiMask; + DWORD offBitsMask; + DWORD cbBitsMask; +} +alias EMRMASKBLT* PEMRMASKBLT; + +struct EMRMODIFYWORLDTRANSFORM { + EMR emr; + XFORM xform; + DWORD iMode; +} +alias EMRMODIFYWORLDTRANSFORM* PEMRMODIFYWORLDTRANSFORM; + +struct EMROFFSETCLIPRGN { + EMR emr; + POINTL ptlOffset; +} +alias EMROFFSETCLIPRGN* PEMROFFSETCLIPRGN; + +struct EMRPLGBLT { + EMR emr; + RECTL rclBounds; + POINTL[3] aptlDest; + LONG xSrc; + LONG ySrc; + LONG cxSrc; + LONG cySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + LONG xMask; + LONG yMask; + DWORD iUsageMask; + DWORD offBmiMask; + DWORD cbBmiMask; + DWORD offBitsMask; + DWORD cbBitsMask; +} +alias EMRPLGBLT* PEMRPLGBLT; + +struct EMRPOLYDRAW { + EMR emr; + RECTL rclBounds; + DWORD cptl; + POINTL[1] aptl; + BYTE[1] abTypes; +} +alias EMRPOLYDRAW* PEMRPOLYDRAW; + +struct EMRPOLYDRAW16 { + EMR emr; + RECTL rclBounds; + DWORD cpts; + POINTS[1] apts; + BYTE[1] abTypes; +} +alias EMRPOLYDRAW16* PEMRPOLYDRAW16; + +struct EMRPOLYLINE { + EMR emr; + RECTL rclBounds; + DWORD cptl; + POINTL[1] aptl; +} +alias EMRPOLYLINE* PEMRPOLYLINE; +typedef EMRPOLYLINE EMRPOLYBEZIER; +alias EMRPOLYBEZIER* PEMRPOLYBEZIER; +typedef EMRPOLYLINE EMRPOLYGON; +alias EMRPOLYGON* PEMRPOLYGON; +typedef EMRPOLYLINE EMRPOLYBEZIERTO; +alias EMRPOLYBEZIERTO* PEMRPOLYBEZIERTO; +typedef EMRPOLYLINE EMRPOLYLINETO; +alias EMRPOLYLINETO* PEMRPOLYLINETO; + +struct EMRPOLYLINE16 { + EMR emr; + RECTL rclBounds; + DWORD cpts; + POINTS[1] apts; +} +alias EMRPOLYLINE16* PEMRPOLYLINE16; +typedef EMRPOLYLINE16 EMRPOLYBEZIER16; +alias EMRPOLYBEZIER16* PEMRPOLYBEZIER16; +typedef EMRPOLYLINE16 EMRPOLYGON16; +alias EMRPOLYGON16* PEMRPOLYGON16; +typedef EMRPOLYLINE16 EMRPOLYBEZIERTO16; +alias EMRPOLYBEZIERTO16* PEMRPOLYBEZIERTO16; +typedef EMRPOLYLINE16 EMRPOLYLINETO16; +alias EMRPOLYLINETO16* PEMRPOLYLINETO16; + +struct EMRPOLYPOLYLINE { + EMR emr; + RECTL rclBounds; + DWORD nPolys; + DWORD cptl; + DWORD[1] aPolyCounts; + POINTL[1] aptl; +} +alias EMRPOLYPOLYLINE* PEMRPOLYPOLYLINE; +typedef EMRPOLYPOLYLINE EMRPOLYPOLYGON; +alias EMRPOLYPOLYGON* PEMRPOLYPOLYGON; + +struct EMRPOLYPOLYLINE16 { + EMR emr; + RECTL rclBounds; + DWORD nPolys; + DWORD cpts; + DWORD[1] aPolyCounts; + POINTS[1] apts; +} +alias EMRPOLYPOLYLINE16* PEMRPOLYPOLYLINE16; +typedef EMRPOLYPOLYLINE16 EMRPOLYPOLYGON16; +alias EMRPOLYPOLYGON16* PEMRPOLYPOLYGON16; + +struct EMRPOLYTEXTOUTA { + EMR emr; + RECTL rclBounds; + DWORD iGraphicsMode; + FLOAT exScale; + FLOAT eyScale; + LONG cStrings; + EMRTEXT[1] aemrtext; +} +alias EMRPOLYTEXTOUTA* PEMRPOLYTEXTOUTA; +typedef EMRPOLYTEXTOUTA EMRPOLYTEXTOUTW; +alias EMRPOLYTEXTOUTW* PEMRPOLYTEXTOUTW; + +struct EMRRESIZEPALETTE { + EMR emr; + DWORD ihPal; + DWORD cEntries; +} +alias EMRRESIZEPALETTE* PEMRRESIZEPALETTE; + +struct EMRRESTOREDC { + EMR emr; + LONG iRelative; +} +alias EMRRESTOREDC* PEMRRESTOREDC; + +struct EMRROUNDRECT { + EMR emr; + RECTL rclBox; + SIZEL szlCorner; +} +alias EMRROUNDRECT* PEMRROUNDRECT; + +struct EMRSCALEVIEWPORTEXTEX { + EMR emr; + LONG xNum; + LONG xDenom; + LONG yNum; + LONG yDenom; +} +alias EMRSCALEVIEWPORTEXTEX* PEMRSCALEVIEWPORTEXTEX; +typedef EMRSCALEVIEWPORTEXTEX EMRSCALEWINDOWEXTEX; +alias EMRSCALEWINDOWEXTEX* PEMRSCALEWINDOWEXTEX; + +struct EMRSELECTOBJECT { + EMR emr; + DWORD ihObject; +} +alias EMRSELECTOBJECT* PEMRSELECTOBJECT; +typedef EMRSELECTOBJECT EMRDELETEOBJECT; +alias EMRDELETEOBJECT* PEMRDELETEOBJECT; + +struct EMRSELECTPALETTE { + EMR emr; + DWORD ihPal; +} +alias EMRSELECTPALETTE* PEMRSELECTPALETTE; + +struct EMRSETARCDIRECTION { + EMR emr; + DWORD iArcDirection; +} +alias EMRSETARCDIRECTION* PEMRSETARCDIRECTION; + +struct EMRSETTEXTCOLOR { + EMR emr; + COLORREF crColor; +} +alias EMRSETTEXTCOLOR* PEMRSETTEXTCOLOR; +typedef EMRSETTEXTCOLOR EMRSETBKCOLOR; +alias EMRSETBKCOLOR* PEMRSETBKCOLOR; + +struct EMRSETCOLORADJUSTMENT { + EMR emr; + COLORADJUSTMENT ColorAdjustment; +} +alias EMRSETCOLORADJUSTMENT* PEMRSETCOLORADJUSTMENT; + +struct EMRSETDIBITSTODEVICE { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG xSrc; + LONG ySrc; + LONG cxSrc; + LONG cySrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + DWORD iUsageSrc; + DWORD iStartScan; + DWORD cScans; +} +alias EMRSETDIBITSTODEVICE* PEMRSETDIBITSTODEVICE; + +struct EMRSETMAPPERFLAGS { + EMR emr; + DWORD dwFlags; +} +alias EMRSETMAPPERFLAGS* PEMRSETMAPPERFLAGS; + +struct EMRSETMITERLIMIT { + EMR emr; + FLOAT eMiterLimit; +} +alias EMRSETMITERLIMIT* PEMRSETMITERLIMIT; + +struct EMRSETPALETTEENTRIES { + EMR emr; + DWORD ihPal; + DWORD iStart; + DWORD cEntries; + PALETTEENTRY[1] aPalEntries; +} +alias EMRSETPALETTEENTRIES* PEMRSETPALETTEENTRIES; + +struct EMRSETPIXELV { + EMR emr; + POINTL ptlPixel; + COLORREF crColor; +} +alias EMRSETPIXELV* PEMRSETPIXELV; + +struct EMRSETVIEWPORTEXTEX { + EMR emr; + SIZEL szlExtent; +} +alias EMRSETVIEWPORTEXTEX* PEMRSETVIEWPORTEXTEX; +typedef EMRSETVIEWPORTEXTEX EMRSETWINDOWEXTEX; +alias EMRSETWINDOWEXTEX* PEMRSETWINDOWEXTEX; + +struct EMRSETVIEWPORTORGEX { + EMR emr; + POINTL ptlOrigin; +} +alias EMRSETVIEWPORTORGEX* PEMRSETVIEWPORTORGEX; +typedef EMRSETVIEWPORTORGEX EMRSETWINDOWORGEX; +alias EMRSETWINDOWORGEX* PEMRSETWINDOWORGEX; +typedef EMRSETVIEWPORTORGEX EMRSETBRUSHORGEX; +alias EMRSETBRUSHORGEX* PEMRSETBRUSHORGEX; + +struct EMRSETWORLDTRANSFORM { + EMR emr; + XFORM xform; +} +alias EMRSETWORLDTRANSFORM* PEMRSETWORLDTRANSFORM; + +struct EMRSTRETCHBLT { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG cxDest; + LONG cyDest; + DWORD dwRop; + LONG xSrc; + LONG ySrc; + XFORM xformSrc; + COLORREF crBkColorSrc; + DWORD iUsageSrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + LONG cxSrc; + LONG cySrc; +} +alias EMRSTRETCHBLT* PEMRSTRETCHBLT; + +struct EMRSTRETCHDIBITS { + EMR emr; + RECTL rclBounds; + LONG xDest; + LONG yDest; + LONG xSrc; + LONG ySrc; + LONG cxSrc; + LONG cySrc; + DWORD offBmiSrc; + DWORD cbBmiSrc; + DWORD offBitsSrc; + DWORD cbBitsSrc; + DWORD iUsageSrc; + DWORD dwRop; + LONG cxDest; + LONG cyDest; +} +alias EMRSTRETCHDIBITS* PEMRSTRETCHDIBITS; + +struct EMRABORTPATH { + EMR emr; +} +alias EMRABORTPATH* PEMRABORTPATH; +typedef EMRABORTPATH EMRBEGINPATH; +alias EMRBEGINPATH* PEMRBEGINPATH; +typedef EMRABORTPATH EMRENDPATH; +alias EMRENDPATH* PEMRENDPATH; +typedef EMRABORTPATH EMRCLOSEFIGURE; +alias EMRCLOSEFIGURE* PEMRCLOSEFIGURE; +typedef EMRABORTPATH EMRFLATTENPATH; +alias EMRFLATTENPATH* PEMRFLATTENPATH; +typedef EMRABORTPATH EMRWIDENPATH; +alias EMRWIDENPATH* PEMRWIDENPATH; +typedef EMRABORTPATH EMRSETMETARGN; +alias EMRSETMETARGN* PEMRSETMETARGN; +typedef EMRABORTPATH EMRSAVEDC; +alias EMRSAVEDC* PEMRSAVEDC; +typedef EMRABORTPATH EMRREALIZEPALETTE; +alias EMRREALIZEPALETTE* PEMRREALIZEPALETTE; + +struct EMRSELECTCLIPPATH { + EMR emr; + DWORD iMode; +} +alias EMRSELECTCLIPPATH* PEMRSELECTCLIPPATH; +typedef EMRSELECTCLIPPATH EMRSETBKMODE; +alias EMRSETBKMODE* PEMRSETBKMODE; +typedef EMRSELECTCLIPPATH EMRSETMAPMODE; +alias EMRSETMAPMODE* PEMRSETMAPMODE; +typedef EMRSELECTCLIPPATH EMRSETPOLYFILLMODE; +alias EMRSETPOLYFILLMODE* PEMRSETPOLYFILLMODE; +typedef EMRSELECTCLIPPATH EMRSETROP2; +alias EMRSETROP2* PEMRSETROP2; +typedef EMRSELECTCLIPPATH EMRSETSTRETCHBLTMODE; +alias EMRSETSTRETCHBLTMODE* PEMRSETSTRETCHBLTMODE; +typedef EMRSELECTCLIPPATH EMRSETICMMODE; +alias EMRSETICMMODE* PEMRSETICMMODE; +typedef EMRSELECTCLIPPATH EMRSETTEXTALIGN; +alias EMRSETTEXTALIGN* PEMRSETTEXTALIGN; +typedef EMRSELECTCLIPPATH EMRENABLEICM; +alias EMRENABLEICM* PEMRENABLEICM; +static if (WINVER >= 0x0500) { + typedef EMRSELECTCLIPPATH EMRSETLAYOUT; + alias EMRSETLAYOUT* PEMRSETLAYOUT; +} + +align(2): +struct METAHEADER { + WORD mtType; + WORD mtHeaderSize; + WORD mtVersion; + DWORD mtSize; + WORD mtNoObjects; + DWORD mtMaxRecord; + WORD mtNoParameters; +} +alias METAHEADER* PMETAHEADER; +alias METAHEADER* LPMETAHEADER; + +align: + +struct ENHMETAHEADER { + DWORD iType; + DWORD nSize; + RECTL rclBounds; + RECTL rclFrame; + DWORD dSignature = ENHMETA_SIGNATURE; + DWORD nVersion; + DWORD nBytes; + DWORD nRecords; + WORD nHandles; + WORD sReserved; + DWORD nDescription; + DWORD offDescription; + DWORD nPalEntries; + SIZEL szlDevice; + SIZEL szlMillimeters; + static if (WINVER >= 0x0400) { + DWORD cbPixelFormat; + DWORD offPixelFormat; + DWORD bOpenGL; + } + static if (WINVER >= 0x0500) { + SIZEL szlMicrometers; + } +} +alias ENHMETAHEADER* PENHMETAHEADER, LPENHMETAHEADER; + +struct METARECORD { + DWORD rdSize; + WORD rdFunction; + WORD[1] rdParm; +} +alias METARECORD* PMETARECORD; +alias METARECORD* LPMETARECORD; + +struct ENHMETARECORD { + DWORD iType; + DWORD nSize; + DWORD[1] dParm; +} +alias ENHMETARECORD* PENHMETARECORD, LPENHMETARECORD; + +// --- + +struct HANDLETABLE { + HGDIOBJ[1] objectHandle; +} +alias HANDLETABLE* PHANDLETABLE, LPHANDLETABLE; + +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; +} +alias TEXTMETRICA* PTEXTMETRICA, NPTEXTMETRICA, LPTEXTMETRICA; + +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; +} +alias TEXTMETRICW* PTEXTMETRICW, NPTEXTMETRICW, LPTEXTMETRICW; + +struct RGNDATAHEADER { + DWORD dwSize; + DWORD iType; + DWORD nCount; + DWORD nRgnSize; + RECT rcBound; +} +alias RGNDATAHEADER* PRGNDATAHEADER; + +struct RGNDATA { + RGNDATAHEADER rdh; + char[1] Buffer; +} +alias RGNDATA* PRGNDATA, NPRGNDATA, LPRGNDATA; + +/* for GetRandomRgn */ +const SYSRGN=4; +struct GCP_RESULTSA { + DWORD lStructSize; + LPSTR lpOutString; + UINT* lpOrder; + INT* lpDx; + INT* lpCaretPos; + LPSTR lpClass; + LPWSTR lpGlyphs; + UINT nGlyphs; + UINT nMaxFit; +} +alias GCP_RESULTSA* LPGCP_RESULTSA; + +struct GCP_RESULTSW { + DWORD lStructSize; + LPWSTR lpOutString; + UINT* lpOrder; + INT* lpDx; + INT* lpCaretPos; + LPWSTR lpClass; + LPWSTR lpGlyphs; + UINT nGlyphs; + UINT nMaxFit; +} +alias GCP_RESULTSW* LPGCP_RESULTSW; + +struct GLYPHMETRICS { + UINT gmBlackBoxX; + UINT gmBlackBoxY; + POINT gmptGlyphOrigin; + short gmCellIncX; + short gmCellIncY; +} +alias GLYPHMETRICS* LPGLYPHMETRICS; + +static if (_WIN32_WINNT >= 0x0500) { + struct WCRANGE { + WCHAR wcLow; + USHORT cGlyphs; + } + alias WCRANGE* PWCRANGE, LPWCRANGE; + + struct GLYPHSET { + DWORD cbThis; + DWORD flAccel; + DWORD cGlyphsSupported; + DWORD cRanges; + WCRANGE[1] ranges; + } + alias GLYPHSET* PGLYPHSET, LPGLYPHSET; + + const DWORD GS_8BIT_INDICES = 0x00000001; +} + +struct KERNINGPAIR { + WORD wFirst; + WORD wSecond; + int iKernAmount; +} +alias KERNINGPAIR* LPKERNINGPAIR; + +struct FIXED { + WORD fract; + short value; +} + +struct MAT2 { + FIXED eM11; + FIXED eM12; + FIXED eM21; + FIXED eM22; +} +alias MAT2* LPMAT2; + +struct OUTLINETEXTMETRICA { + UINT otmSize; + TEXTMETRICA otmTextMetrics; + BYTE otmFiller; + PANOSE otmPanoseNumber; + UINT otmfsSelection; + UINT otmfsType; + int otmsCharSlopeRise; + int otmsCharSlopeRun; + int otmItalicAngle; + UINT otmEMSquare; + int otmAscent; + int otmDescent; + UINT otmLineGap; + UINT otmsCapEmHeight; + UINT otmsXHeight; + RECT otmrcFontBox; + int otmMacAscent; + int otmMacDescent; + UINT otmMacLineGap; + UINT otmusMinimumPPEM; + POINT otmptSubscriptSize; + POINT otmptSubscriptOffset; + POINT otmptSuperscriptSize; + POINT otmptSuperscriptOffset; + UINT otmsStrikeoutSize; + int otmsStrikeoutPosition; + int otmsUnderscoreSize; + int otmsUnderscorePosition; + PSTR otmpFamilyName; + PSTR otmpFaceName; + PSTR otmpStyleName; + PSTR otmpFullName; +} +alias OUTLINETEXTMETRICA* POUTLINETEXTMETRICA, NPOUTLINETEXTMETRICA, LPOUTLINETEXTMETRICA; + +struct OUTLINETEXTMETRICW { + UINT otmSize; + TEXTMETRICW otmTextMetrics; + BYTE otmFiller; + PANOSE otmPanoseNumber; + UINT otmfsSelection; + UINT otmfsType; + int otmsCharSlopeRise; + int otmsCharSlopeRun; + int otmItalicAngle; + UINT otmEMSquare; + int otmAscent; + int otmDescent; + UINT otmLineGap; + UINT otmsCapEmHeight; + UINT otmsXHeight; + RECT otmrcFontBox; + int otmMacAscent; + int otmMacDescent; + UINT otmMacLineGap; + UINT otmusMinimumPPEM; + POINT otmptSubscriptSize; + POINT otmptSubscriptOffset; + POINT otmptSuperscriptSize; + POINT otmptSuperscriptOffset; + UINT otmsStrikeoutSize; + int otmsStrikeoutPosition; + int otmsUnderscoreSize; + int otmsUnderscorePosition; + PSTR otmpFamilyName; + PSTR otmpFaceName; + PSTR otmpStyleName; + PSTR otmpFullName; +} +alias OUTLINETEXTMETRICW* POUTLINETEXTMETRICW, NPOUTLINETEXTMETRICW, LPOUTLINETEXTMETRICW; + +struct RASTERIZER_STATUS { + short nSize; + short wFlags; + short nLanguageID; +} +alias RASTERIZER_STATUS* LPRASTERIZER_STATUS; + +struct POLYTEXTA { + int x; + int y; + UINT n; + LPCSTR lpstr; + UINT uiFlags; + RECT rcl; + int* pdx; +} +alias POLYTEXTA* PPOLYTEXTA, NPPOLYTEXTA, LPPOLYTEXTA; + +struct POLYTEXTW { + int x; + int y; + UINT n; + LPCWSTR lpstr; + UINT uiFlags; + RECT rcl; + int* pdx; +} +alias POLYTEXTW* PPOLYTEXTW, NPPOLYTEXTW, LPPOLYTEXTW; + +struct PIXELFORMATDESCRIPTOR { + WORD nSize; + WORD nVersion; + DWORD dwFlags; + BYTE iPixelType; + BYTE cColorBits; + BYTE cRedBits; + BYTE cRedShift; + BYTE cGreenBits; + BYTE cGreenShift; + BYTE cBlueBits; + BYTE cBlueShift; + BYTE cAlphaBits; + BYTE cAlphaShift; + BYTE cAccumBits; + BYTE cAccumRedBits; + BYTE cAccumGreenBits; + BYTE cAccumBlueBits; + BYTE cAccumAlphaBits; + BYTE cDepthBits; + BYTE cStencilBits; + BYTE cAuxBuffers; + BYTE iLayerType; + BYTE bReserved; + DWORD dwLayerMask; + DWORD dwVisibleMask; + DWORD dwDamageMask; +} +alias PIXELFORMATDESCRIPTOR* PPIXELFORMATDESCRIPTOR, LPPIXELFORMATDESCRIPTOR; + +struct METAFILEPICT { + LONG mm; + LONG xExt; + LONG yExt; + HMETAFILE hMF; +} +alias METAFILEPICT* LPMETAFILEPICT; + +struct LOCALESIGNATURE { + DWORD[4] lsUsb; + DWORD[2] lsCsbDefault; + DWORD[2] lsCsbSupported; +} +alias LOCALESIGNATURE* PLOCALESIGNATURE, LPLOCALESIGNATURE; + +alias LONG LCSTYPE; /* What this for? */ + +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; +} +alias NEWTEXTMETRICA* PNEWTEXTMETRICA, NPNEWTEXTMETRICA, 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; +} +alias NEWTEXTMETRICW* PNEWTEXTMETRICW, NPNEWTEXTMETRICW, LPNEWTEXTMETRICW; + +align: +struct NEWTEXTMETRICEXA { + NEWTEXTMETRICA ntmTm; + FONTSIGNATURE ntmFontSig; +} + +struct NEWTEXTMETRICEXW { + NEWTEXTMETRICW ntmTm; + FONTSIGNATURE ntmFontSig; +} + +struct PELARRAY { + LONG paXCount; + LONG paYCount; + LONG paXExt; + LONG paYExt; + BYTE paRGBs; +} +alias PELARRAY* PPELARRAY, NPPELARRAY, LPPELARRAY; + +struct ENUMLOGFONTA { + LOGFONTA elfLogFont; + BYTE[LF_FULLFACESIZE] elfFullName; + BYTE[LF_FACESIZE] elfStyle; +} +alias ENUMLOGFONTA* LPENUMLOGFONTA; + +struct ENUMLOGFONTW { + LOGFONTW elfLogFont; + WCHAR[LF_FULLFACESIZE] elfFullName; + WCHAR[LF_FACESIZE] elfStyle; +} +alias ENUMLOGFONTW* LPENUMLOGFONTW; + +struct ENUMLOGFONTEXA { + LOGFONTA elfLogFont; + BYTE[LF_FULLFACESIZE] elfFullName; + BYTE[LF_FACESIZE] elfStyle; + BYTE[LF_FACESIZE] elfScript; +} +alias ENUMLOGFONTEXA* LPENUMLOGFONTEXA; + +struct ENUMLOGFONTEXW { + LOGFONTW elfLogFont; + WCHAR[LF_FULLFACESIZE] elfFullName; + WCHAR[LF_FACESIZE] elfStyle; + WCHAR[LF_FACESIZE] elfScript; +} +alias ENUMLOGFONTEXW* LPENUMLOGFONTEXW; + +struct POINTFX { + FIXED x; + FIXED y; +} +alias POINTFX* LPPOINTFX; + +struct TTPOLYCURVE { + WORD wType; + WORD cpfx; + POINTFX[1] apfx; +} +alias TTPOLYCURVE* LPTTPOLYCURVE; + +struct TTPOLYGONHEADER { + DWORD cb; + DWORD dwType; + POINTFX pfxStart; +} +alias TTPOLYGONHEADER* LPTTPOLYGONHEADER; + +struct POINTFLOAT { + FLOAT x; + FLOAT y; +} +alias POINTFLOAT* PPOINTFLOAT; + +struct GLYPHMETRICSFLOAT { + FLOAT gmfBlackBoxX; + FLOAT gmfBlackBoxY; + POINTFLOAT gmfptGlyphOrigin; + FLOAT gmfCellIncX; + FLOAT gmfCellIncY; +} +alias GLYPHMETRICSFLOAT* PGLYPHMETRICSFLOAT, LPGLYPHMETRICSFLOAT; + +struct LAYERPLANEDESCRIPTOR { + WORD nSize; + WORD nVersion; + DWORD dwFlags; + BYTE iPixelType; + BYTE cColorBits; + BYTE cRedBits; + BYTE cRedShift; + BYTE cGreenBits; + BYTE cGreenShift; + BYTE cBlueBits; + BYTE cBlueShift; + BYTE cAlphaBits; + BYTE cAlphaShift; + BYTE cAccumBits; + BYTE cAccumRedBits; + BYTE cAccumGreenBits; + BYTE cAccumBlueBits; + BYTE cAccumAlphaBits; + BYTE cDepthBits; + BYTE cStencilBits; + BYTE cAuxBuffers; + BYTE iLayerPlane; + BYTE bReserved; + COLORREF crTransparent; +} +alias LAYERPLANEDESCRIPTOR* PLAYERPLANEDESCRIPTOR, LPLAYERPLANEDESCRIPTOR; + +struct BLENDFUNCTION { + BYTE BlendOp; + BYTE BlendFlags; + BYTE SourceConstantAlpha; + BYTE AlphaFormat; +} +alias BLENDFUNCTION* PBLENDFUNCTION, LPBLENDFUNCTION; + +const MM_MAX_NUMAXES = 16; + +struct DESIGNVECTOR { + DWORD dvReserved; + DWORD dvNumAxes; + LONG[MM_MAX_NUMAXES] dvValues; +} +alias DESIGNVECTOR* PDESIGNVECTOR, LPDESIGNVECTOR; +const STAMP_DESIGNVECTOR = 0x8000000 + 'd' + ('v' << 8); +const STAMP_AXESLIST = 0x8000000 + 'a' + ('l' << 8); + +static if (_WIN32_WINNT >= 0x0500) { + + const MM_MAX_AXES_NAMELEN = 16; + + struct AXISINFOA { + LONG axMinValue; + LONG axMaxValue; + BYTE[MM_MAX_AXES_NAMELEN] axAxisName; + } + alias AXISINFOA* PAXISINFOA, LPAXISINFOA; + + struct AXISINFOW { + LONG axMinValue; + LONG axMaxValue; + WCHAR[MM_MAX_AXES_NAMELEN] axAxisName; + } + alias AXISINFOW* PAXISINFOW, LPAXISINFOW; + + version (Unicode) { + alias AXISINFOW AXISINFO; + alias PAXISINFOW PAXISINFO; + alias LPAXISINFOW LPAXISINFO; + } + else { + alias AXISINFOA AXISINFO; + alias PAXISINFOA PAXISINFO; + alias LPAXISINFOA LPAXISINFO; + } + + struct AXESLISTA { + DWORD axlReserved; + DWORD axlNumAxes; + AXISINFOA[MM_MAX_NUMAXES] axlAxisInfo; + } + alias AXESLISTA* PAXESLISTA, LPAXESLISTA; + + struct AXESLISTW { + DWORD axlReserved; + DWORD axlNumAxes; + AXISINFOW[MM_MAX_NUMAXES] axlAxisInfo; + } + alias AXESLISTW* PAXESLISTW, LPAXESLISTW; + + version (Unicode) { + alias AXESLISTW AXESLIST; + alias PAXESLISTW PAXESLIST; + alias LPAXESLISTW LPAXESLIST; + } + else { + alias AXESLISTA AXESLIST; + alias PAXESLISTA PAXESLIST; + alias LPAXESLISTA LPAXESLIST; + } + + struct ENUMLOGFONTEXDVA { + ENUMLOGFONTEXA elfEnumLogfontEx; + DESIGNVECTOR elfDesignVector; + } + alias ENUMLOGFONTEXDVA* PENUMLOGFONTEXDVA, LPENUMLOGFONTEXDVA; + + struct ENUMLOGFONTEXDVW { + ENUMLOGFONTEXW elfEnumLogfontEx; + DESIGNVECTOR elfDesignVector; + } + alias ENUMLOGFONTEXDVW* PENUMLOGFONTEXDVW, LPENUMLOGFONTEXDVW; + + HFONT CreateFontIndirectExA(ENUMLOGFONTEXDVA*); + HFONT CreateFontIndirectExW(ENUMLOGFONTEXDVW*); + version (Unicode) + alias CreateFontIndirectExW CreateFontIndirectEx; + else + alias CreateFontIndirectExA CreateFontIndirectEx; + + struct ENUMTEXTMETRICA { + NEWTEXTMETRICEXA etmNewTextMetricEx; + AXESLISTA etmAxesList; + } + alias ENUMTEXTMETRICA* PENUMTEXTMETRICA, LPENUMTEXTMETRICA; + + struct ENUMTEXTMETRICW { + NEWTEXTMETRICEXW etmNewTextMetricEx; + AXESLISTW etmAxesList; + } + alias ENUMTEXTMETRICW* PENUMTEXTMETRICW, LPENUMTEXTMETRICW; + + version (Unicode) { + alias ENUMTEXTMETRICW ENUMTEXTMETRIC; + alias PENUMTEXTMETRICW PENUMTEXTMETRIC; + alias LPENUMTEXTMETRICW LPENUMTEXTMETRIC; + } + else { + alias ENUMTEXTMETRICA ENUMTEXTMETRIC; + alias PENUMTEXTMETRICA PENUMTEXTMETRIC; + alias LPENUMTEXTMETRICA LPENUMTEXTMETRIC; + } +} /* _WIN32_WINNT >= 0x0500 */ + +struct GRADIENT_TRIANGLE { + ULONG Vertex1; + ULONG Vertex2; + ULONG Vertex3; +} +alias GRADIENT_TRIANGLE* PGRADIENT_TRIANGLE, LPGRADIENT_TRIANGLE; + +struct GRADIENT_RECT { + ULONG UpperLeft; + ULONG LowerRight; +} +alias GRADIENT_RECT* PGRADIENT_RECT, LPGRADIENT_RECT; + +struct DISPLAY_DEVICEA { + DWORD cb; + CHAR[32] DeviceName; + CHAR[128] DeviceString; + DWORD StateFlags; + CHAR[128] DeviceID; + CHAR[128] DeviceKey; +} +alias DISPLAY_DEVICEA* PDISPLAY_DEVICEA, LPDISPLAY_DEVICEA; + +struct DISPLAY_DEVICEW { + DWORD cb; + WCHAR[32] DeviceName; + WCHAR[128] DeviceString; + DWORD StateFlags; + WCHAR[128] DeviceID; + WCHAR[128] DeviceKey; +} +alias DISPLAY_DEVICEW* PDISPLAY_DEVICEW, LPDISPLAY_DEVICEW; + +static if (WINVER >= 0x0400) { + struct DRAWPATRECT { + POINT ptPosition; + POINT ptSize; + WORD wStyle; + WORD wPattern; + } + alias DRAWPATRECT* PDRAWPATRECT; +} + +// --------- +// Callbacks + +alias BOOL function (HDC, int) ABORTPROC; +alias int function (HDC, HANDLETABLE*, METARECORD*, int, LPARAM) MFENUMPROC; +alias int function (HDC, HANDLETABLE*, ENHMETARECORD*, int, LPARAM) ENHMFENUMPROC; +alias int function (LOGFONTA*, TEXTMETRICA*, DWORD, LPARAM) FONTENUMPROCA, OLDFONTENUMPROCA; +alias int function (LOGFONTW*, TEXTMETRICW*, DWORD, LPARAM) FONTENUMPROCW, OLDFONTENUMPROCW; +alias int function (LPSTR, LPARAM) ICMENUMPROCA; +alias int function (LPWSTR, LPARAM) ICMENUMPROCW; +alias void function (LPVOID, LPARAM) GOBJENUMPROC; +alias void function (int, int, LPARAM) LINEDDAPROC; +alias UINT function (HWND, HMODULE, LPDEVMODEA, LPSTR, LPSTR, LPDEVMODEA, LPSTR, UINT) LPFNDEVMODE; +alias DWORD function (LPSTR, LPSTR, UINT, LPSTR, LPDEVMODEA) LPFNDEVCAPS; + + +// --------- +// C Macros. +// FIXME: +//POINTS MAKEPOINTS(DWORD dwValue) #define MAKEPOINTS(l) (*((POINTS*)&(l))) + +DWORD MAKEROP4(DWORD fore, DWORD back) { + return ((back<<8) & 0xFF000000) | (fore); +} + +COLORREF CMYK(BYTE c, BYTE m, BYTE y, BYTE k) { + return cast(COLORREF)(k | (y << 8) | (m << 16) | (c << 24)); +} + +BYTE GetCValue(COLORREF cmyk) { + return cast(BYTE)(cmyk >> 24); +} + +BYTE GetMValue(COLORREF cmyk) { + return cast(BYTE)(cmyk >> 16); +} + +BYTE GetYValue(COLORREF cmyk) { + return cast(BYTE)(cmyk >> 8); +} + +BYTE GetKValue(COLORREF cmyk) { + return cast(BYTE)cmyk; +} + +COLORREF RGB(BYTE r, BYTE g, BYTE b) { + return cast(COLORREF)(r | (g << 8) | (b << 16)); +} + +BYTE GetRValue(COLORREF c) { + return cast(BYTE)c; +} + +BYTE GetGValue(COLORREF c) { + return cast(BYTE)(c >> 8); +} + +BYTE GetBValue(COLORREF c) { + return cast(BYTE)(c >> 16); +} + +COLORREF PALETTEINDEX(WORD i) { + return 0x01000000 | cast(COLORREF) i; +} + +COLORREF PALETTERGB(BYTE r, BYTE g, BYTE b) { + return 0x02000000|RGB(r, g, b); +} + +extern(Windows) { + int AbortDoc(HDC); + BOOL AbortPath(HDC); + int AddFontResourceA(LPCSTR); + int AddFontResourceW(LPCWSTR); + BOOL AngleArc(HDC, int, int, DWORD, FLOAT, FLOAT); + BOOL AnimatePalette(HPALETTE, UINT, UINT, PALETTEENTRY*); + BOOL Arc(HDC, int, int, int, int, int, int, int, int); + BOOL ArcTo(HDC, int, int, int, int, int, int, int, int); + BOOL BeginPath(HDC); + BOOL BitBlt(HDC, int, int, int, int, HDC, int, int, DWORD); + BOOL CancelDC(HDC); + BOOL CheckColorsInGamut(HDC, PVOID, PVOID, DWORD); + BOOL Chord(HDC, int, int, int, int, int, int, int, int); + int ChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR*); + HENHMETAFILE CloseEnhMetaFile(HDC); + BOOL CloseFigure(HDC); + HMETAFILE CloseMetaFile(HDC); + BOOL ColorMatchToTarget(HDC, HDC, DWORD); + BOOL ColorCorrectPalette(HDC, HPALETTE, DWORD, DWORD); + int CombineRgn(HRGN, HRGN, HRGN, int); + BOOL CombineTransform(LPXFORM, XFORM*, XFORM*); + HENHMETAFILE CopyEnhMetaFileA(HENHMETAFILE, LPCSTR); + HENHMETAFILE CopyEnhMetaFileW(HENHMETAFILE, LPCWSTR); + HMETAFILE CopyMetaFileA(HMETAFILE, LPCSTR); + HMETAFILE CopyMetaFileW(HMETAFILE, LPCWSTR); + HBITMAP CreateBitmap(int, int, UINT, UINT, PCVOID); + HBITMAP CreateBitmapIndirect(BITMAP*); + HBRUSH CreateBrushIndirect(LOGBRUSH*); + HCOLORSPACE CreateColorSpaceA(LPLOGCOLORSPACEA); + HCOLORSPACE CreateColorSpaceW(LPLOGCOLORSPACEW); + HBITMAP CreateCompatibleBitmap(HDC, int, int); + HDC CreateCompatibleDC(HDC); + HDC CreateDCA(LPCSTR, LPCSTR, LPCSTR, DEVMODEA*); + HDC CreateDCW(LPCWSTR, LPCWSTR, LPCWSTR, DEVMODEW*); + HBITMAP CreateDIBitmap(HDC, BITMAPINFOHEADER*, DWORD, PCVOID, BITMAPINFO*, UINT); + HBRUSH CreateDIBPatternBrush(HGLOBAL, UINT); + HBRUSH CreateDIBPatternBrushPt(PCVOID, UINT); + HBITMAP CreateDIBSection(HDC, BITMAPINFO*, UINT, void**, HANDLE, DWORD); + HBITMAP CreateDiscardableBitmap(HDC, int, int); + HRGN CreateEllipticRgn(int, int, int, int); + HRGN CreateEllipticRgnIndirect(LPCRECT); + HDC CreateEnhMetaFileA(HDC, LPCSTR, LPCRECT, LPCSTR); + HDC CreateEnhMetaFileW(HDC, LPCWSTR, LPCRECT, LPCWSTR); + HFONT CreateFontA(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCSTR); + HFONT CreateFontW(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCWSTR); + HFONT CreateFontIndirectA(LOGFONTA*); + HFONT CreateFontIndirectW(LOGFONTW*); + HPALETTE CreateHalftonePalette(HDC); + HBRUSH CreateHatchBrush(int, COLORREF); + HDC CreateICA(LPCSTR, LPCSTR, LPCSTR, DEVMODEA*); + HDC CreateICW(LPCWSTR, LPCWSTR, LPCWSTR, DEVMODEW*); + HDC CreateMetaFileA(LPCSTR); + HDC CreateMetaFileW(LPCWSTR); + HPALETTE CreatePalette(LOGPALETTE*); + HBRUSH CreatePatternBrush(HBITMAP); + HPEN CreatePen(int, int, COLORREF); + HPEN CreatePenIndirect(LOGPEN*); + HRGN CreatePolygonRgn(POINT*, int, int); + HRGN CreatePolyPolygonRgn(POINT*, INT*, int, int); + HRGN CreateRectRgn(int, int, int, int); + HRGN CreateRectRgnIndirect(LPCRECT); + HRGN CreateRoundRectRgn(int, int, int, int, int, int); + BOOL CreateScalableFontResourceA(DWORD, LPCSTR, LPCSTR, LPCSTR); + BOOL CreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR); + HBRUSH CreateSolidBrush(COLORREF); + BOOL DeleteColorSpace(HCOLORSPACE); + BOOL DeleteDC(HDC); + BOOL DeleteEnhMetaFile(HENHMETAFILE); + BOOL DeleteMetaFile(HMETAFILE); + BOOL DeleteObject(HGDIOBJ); + int DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR); + DWORD DeviceCapabilitiesA(LPCSTR, LPCSTR, WORD, LPSTR, DEVMODEA*); + DWORD DeviceCapabilitiesW(LPCWSTR, LPCWSTR, WORD, LPWSTR, DEVMODEW*); + BOOL DPtoLP(HDC, LPPOINT, int); + int DrawEscape(HDC, int, int, LPCSTR); + BOOL Ellipse(HDC, int, int, int, int); + int EndDoc(HDC); + int EndPage(HDC); + BOOL EndPath(HDC); + BOOL EnumEnhMetaFile(HDC, HENHMETAFILE, ENHMFENUMPROC, PVOID, LPCRECT); + int EnumFontFamiliesA(HDC, LPCSTR, FONTENUMPROCA, LPARAM); + int EnumFontFamiliesW(HDC, LPCWSTR, FONTENUMPROCW, LPARAM); + int EnumFontFamiliesExA(HDC, PLOGFONTA, FONTENUMPROCA, LPARAM, DWORD); + int EnumFontFamiliesExW(HDC, PLOGFONTW, FONTENUMPROCW, LPARAM, DWORD); + int EnumFontsA(HDC, LPCSTR, FONTENUMPROCA, LPARAM); + int EnumFontsW(HDC, LPCWSTR, FONTENUMPROCW, LPARAM); + int EnumICMProfilesA(HDC, ICMENUMPROCA, LPARAM); + int EnumICMProfilesW(HDC, ICMENUMPROCW, LPARAM); + BOOL EnumMetaFile(HDC, HMETAFILE, MFENUMPROC, LPARAM); + int EnumObjects(HDC, int, GOBJENUMPROC, LPARAM); + BOOL EqualRgn(HRGN, HRGN); + int Escape(HDC, int, int, LPCSTR, PVOID); + int ExcludeClipRect(HDC, int, int, int, int); + int ExcludeUpdateRgn(HDC, HWND); + HPEN ExtCreatePen(DWORD, DWORD, LOGBRUSH*, DWORD, DWORD*); + HRGN ExtCreateRegion(XFORM*, DWORD, RGNDATA*); + int ExtEscape(HDC, int, int, LPCSTR, int, LPSTR); + BOOL ExtFloodFill(HDC, int, int, COLORREF, UINT); + int ExtSelectClipRgn(HDC, HRGN, int); + BOOL ExtTextOutA(HDC, int, int, UINT, LPCRECT, LPCSTR, UINT, INT*); + BOOL ExtTextOutW(HDC, int, int, UINT, LPCRECT, LPCWSTR, UINT, INT*); + BOOL FillPath(HDC); + int FillRect(HDC, LPCRECT, HBRUSH); + int FillRgn(HDC, HRGN, HBRUSH); + BOOL FixBrushOrgEx(HDC, int, int, LPPOINT); + BOOL FlattenPath(HDC); + BOOL FloodFill(HDC, int, int, COLORREF); + BOOL FrameRgn(HDC, HRGN, HBRUSH, int, int); + BOOL GdiComment(HDC, UINT, BYTE*); + BOOL GdiFlush(); + DWORD GdiGetBatchLimit(); + DWORD GdiSetBatchLimit(DWORD); + int GetArcDirection(HDC); + BOOL GetAspectRatioFilterEx(HDC, LPSIZE); + LONG GetBitmapBits(HBITMAP, LONG, PVOID); + BOOL GetBitmapDimensionEx(HBITMAP, LPSIZE); + COLORREF GetBkColor(HDC); + int GetBkMode(HDC); + UINT GetBoundsRect(HDC, LPRECT, UINT); + BOOL GetBrushOrgEx(HDC, LPPOINT); + BOOL GetCharABCWidthsA(HDC, UINT, UINT, LPABC); + BOOL GetCharABCWidthsW(HDC, UINT, UINT, LPABC); + BOOL GetCharABCWidthsFloatA(HDC, UINT, UINT, LPABCFLOAT); + BOOL GetCharABCWidthsFloatW(HDC, UINT, UINT, LPABCFLOAT); + DWORD GetCharacterPlacementA(HDC, LPCSTR, int, int, LPGCP_RESULTSA, DWORD); + DWORD GetCharacterPlacementW(HDC, LPCWSTR, int, int, LPGCP_RESULTSW, DWORD); + BOOL GetCharWidth32A(HDC, UINT, UINT, LPINT); + BOOL GetCharWidth32W(HDC, UINT, UINT, LPINT); + BOOL GetCharWidthA(HDC, UINT, UINT, LPINT); + BOOL GetCharWidthW(HDC, UINT, UINT, LPINT); + BOOL GetCharWidthFloatA(HDC, UINT, UINT, PFLOAT); + BOOL GetCharWidthFloatW(HDC, UINT, UINT, PFLOAT); + int GetClipBox(HDC, LPRECT); + int GetClipRgn(HDC, HRGN); + BOOL GetColorAdjustment(HDC, LPCOLORADJUSTMENT); + HANDLE GetColorSpace(HDC); + HGDIOBJ GetCurrentObject(HDC, UINT); + BOOL GetCurrentPositionEx(HDC, LPPOINT); + HCURSOR GetCursor(); + BOOL GetDCOrgEx(HDC, LPPOINT); + int GetDeviceCaps(HDC, int); + BOOL GetDeviceGammaRamp(HDC, PVOID); + UINT GetDIBColorTable(HDC, UINT, UINT, RGBQUAD*); + int GetDIBits(HDC, HBITMAP, UINT, UINT, PVOID, LPBITMAPINFO, UINT); + HENHMETAFILE GetEnhMetaFileA(LPCSTR); + HENHMETAFILE GetEnhMetaFileW(LPCWSTR); + UINT GetEnhMetaFileBits(HENHMETAFILE, UINT, LPBYTE); + UINT GetEnhMetaFileDescriptionA(HENHMETAFILE, UINT, LPSTR); + UINT GetEnhMetaFileDescriptionW(HENHMETAFILE, UINT, LPWSTR); + UINT GetEnhMetaFileHeader(HENHMETAFILE, UINT, LPENHMETAHEADER); + UINT GetEnhMetaFilePaletteEntries(HENHMETAFILE, UINT, LPPALETTEENTRY); + UINT GetEnhMetaFilePixelFormat(HENHMETAFILE, DWORD, PIXELFORMATDESCRIPTOR*); + DWORD GetFontData(HDC, DWORD, DWORD, PVOID, DWORD); + DWORD GetFontLanguageInfo(HDC); + DWORD GetGlyphOutlineA(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, PVOID, MAT2*); + DWORD GetGlyphOutlineW(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, PVOID, MAT2*); + int GetGraphicsMode(HDC); + BOOL GetICMProfileA(HDC, DWORD, LPSTR); + BOOL GetICMProfileW(HDC, DWORD, LPWSTR); + DWORD GetKerningPairsA(HDC, DWORD, LPKERNINGPAIR); + DWORD GetKerningPairsW(HDC, DWORD, LPKERNINGPAIR); + BOOL GetLogColorSpaceA(HCOLORSPACE, LPLOGCOLORSPACEA, DWORD); + BOOL GetLogColorSpaceW(HCOLORSPACE, LPLOGCOLORSPACEW, DWORD); + int GetMapMode(HDC); + HMETAFILE GetMetaFileA(LPCSTR); + HMETAFILE GetMetaFileW(LPCWSTR); + UINT GetMetaFileBitsEx(HMETAFILE, UINT, PVOID); + int GetMetaRgn(HDC, HRGN); + BOOL GetMiterLimit(HDC, PFLOAT); + COLORREF GetNearestColor(HDC, COLORREF); + UINT GetNearestPaletteIndex(HPALETTE, COLORREF); + int GetObjectA(HGDIOBJ, int, PVOID); + int GetObjectW(HGDIOBJ, int, PVOID); + DWORD GetObjectType(HGDIOBJ); + UINT GetOutlineTextMetricsA(HDC, UINT, LPOUTLINETEXTMETRICA); + UINT GetOutlineTextMetricsW(HDC, UINT, LPOUTLINETEXTMETRICW); + UINT GetPaletteEntries(HPALETTE, UINT, UINT, LPPALETTEENTRY); + int GetPath(HDC, LPPOINT, PBYTE, int); + COLORREF GetPixel(HDC, int, int); + int GetPixelFormat(HDC); + int GetPolyFillMode(HDC); + BOOL GetRasterizerCaps(LPRASTERIZER_STATUS, UINT); + int GetRandomRgn (HDC, HRGN, INT); + DWORD GetRegionData(HRGN, DWORD, LPRGNDATA); + int GetRgnBox(HRGN, LPRECT); + int GetROP2(HDC); + HGDIOBJ GetStockObject(int); + int GetStretchBltMode(HDC); + UINT GetSystemPaletteEntries(HDC, UINT, UINT, LPPALETTEENTRY); + UINT GetSystemPaletteUse(HDC); + UINT GetTextAlign(HDC); + int GetTextCharacterExtra(HDC); + int GetTextCharset(HDC); + int GetTextCharsetInfo(HDC, LPFONTSIGNATURE, DWORD); + COLORREF GetTextColor(HDC); + BOOL GetTextExtentExPointA(HDC, LPCSTR, int, int, LPINT, LPINT, LPSIZE); + BOOL GetTextExtentExPointW(HDC, LPCWSTR, int, int, LPINT, LPINT, LPSIZE); + BOOL GetTextExtentPointA(HDC, LPCSTR, int, LPSIZE); + BOOL GetTextExtentPointW(HDC, LPCWSTR, int, LPSIZE); + BOOL GetTextExtentPoint32A(HDC, LPCSTR, int, LPSIZE); + BOOL GetTextExtentPoint32W(HDC, LPCWSTR, int, LPSIZE); + int GetTextFaceA(HDC, int, LPSTR); + int GetTextFaceW(HDC, int, LPWSTR); + BOOL GetTextMetricsA(HDC, LPTEXTMETRICA); + BOOL GetTextMetricsW(HDC, LPTEXTMETRICW); + BOOL GetViewportExtEx(HDC, LPSIZE); + BOOL GetViewportOrgEx(HDC, LPPOINT); + BOOL GetWindowExtEx(HDC, LPSIZE); + BOOL GetWindowOrgEx(HDC, LPPOINT); + UINT GetWinMetaFileBits(HENHMETAFILE, UINT, LPBYTE, INT, HDC); + BOOL GetWorldTransform(HDC, LPXFORM); + int IntersectClipRect(HDC, int, int, int, int); + BOOL InvertRgn(HDC, HRGN); + BOOL LineDDA(int, int, int, int, LINEDDAPROC, LPARAM); + BOOL LineTo(HDC, int, int); + BOOL LPtoDP(HDC, LPPOINT, int); + BOOL MaskBlt(HDC, int, int, int, int, HDC, int, int, HBITMAP, int, int, DWORD); + BOOL ModifyWorldTransform(HDC, XFORM*, DWORD); + BOOL MoveToEx(HDC, int, int, LPPOINT); + int OffsetClipRgn(HDC, int, int); + int OffsetRgn(HRGN, int, int); + BOOL OffsetViewportOrgEx(HDC, int, int, LPPOINT); + BOOL OffsetWindowOrgEx(HDC, int, int, LPPOINT); + BOOL PaintRgn(HDC, HRGN); + BOOL PatBlt(HDC, int, int, int, int, DWORD); + HRGN PathToRegion(HDC); + BOOL Pie(HDC, int, int, int, int, int, int, int, int); + BOOL PlayEnhMetaFile(HDC, HENHMETAFILE, LPCRECT); + BOOL PlayEnhMetaFileRecord(HDC, LPHANDLETABLE, ENHMETARECORD*, UINT); + BOOL PlayMetaFile(HDC, HMETAFILE); + BOOL PlayMetaFileRecord(HDC, LPHANDLETABLE, LPMETARECORD, UINT); + BOOL PlgBlt(HDC, POINT*, HDC, int, int, int, int, HBITMAP, int, int); + BOOL PolyBezier(HDC, POINT*, DWORD); + BOOL PolyBezierTo(HDC, POINT*, DWORD); + BOOL PolyDraw(HDC, POINT*, BYTE*, int); + BOOL Polygon(HDC, POINT*, int); + BOOL Polyline(HDC, POINT*, int); + BOOL PolylineTo(HDC, POINT*, DWORD); + BOOL PolyPolygon(HDC, POINT*, INT*, int); + BOOL PolyPolyline(HDC, POINT*, DWORD*, DWORD); + BOOL PolyTextOutA(HDC, POLYTEXTA*, int); + BOOL PolyTextOutW(HDC, POLYTEXTW*, int); + BOOL PtInRegion(HRGN, int, int); + BOOL PtVisible(HDC, int, int); + UINT RealizePalette(HDC); + BOOL Rectangle(HDC, int, int, int, int); + BOOL RectInRegion(HRGN, LPCRECT); + BOOL RectVisible(HDC, LPCRECT); + BOOL RemoveFontResourceA(LPCSTR); + BOOL RemoveFontResourceW(LPCWSTR); + + HDC ResetDCA(HDC, DEVMODEA*); + HDC ResetDCW(HDC, DEVMODEW*); + BOOL ResizePalette(HPALETTE, UINT); + BOOL RestoreDC(HDC, int); + BOOL RoundRect(HDC, int, int, int, int, int, int); + int SaveDC(HDC); + BOOL ScaleViewportExtEx(HDC, int, int, int, int, LPSIZE); + BOOL ScaleWindowExtEx(HDC, int, int, int, int, LPSIZE); + BOOL SelectClipPath(HDC, int); + int SelectClipRgn(HDC, HRGN); + HGDIOBJ SelectObject(HDC, HGDIOBJ); + HPALETTE SelectPalette(HDC, HPALETTE, BOOL); + int SetAbortProc(HDC, ABORTPROC); + int SetArcDirection(HDC, int); + LONG SetBitmapBits(HBITMAP, DWORD, PCVOID); + BOOL SetBitmapDimensionEx(HBITMAP, int, int, LPSIZE); + COLORREF SetBkColor(HDC, COLORREF); + int SetBkMode(HDC, int); + UINT SetBoundsRect(HDC, LPCRECT, UINT); + BOOL SetBrushOrgEx(HDC, int, int, LPPOINT); + BOOL SetColorAdjustment(HDC, COLORADJUSTMENT*); + BOOL SetColorSpace(HDC, HCOLORSPACE); + + BOOL SetDeviceGammaRamp(HDC, PVOID); + UINT SetDIBColorTable(HDC, UINT, UINT, RGBQUAD*); + int SetDIBits(HDC, HBITMAP, UINT, UINT, PCVOID, BITMAPINFO*, UINT); + int SetDIBitsToDevice(HDC, int, int, DWORD, DWORD, int, int, UINT, UINT, PCVOID, BITMAPINFO*, UINT); + HENHMETAFILE SetEnhMetaFileBits(UINT, BYTE*); + int SetGraphicsMode(HDC, int); + int SetICMMode(HDC, int); + BOOL SetICMProfileA(HDC, LPSTR); + BOOL SetICMProfileW(HDC, LPWSTR); + int SetMapMode(HDC, int); + + static if (WINVER >= 0x0500) { + DWORD SetLayout(HDC hdc, DWORD l); + DWORD GetLayout(HDC hdc); + } + + DWORD SetMapperFlags(HDC, DWORD); + HMETAFILE SetMetaFileBitsEx(UINT, BYTE*); + int SetMetaRgn(HDC); + BOOL SetMiterLimit(HDC, FLOAT, PFLOAT); + UINT SetPaletteEntries(HPALETTE, UINT, UINT, PALETTEENTRY*); + COLORREF SetPixel(HDC, int, int, COLORREF); + BOOL SetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR*); + BOOL SetPixelV(HDC, int, int, COLORREF); + int SetPolyFillMode(HDC, int); + BOOL SetRectRgn(HRGN, int, int, int, int); + int SetROP2(HDC, int); + int SetStretchBltMode(HDC, int); + UINT SetSystemPaletteUse(HDC, UINT); + UINT SetTextAlign(HDC, UINT); + int SetTextCharacterExtra(HDC, int); + COLORREF SetTextColor(HDC, COLORREF); + BOOL SetTextJustification(HDC, int, int); + BOOL SetViewportExtEx(HDC, int, int, LPSIZE); + BOOL SetViewportOrgEx(HDC, int, int, LPPOINT); + BOOL SetWindowExtEx(HDC, int, int, LPSIZE); + BOOL SetWindowOrgEx(HDC, int, int, LPPOINT); + HENHMETAFILE SetWinMetaFileBits(UINT, BYTE*, HDC, METAFILEPICT*); + BOOL SetWorldTransform(HDC, XFORM*); + int StartDocA(HDC, DOCINFOA*); + int StartDocW(HDC, DOCINFOW*); + int StartPage(HDC); + BOOL StretchBlt(HDC, int, int, int, int, HDC, int, int, int, int, DWORD); + int StretchDIBits(HDC, int, int, int, int, int, int, int, int, VOID* , BITMAPINFO* , UINT, DWORD); + BOOL StrokeAndFillPath(HDC); + BOOL StrokePath(HDC); + BOOL SwapBuffers(HDC); + BOOL TextOutA(HDC, int, int, LPCSTR, int); + BOOL TextOutW(HDC, int, int, LPCWSTR, int); + BOOL TranslateCharsetInfo(PDWORD, LPCHARSETINFO, DWORD); + BOOL UnrealizeObject(HGDIOBJ); + BOOL UpdateColors(HDC); + BOOL UpdateICMRegKeyA(DWORD, DWORD, LPSTR, UINT); + BOOL UpdateICMRegKeyW(DWORD, DWORD, LPWSTR, UINT); + BOOL WidenPath(HDC); + BOOL wglCopyContext(HGLRC, HGLRC, UINT); + HGLRC wglCreateContext(HDC); + HGLRC wglCreateLayerContext(HDC, int); + BOOL wglDeleteContext(HGLRC); + BOOL wglDescribeLayerPlane(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR); + HGLRC wglGetCurrentContext(); + HDC wglGetCurrentDC(); + int wglGetLayerPaletteEntries(HDC, int, int, int, COLORREF*); + PROC wglGetProcAddress(LPCSTR); + BOOL wglMakeCurrent(HDC, HGLRC); + BOOL wglRealizeLayerPalette(HDC, int, BOOL); + int wglSetLayerPaletteEntries(HDC, int, int, int, COLORREF*); + BOOL wglShareLists(HGLRC, HGLRC); + BOOL wglSwapLayerBuffers(HDC, UINT); + BOOL wglUseFontBitmapsA(HDC, DWORD, DWORD, DWORD); + BOOL wglUseFontBitmapsW(HDC, DWORD, DWORD, DWORD); + BOOL wglUseFontOutlinesA(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT); + BOOL wglUseFontOutlinesW(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT); + + static if (WINVER >= 0x0500) { + alias WGLSWAP* PWGLSWAP; + struct WGLSWAP { + HDC hdc; + UINT uiFlags; + } + const WGL_SWAPMULTIPLE_MAX = 16; + DWORD wglSwapMultipleBuffers(UINT, WGLSWAP*); +} + +static if (WINVER >= 0x0500) { + BOOL AlphaBlend(HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION); + BOOL GradientFill(HDC, PTRIVERTEX, ULONG, PVOID, ULONG, ULONG); + BOOL TransparentBlt(HDC, int, int, int, int, HDC, int, int, int, int, UINT); + } + + static if (_WIN32_WINNT >= 0x0500) { + COLORREF SetDCBrushColor(HDC, COLORREF); + COLORREF SetDCPenColor(HDC, COLORREF); + HANDLE AddFontMemResourceEx(PVOID, DWORD, PVOID, DWORD*); + int AddFontResourceExA(LPCSTR, DWORD, PVOID); + int AddFontResourceExW(LPCWSTR, DWORD, PVOID); + BOOL RemoveFontMemResourceEx(HANDLE); + BOOL RemoveFontResourceExA(LPCSTR, DWORD, PVOID); + BOOL RemoveFontResourceExW(LPCWSTR, DWORD, PVOID); + DWORD GetFontUnicodeRanges(HDC, LPGLYPHSET); + DWORD GetGlyphIndicesA(HDC, LPCSTR, int, LPWORD, DWORD); + DWORD GetGlyphIndicesW(HDC, LPCWSTR, int, LPWORD, DWORD); + BOOL GetTextExtentPointI(HDC, LPWORD, int, LPSIZE); + BOOL GetTextExtentExPointI(HDC, LPWORD, int, int, LPINT, LPINT, LPSIZE); + BOOL GetCharWidthI(HDC, UINT, UINT, LPWORD, LPINT); + BOOL GetCharABCWidthsI(HDC, UINT, UINT, LPWORD, LPABC); + } +} // extern (Windows) + +version(Unicode) { + alias WCHAR BCHAR; + alias DOCINFOW DOCINFO; + alias LOGFONTW LOGFONT; + + alias TEXTMETRICW TEXTMETRIC; + alias NPTEXTMETRICW NPTEXTMETRIC; + alias ICMENUMPROCW ICMENUMPROC; + alias FONTENUMPROCW FONTENUMPROC; + alias DEVMODEW DEVMODE; + + alias EXTLOGFONTW EXTLOGFONT; + alias GCP_RESULTSW GCP_RESULTS; + alias OUTLINETEXTMETRICW OUTLINETEXTMETRIC; + alias POLYTEXTW POLYTEXT; + alias LOGCOLORSPACEW LOGCOLORSPACE; + alias NEWTEXTMETRICW NEWTEXTMETRIC; + alias NEWTEXTMETRICEXW NEWTEXTMETRICEX; + alias ENUMLOGFONTW ENUMLOGFONT; + alias ENUMLOGFONTEXW ENUMLOGFONTEX; + alias DISPLAY_DEVICEW DISPLAY_DEVICE; + alias AddFontResourceW AddFontResource; + + alias CopyEnhMetaFileW CopyEnhMetaFile; + alias CopyMetaFileW CopyMetaFile; + alias CreateColorSpaceW CreateColorSpace; + alias CreateDCW CreateDC; + alias CreateEnhMetaFileW CreateEnhMetaFile; + alias CreateFontW CreateFont; + alias CreateFontIndirectW CreateFontIndirect; + alias CreateICW CreateIC; + alias CreateMetaFileW CreateMetaFile; + alias CreateScalableFontResourceW CreateScalableFontResource; + alias DeviceCapabilitiesW DeviceCapabilities; + alias EnumFontFamiliesW EnumFontFamilies; + alias EnumFontFamiliesExW EnumFontFamiliesEx; + alias EnumFontsW EnumFonts; + alias EnumICMProfilesW EnumICMProfiles; + alias ExtTextOutW ExtTextOut; + alias GetCharABCWidthsFloatW GetCharABCWidthsFloat; + alias GetCharABCWidthsW GetCharABCWidths; + alias GetCharacterPlacementW GetCharacterPlacement; + alias GetCharWidth32W GetCharWidth32; + alias GetCharWidthFloatW GetCharWidthFloat; + alias GetCharWidthW GetCharWidth; + alias GetEnhMetaFileW GetEnhMetaFile; + alias GetEnhMetaFileDescriptionW GetEnhMetaFileDescription; + alias GetGlyphOutlineW GetGlyphOutline; + alias GetICMProfileW GetICMProfile; + alias GetKerningPairsW GetKerningPairs; + alias GetLogColorSpaceW GetLogColorSpace; + alias GetMetaFileW GetMetaFile; + alias GetObjectW GetObject; + alias GetOutlineTextMetricsW GetOutlineTextMetrics; + alias GetTextExtentPointW GetTextExtentPoint; + alias GetTextExtentExPointW GetTextExtentExPoint; + alias GetTextExtentPoint32W GetTextExtentPoint32; + alias GetTextFaceW GetTextFace; + alias GetTextMetricsW GetTextMetrics; + alias PolyTextOutW PolyTextOut; + alias RemoveFontResourceW RemoveFontResource; + + alias ResetDCW ResetDC; + alias SetICMProfileW SetICMProfile; + alias StartDocW StartDoc; + alias TextOutW TextOut; + alias UpdateICMRegKeyW UpdateICMRegKey; + alias wglUseFontBitmapsW wglUseFontBitmaps; + alias wglUseFontOutlinesW wglUseFontOutlines; + static if (_WIN32_WINNT >= 0x0500) { + alias ENUMLOGFONTEXDVW ENUMLOGFONTEXDV; + alias PENUMLOGFONTEXDVW PENUMLOGFONTEXDV; + alias LPENUMLOGFONTEXDVW LPENUMLOGFONTEXDV; + alias AddFontResourceExW AddFontResourceEx; + alias RemoveFontResourceExW RemoveFontResourceEx; + alias GetGlyphIndicesW GetGlyphIndices; + } +} else { /* non-unicode build */ + alias BYTE BCHAR; + alias DOCINFOA DOCINFO; + alias LOGFONTA LOGFONT; + alias TEXTMETRICA TEXTMETRIC; + alias NPTEXTMETRICA NPTEXTMETRIC; + alias ICMENUMPROCA ICMENUMPROC; + alias FONTENUMPROCA FONTENUMPROC; + alias DEVMODEA DEVMODE; + alias EXTLOGFONTA EXTLOGFONT; + alias GCP_RESULTSA GCP_RESULTS; + alias OUTLINETEXTMETRICA OUTLINETEXTMETRIC; + alias POLYTEXTA POLYTEXT; + alias LOGCOLORSPACEA LOGCOLORSPACE; + alias NEWTEXTMETRICA NEWTEXTMETRIC; + alias NEWTEXTMETRICEXA NEWTEXTMETRICEX; + alias ENUMLOGFONTA ENUMLOGFONT; + alias ENUMLOGFONTEXA ENUMLOGFONTEX; + alias DISPLAY_DEVICEA DISPLAY_DEVICE; + + alias AddFontResourceA AddFontResource; + alias CopyEnhMetaFileA CopyEnhMetaFile; + alias CopyMetaFileA CopyMetaFile; + alias CreateColorSpaceA CreateColorSpace; + alias CreateDCA CreateDC; + alias CreateEnhMetaFileA CreateEnhMetaFile; + alias CreateFontA CreateFont; + alias CreateFontIndirectA CreateFontIndirect; + alias CreateICA CreateIC; + alias CreateMetaFileA CreateMetaFile; + alias CreateScalableFontResourceA CreateScalableFontResource; + alias DeviceCapabilitiesA DeviceCapabilities; + alias EnumFontFamiliesA EnumFontFamilies; + alias EnumFontFamiliesExA EnumFontFamiliesEx; + alias EnumFontsA EnumFonts; + alias EnumICMProfilesA EnumICMProfiles; + alias ExtTextOutA ExtTextOut; + alias GetCharWidthFloatA GetCharWidthFloat; + alias GetCharWidthA GetCharWidth; + alias GetCharacterPlacementA GetCharacterPlacement; + alias GetCharABCWidthsA GetCharABCWidths; + alias GetCharABCWidthsFloatA GetCharABCWidthsFloat; + alias GetCharWidth32A GetCharWidth32; + alias GetEnhMetaFileA GetEnhMetaFile; + alias GetEnhMetaFileDescriptionA GetEnhMetaFileDescription; + alias GetGlyphOutlineA GetGlyphOutline; + alias GetICMProfileA GetICMProfile; + alias GetKerningPairsA GetKerningPairs; + alias GetLogColorSpaceA GetLogColorSpace; + alias GetMetaFileA GetMetaFile; + alias GetObjectA GetObject; + alias GetOutlineTextMetricsA GetOutlineTextMetrics; + alias GetTextExtentPointA GetTextExtentPoint; + alias GetTextExtentExPointA GetTextExtentExPoint; + alias GetTextExtentPoint32A GetTextExtentPoint32; + alias GetTextFaceA GetTextFace; + alias GetTextMetricsA GetTextMetrics; + alias PolyTextOutA PolyTextOut; + alias RemoveFontResourceA RemoveFontResource; + alias ResetDCA ResetDC; + alias SetICMProfileA SetICMProfile; + alias StartDocA StartDoc; + alias TextOutA TextOut; + alias UpdateICMRegKeyA UpdateICMRegKey; + alias wglUseFontBitmapsA wglUseFontBitmaps; + alias wglUseFontOutlinesA wglUseFontOutlines; + static if (_WIN32_WINNT >= 0x0500) { + alias ENUMLOGFONTEXDVA ENUMLOGFONTEXDV; + alias PENUMLOGFONTEXDVA PENUMLOGFONTEXDV; + alias LPENUMLOGFONTEXDVA LPENUMLOGFONTEXDV; + alias AddFontResourceExA AddFontResourceEx; + alias RemoveFontResourceExA RemoveFontResourceEx; + alias GetGlyphIndicesA GetGlyphIndices; + } +} + +// Common to both ASCII & UNICODE +alias DOCINFO* LPDOCINFO; +alias LOGFONT* PLOGFONT, NPLOGFONT, LPLOGFONT; +alias TEXTMETRIC* PTEXTMETRIC, LPTEXTMETRIC; +alias DEVMODE* PDEVMODE, NPDEVMODE, LPDEVMODE; +alias EXTLOGFONT* PEXTLOGFONT, NPEXTLOGFONT, LPEXTLOGFONT; +alias GCP_RESULTS* LPGCP_RESULTS; +alias OUTLINETEXTMETRIC* POUTLINETEXTMETRIC, NPOUTLINETEXTMETRIC, LPOUTLINETEXTMETRIC; +alias POLYTEXT* PPOLYTEXT, NPPOLYTEXT, LPPOLYTEXT; +alias LOGCOLORSPACE* LPLOGCOLORSPACE; +alias NEWTEXTMETRIC* PNEWTEXTMETRIC, NPNEWTEXTMETRIC, LPNEWTEXTMETRIC; +alias ENUMLOGFONT* LPENUMLOGFONT; +alias ENUMLOGFONTEX* LPENUMLOGFONTEX; +alias DISPLAY_DEVICE* PDISPLAY_DEVICE, LPDISPLAY_DEVICE;