Merge pull request #3362 from Hyrtwol/sys-windows-2

core/sys/windows part 2

core/sys/windows/advapi32.odin

@@ -152,6 +152,43 @@ foreign advapi32 {
 		cbData: DWORD,
 	) -> LSTATUS ---
 
+	RegQueryInfoKeyW :: proc(
+		hKey: HKEY,
+		lpClass: LPWSTR,
+		lpcchClass: LPDWORD,
+		lpReserved: LPDWORD,
+		lpcSubKeys: LPDWORD,
+		lpcbMaxSubKeyLen: LPDWORD,
+		lpcbMaxClassLen: LPDWORD,
+		lpcValues: LPDWORD,
+		lpcbMaxValueNameLen: LPDWORD,
+		lpcbMaxValueLen: LPDWORD,
+		lpcbSecurityDescriptor: LPDWORD,
+		lpftLastWriteTime: ^FILETIME,
+	) -> LSTATUS ---
+
+	RegEnumKeyExW :: proc(
+		hKey: HKEY,
+		dwIndex: DWORD,
+		lpName: LPWSTR,
+		lpcchName: LPDWORD,
+		lpReserved: LPDWORD,
+		lpClass: LPWSTR,
+		lpcchClass: LPDWORD,
+		lpftLastWriteTime: ^FILETIME,
+	  ) -> LSTATUS ---
+
+	RegEnumValueW :: proc(
+		hKey: HKEY,
+		dwIndex: DWORD,
+		lpValueName: LPWSTR,
+		lpcchValueName: LPDWORD,
+		lpReserved: LPDWORD,
+		lpType: LPDWORD,
+		lpData: LPBYTE,
+		lpcbData: LPDWORD,
+	) -> LSTATUS ---
+
 	GetFileSecurityW :: proc(
 		lpFileName: LPCWSTR,
 		RequestedInformation: SECURITY_INFORMATION,

core/sys/windows/codepage.odin

@@ -0,0 +1,298 @@
+// +build windows
+package sys_windows
+
+// https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
+CODEPAGE :: enum UINT {
+	// Default to ANSI code page
+	ACP                     = CP_ACP,
+	// Default to OEM  code page
+	OEMCP                   = CP_OEMCP,
+	// Default to MAC  code page
+	MACCP                   = CP_MACCP,
+	// Current thread's ANSI code page
+	THREAD_ACP              = CP_THREAD_ACP,
+	// Symbol translations
+	SYMBOL                  = CP_SYMBOL,
+
+	// IBM EBCDIC US-Canada
+	IBM037                  = 037,
+	// OEM United States
+	IBM437                  = 437,
+	// IBM EBCDIC International
+	IBM500                  = 500,
+	// Arabic (ASMO 708)
+	ASMO_708                = 708,
+	// Arabic (Transparent ASMO); Arabic (DOS)
+	DOS_720                 = 720,
+	// OEM Greek (formerly 437G); Greek (DOS)
+	IBM737                  = 737,
+	// OEM Baltic; Baltic (DOS)
+	IBM775                  = 775,
+	// OEM Multilingual Latin 1; Western European (DOS)
+	IBM850                  = 850,
+	// OEM Latin 2; Central European (DOS)
+	IBM852                  = 852,
+	// OEM Cyrillic (primarily Russian)
+	IBM855                  = 855,
+	// OEM Turkish; Turkish (DOS)
+	IBM857                  = 857,
+	// OEM Multilingual Latin 1 + Euro symbol
+	IBM00858                = 858,
+	// OEM Portuguese; Portuguese (DOS)
+	IBM860                  = 860,
+	// OEM Icelandic; Icelandic (DOS)
+	IBM861                  = 861,
+	// OEM Hebrew; Hebrew (DOS)
+	DOS_862                 = 862,
+	// OEM French Canadian; French Canadian (DOS)
+	IBM863                  = 863,
+	// OEM Arabic; Arabic (864)
+	IBM864                  = 864,
+	// OEM Nordic; Nordic (DOS)
+	IBM865                  = 865,
+	// OEM Russian; Cyrillic (DOS)
+	CP866                   = 866,
+	// OEM Modern Greek; Greek, Modern (DOS)
+	IBM869                  = 869,
+	// IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2
+	IBM870                  = 870,
+	// Thai (Windows)
+	WINDOWS_874             = 874,
+	// IBM EBCDIC Greek Modern
+	CP875                   = 875,
+	// ANSI/OEM Japanese; Japanese (Shift-JIS)
+	SHIFT_JIS               = 932,
+	// ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
+	GB2312                  = 936,
+	// ANSI/OEM Korean (Unified Hangul Code)
+	KS_C_5601_1987          = 949,
+	// ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5)
+	BIG5                    = 950,
+	// IBM EBCDIC Turkish (Latin 5)
+	IBM1026                 = 1026,
+	// IBM EBCDIC Latin 1/Open System
+	IBM01047                = 1047,
+	// IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro)
+	IBM01140                = 1140,
+	// IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro)
+	IBM01141                = 1141,
+	// IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro)
+	IBM01142                = 1142,
+	// IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro)
+	IBM01143                = 1143,
+	// IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro)
+	IBM01144                = 1144,
+	// IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro)
+	IBM01145                = 1145,
+	// IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro)
+	IBM01146                = 1146,
+	// IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro)
+	IBM01147                = 1147,
+	// IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro)
+	IBM01148                = 1148,
+	// IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro)
+	IBM01149                = 1149,
+	// Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications
+	UTF16                   = 1200,
+	// Unicode UTF-16, big endian byte order; available only to managed applications
+	UNICODEFFFE             = 1201,
+	// ANSI Central European; Central European (Windows)
+	WINDOWS_1250            = 1250,
+	// ANSI Cyrillic; Cyrillic (Windows)
+	WINDOWS_1251            = 1251,
+	// ANSI Latin 1; Western European (Windows)
+	WINDOWS_1252            = 1252,
+	// ANSI Greek; Greek (Windows)
+	WINDOWS_1253            = 1253,
+	// ANSI Turkish; Turkish (Windows)
+	WINDOWS_1254            = 1254,
+	// ANSI Hebrew; Hebrew (Windows)
+	WINDOWS_1255            = 1255,
+	// ANSI Arabic; Arabic (Windows)
+	WINDOWS_1256            = 1256,
+	// ANSI Baltic; Baltic (Windows)
+	WINDOWS_1257            = 1257,
+	// ANSI/OEM Vietnamese; Vietnamese (Windows)
+	WINDOWS_1258            = 1258,
+	// Korean (Johab)
+	JOHAB                   = 1361,
+	// MAC Roman; Western European (Mac)
+	MACINTOSH               = 10000,
+	// Japanese (Mac)
+	X_MAC_JAPANESE          = 10001,
+	// MAC Traditional Chinese (Big5); Chinese Traditional (Mac)
+	X_MAC_CHINESETRAD       = 10002,
+	// Korean (Mac)
+	X_MAC_KOREAN            = 10003,
+	// Arabic (Mac)
+	X_MAC_ARABIC            = 10004,
+	// Hebrew (Mac)
+	X_MAC_HEBREW            = 10005,
+	// Greek (Mac)
+	X_MAC_GREEK             = 10006,
+	// Cyrillic (Mac)
+	X_MAC_CYRILLIC          = 10007,
+	// MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac)
+	X_MAC_CHINESESIMP       = 10008,
+	// Romanian (Mac)
+	X_MAC_ROMANIAN          = 10010,
+	// Ukrainian (Mac)
+	X_MAC_UKRAINIAN         = 10017,
+	// Thai (Mac)
+	X_MAC_THAI              = 10021,
+	// MAC Latin 2; Central European (Mac)
+	X_MAC_CE                = 10029,
+	// Icelandic (Mac)
+	X_MAC_ICELANDIC         = 10079,
+	// Turkish (Mac)
+	X_MAC_TURKISH           = 10081,
+	// Croatian (Mac)
+	X_MAC_CROATIAN          = 10082,
+	// Unicode UTF-32, little endian byte order; available only to managed applications
+	UTF32                   = 12000,
+	// Unicode UTF-32, big endian byte order; available only to managed applications
+	UTF32BE                 = 12001,
+	// CNS Taiwan; Chinese Traditional (CNS)
+	X_CHINESE_CNS           = 20000,
+	// TCA Taiwan
+	X_CP20001               = 20001,
+	// Eten Taiwan; Chinese Traditional (Eten)
+	X_CHINESE_ETEN          = 20002,
+	// IBM5550 Taiwan
+	X_CP20003               = 20003,
+	// TeleText Taiwan
+	X_CP20004               = 20004,
+	// Wang Taiwan
+	X_CP20005               = 20005,
+	// IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5)
+	X_IA5                   = 20105,
+	// IA5 German (7-bit)
+	X_IA5_GERMAN            = 20106,
+	// IA5 Swedish (7-bit)
+	X_IA5_SWEDISH           = 20107,
+	// IA5 Norwegian (7-bit)
+	X_IA5_NORWEGIAN         = 20108,
+	// US-ASCII (7-bit)
+	US_ASCII                = 20127,
+	// T.61
+	X_CP20261               = 20261,
+	// ISO 6937 Non-Spacing Accent
+	X_CP20269               = 20269,
+	// IBM EBCDIC Germany
+	IBM273                  = 20273,
+	// IBM EBCDIC Denmark-Norway
+	IBM277                  = 20277,
+	// IBM EBCDIC Finland-Sweden
+	IBM278                  = 20278,
+	// IBM EBCDIC Italy
+	IBM280                  = 20280,
+	// IBM EBCDIC Latin America-Spain
+	IBM284                  = 20284,
+	// IBM EBCDIC United Kingdom
+	IBM285                  = 20285,
+	// IBM EBCDIC Japanese Katakana Extended
+	IBM290                  = 20290,
+	// IBM EBCDIC France
+	IBM297                  = 20297,
+	// IBM EBCDIC Arabic
+	IBM420                  = 20420,
+	// IBM EBCDIC Greek
+	IBM423                  = 20423,
+	// IBM EBCDIC Hebrew
+	IBM424                  = 20424,
+	// IBM EBCDIC Korean Extended
+	X_EBCDIC_KOREANEXTENDED = 20833,
+	// IBM EBCDIC Thai
+	IBM_THAI                = 20838,
+	// Russian (KOI8-R); Cyrillic (KOI8-R)
+	KOI8_R                  = 20866,
+	// IBM EBCDIC Icelandic
+	IBM871                  = 20871,
+	// IBM EBCDIC Cyrillic Russian
+	IBM880                  = 20880,
+	// IBM EBCDIC Turkish
+	IBM905                  = 20905,
+	// IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)
+	IBM00924                = 20924,
+	// Japanese (JIS 0208-1990 and 0212-1990)
+	EUC_JP                  = 20932,
+	// Simplified Chinese (GB2312); Chinese Simplified (GB2312-80)
+	X_CP20936               = 20936,
+	// Korean Wansung
+	X_CP20949               = 20949,
+	// IBM EBCDIC Cyrillic Serbian-Bulgarian
+	CP1025                  = 21025,
+	// Ukrainian (KOI8-U); Cyrillic (KOI8-U)
+	KOI8_U                  = 21866,
+	// ISO 8859-1 Latin 1; Western European (ISO)
+	ISO_8859_1              = 28591,
+	// ISO 8859-2 Central European; Central European (ISO)
+	ISO_8859_2              = 28592,
+	// ISO 8859-3 Latin 3
+	ISO_8859_3              = 28593,
+	// ISO 8859-4 Baltic
+	ISO_8859_4              = 28594,
+	// ISO 8859-5 Cyrillic
+	ISO_8859_5              = 28595,
+	// ISO 8859-6 Arabic
+	ISO_8859_6              = 28596,
+	// ISO 8859-7 Greek
+	ISO_8859_7              = 28597,
+	// ISO 8859-8 Hebrew; Hebrew (ISO-Visual)
+	ISO_8859_8              = 28598,
+	// ISO 8859-9 Turkish
+	ISO_8859_9              = 28599,
+	// ISO 8859-13 Estonian
+	ISO_8859_13             = 28603,
+	// ISO 8859-15 Latin 9
+	ISO_8859_15             = 28605,
+	// Europa 3
+	X_EUROPA                = 29001,
+	// ISO 8859-8 Hebrew; Hebrew (ISO-Logical)
+	ISO_8859_8_I            = 38598,
+	// ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
+	ISO_2022_JP             = 50220,
+	// ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana)
+	CSISO2022JP             = 50221,
+	// ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI)
+	ISO_2022_2_JP           = 50222,
+	// ISO 2022 Korean
+	ISO_2022_KR             = 50225,
+	// ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022)
+	X_CP50227               = 50227,
+	// EUC Japanese
+	EUC_JP_2                = 51932,
+	// EUC Simplified Chinese; Chinese Simplified (EUC)
+	EUC_CN                  = 51936,
+	// EUC Korean
+	EUC_KR                  = 51949,
+	// HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)
+	HZ_GB_2312              = 52936,
+	// **Windows XP and later:** GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030)
+	GB18030                 = 54936,
+	// ISCII Devanagari
+	X_ISCII_DE              = 57002,
+	// ISCII Bangla
+	X_ISCII_BE              = 57003,
+	// ISCII Tamil
+	X_ISCII_TA              = 57004,
+	// ISCII Telugu
+	X_ISCII_TE              = 57005,
+	// ISCII Assamese
+	X_ISCII_AS              = 57006,
+	// ISCII Odia
+	X_ISCII_OR              = 57007,
+	// ISCII Kannada
+	X_ISCII_KA              = 57008,
+	// ISCII Malayalam
+	X_ISCII_MA              = 57009,
+	// ISCII Gujarati
+	X_ISCII_GU              = 57010,
+	// ISCII Punjabi
+	X_ISCII_PA              = 57011,
+
+	// Unicode (UTF-7)
+	UTF7                    = CP_UTF7, /*65000*/
+	// Unicode (UTF-8)
+	UTF8                    = CP_UTF8, /*65001*/
+}

core/sys/windows/gdi32.odin

@@ -7,108 +7,97 @@ foreign import gdi32 "system:Gdi32.lib"
 
 @(default_calling_convention="system")
 foreign gdi32 {
-	GetStockObject :: proc(i: c_int) -> HGDIOBJ ---
+	GetDeviceCaps :: proc(hdc: HDC, index: INT) -> INT ---
+	GetStockObject :: proc(i: INT) -> HGDIOBJ ---
 	SelectObject :: proc(hdc: HDC, h: HGDIOBJ) -> HGDIOBJ ---
 	DeleteObject :: proc(ho: HGDIOBJ) -> BOOL ---
 	SetBkColor :: proc(hdc: HDC, color: COLORREF) -> COLORREF ---
+	SetBkMode :: proc(hdc: HDC, mode: BKMODE) -> INT ---
 
 	CreateCompatibleDC :: proc(hdc: HDC) -> HDC ---
 	DeleteDC :: proc(hdc: HDC) -> BOOL ---
+	CancelDC :: proc(hdc: HDC) -> BOOL ---
+	SaveDC :: proc(hdc: HDC) -> INT ---
+	RestoreDC :: proc(hdc: HDC, nSavedDC: INT) -> BOOL ---
 
 	CreateDIBPatternBrush :: proc(h: HGLOBAL, iUsage: UINT) -> HBRUSH ---
+	CreateDIBitmap :: proc(hdc: HDC, pbmih: ^BITMAPINFOHEADER, flInit: DWORD, pjBits: VOID, pbmi: ^BITMAPINFO, iUsage: UINT) -> HBITMAP ---
+	CreateDIBSection :: proc(hdc: HDC, pbmi: ^BITMAPINFO, usage: UINT, ppvBits: VOID, hSection: HANDLE, offset: DWORD) -> HBITMAP ---
+	StretchDIBits :: proc(hdc: HDC, xDest, yDest, DestWidth, DestHeight, xSrc, ySrc, SrcWidth, SrcHeight: INT, lpBits: VOID, lpbmi: ^BITMAPINFO, iUsage: UINT, rop: DWORD) -> INT ---
+	StretchBlt :: proc(hdcDest: HDC, xDest, yDest, wDest, hDest: INT, hdcSrc: HDC, xSrc, ySrc, wSrc, hSrc: INT, rop: DWORD) -> BOOL ---
 
-	CreateDIBitmap :: proc(
-		hdc: HDC,
-		pbmih: ^BITMAPINFOHEADER,
-		flInit: DWORD,
-		pjBits: VOID,
-		pbmi: ^BITMAPINFO,
-		iUsage: UINT,
-	) -> HBITMAP ---
-
-	CreateDIBSection :: proc(
-		hdc: HDC,
-		pbmi: ^BITMAPINFO,
-		usage: UINT,
-		ppvBits: VOID,
-		hSection: HANDLE,
-		offset: DWORD,
-	) -> HBITMAP ---
-
-	StretchDIBits :: proc(
-		hdc: HDC,
-		xDest: c_int,
-		yDest: c_int,
-		DestWidth: c_int,
-		DestHeight: c_int,
-		xSrc: c_int,
-		ySrc: c_int,
-		SrcWidth: c_int,
-		SrcHeight: c_int,
-		lpBits: VOID,
-		lpbmi: ^BITMAPINFO,
-		iUsage: UINT,
-		rop: DWORD,
-	) -> c_int ---
-
-	StretchBlt :: proc(
-		hdcDest: HDC,
-		xDest: c_int,
-		yDest: c_int,
-		wDest: c_int,
-		hDest: c_int,
-		hdcSrc: HDC,
-		xSrc: c_int,
-		ySrc: c_int,
-		wSrc: c_int,
-		hSrc: c_int,
-		rop: DWORD,
-	) -> BOOL ---
-
-	SetPixelFormat :: proc(hdc: HDC, format: c_int, ppfd: ^PIXELFORMATDESCRIPTOR) -> BOOL ---
-	ChoosePixelFormat :: proc(hdc: HDC, ppfd: ^PIXELFORMATDESCRIPTOR) -> c_int ---
-	DescribePixelFormat :: proc(hdc: HDC, iPixelFormat: c_int, nBytes: UINT, ppfd: ^PIXELFORMATDESCRIPTOR) -> c_int ---
-	SwapBuffers :: proc(HDC) -> BOOL ---
+	SetPixelFormat :: proc(hdc: HDC, format: INT, ppfd: ^PIXELFORMATDESCRIPTOR) -> BOOL ---
+	ChoosePixelFormat :: proc(hdc: HDC, ppfd: ^PIXELFORMATDESCRIPTOR) -> INT ---
+	DescribePixelFormat :: proc(hdc: HDC, iPixelFormat: INT, nBytes: UINT, ppfd: ^PIXELFORMATDESCRIPTOR) -> INT ---	
+	SwapBuffers :: proc(hdc: HDC) -> BOOL ---
 
 	SetDCBrushColor :: proc(hdc: HDC, color: COLORREF) -> COLORREF ---
 	GetDCBrushColor :: proc(hdc: HDC) -> COLORREF ---
-	PatBlt :: proc(hdc: HDC, x, y, w, h: c_int, rop: DWORD) -> BOOL ---
-	Rectangle :: proc(hdc: HDC, left, top, right, bottom: c_int) -> BOOL ---
-
-	CreateFontW :: proc(
-		cHeight, cWidth, cEscapement, cOrientation, cWeight: c_int,
-		bItalic, bUnderline, bStrikeOut, iCharSet, iOutPrecision: DWORD,
-		iClipPrecision, iQuality, iPitchAndFamily: DWORD,
-		pszFaceName: LPCWSTR,
-	) -> HFONT ---
-	TextOutW :: proc(hdc: HDC, x, y: c_int, lpString: LPCWSTR, c: c_int) -> BOOL ---
-	GetTextExtentPoint32W :: proc(hdc: HDC, lpString: LPCWSTR, c: c_int, psizl: LPSIZE) -> BOOL ---
+	PatBlt :: proc(hdc: HDC, x, y, w, h: INT, rop: DWORD) -> BOOL ---
+	Rectangle :: proc(hdc: HDC, left, top, right, bottom: INT) -> BOOL ---
+
+	CreateFontW :: proc(cHeight, cWidth, cEscapement, cOrientation, cWeight: INT, bItalic, bUnderline, bStrikeOut, iCharSet, iOutPrecision: DWORD, iClipPrecision, iQuality, iPitchAndFamily: DWORD, pszFaceName: LPCWSTR) -> HFONT ---
+	CreateFontIndirectW :: proc(lplf: ^LOGFONTW) -> HFONT ---
+	CreateFontIndirectExW :: proc(unnamedParam1: ^ENUMLOGFONTEXDVW) -> HFONT ---
+	AddFontResourceW :: proc(unnamedParam1: LPCWSTR) -> INT ---
+	AddFontResourceExW :: proc(name: LPCWSTR, fl: DWORD, res: PVOID) -> INT ---
+	AddFontMemResourceEx :: proc(pFileView: PVOID, cjSize: DWORD, pvResrved: PVOID, pNumFonts: ^DWORD) -> HANDLE ---
+	EnumFontsW :: proc(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM) -> INT ---
+	EnumFontFamiliesW :: proc(hdc: HDC, lpLogfont: LPCWSTR, lpProc: FONTENUMPROCW, lParam: LPARAM) -> INT ---
+	EnumFontFamiliesExW :: proc(hdc: HDC, lpLogfont: LPLOGFONTW, lpProc: FONTENUMPROCW, lParam: LPARAM, dwFlags: DWORD) -> INT ---
+
+	TextOutW :: proc(hdc: HDC, x, y: INT, lpString: LPCWSTR, c: INT) -> BOOL ---
+	GetTextExtentPoint32W :: proc(hdc: HDC, lpString: LPCWSTR, c: INT, psizl: LPSIZE) -> BOOL ---
 	GetTextMetricsW :: proc(hdc: HDC, lptm: LPTEXTMETRICW) -> BOOL ---
 
 	CreateSolidBrush :: proc(color: COLORREF) -> HBRUSH ---
 
-	GetObjectW :: proc(h: HANDLE, c: c_int, pv: LPVOID) -> int ---
-	CreateCompatibleBitmap :: proc(hdc: HDC, cx, cy: c_int) -> HBITMAP ---
-	BitBlt :: proc(hdc: HDC, x, y, cx, cy: c_int, hdcSrc: HDC, x1, y1: c_int, rop: DWORD) -> BOOL ---
-	GetDIBits :: proc(hdc: HDC, hbm: HBITMAP, start, cLines: UINT, lpvBits: LPVOID, lpbmi: ^BITMAPINFO, usage: UINT) -> int ---
+	GetObjectW :: proc(h: HANDLE, c: INT, pv: LPVOID) -> int ---
+	CreateCompatibleBitmap :: proc(hdc: HDC, cx, cy: INT) -> HBITMAP ---
+	BitBlt :: proc(hdc: HDC, x, y, cx, cy: INT, hdcSrc: HDC, x1, y1: INT, rop: DWORD) -> BOOL ---
+	GetDIBits :: proc(hdc: HDC, hbm: HBITMAP, start, cLines: UINT, lpvBits: LPVOID, lpbmi: ^BITMAPINFO, usage: UINT) -> INT ---
+	SetDIBits :: proc(hdc: HDC, hbm: HBITMAP, start: UINT, cLines: UINT, lpBits: VOID, lpbmi: ^BITMAPINFO, ColorUse: UINT) -> INT ---
+	SetDIBColorTable :: proc(hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: ^RGBQUAD) -> UINT ---
+	GetDIBColorTable :: proc(hdc: HDC, iStart: UINT, cEntries: UINT, prgbq: ^RGBQUAD) -> UINT ---
+
+	CreatePen :: proc(iStyle, cWidth: INT, color: COLORREF) -> HPEN ---
+	ExtCreatePen :: proc(iPenStyle, cWidth: DWORD, plbrush: ^LOGBRUSH, cStyle: DWORD, pstyle: ^DWORD) -> HPEN ---
+	SetDCPenColor :: proc(hdc: HDC, color: COLORREF) -> COLORREF ---
+	GetDCPenColor :: proc(hdc: HDC) -> COLORREF ---
+
+	CreatePalette :: proc(plpal: ^LOGPALETTE) -> HPALETTE ---
+	SelectPalette :: proc(hdc: HDC, hPal: HPALETTE, bForceBkgd: BOOL) -> HPALETTE ---
+	RealizePalette :: proc(hdc: HDC) -> UINT ---
+
+	SetTextColor :: proc(hdc: HDC, color: COLORREF) -> COLORREF ---
+	RoundRect :: proc(hdc: HDC, left: INT, top: INT, right: INT, bottom: INT, width: INT, height: INT) -> BOOL ---
+	SetPixel :: proc(hdc: HDC, x: INT, y: INT, color: COLORREF) -> COLORREF ---
+
+	GdiTransparentBlt :: proc(hdcDest: HDC, xoriginDest, yoriginDest, wDest, hDest: INT, hdcSrc: HDC, xoriginSrc, yoriginSrc, wSrc, hSrc: INT, crTransparent: UINT) -> BOOL ---
+	GdiGradientFill :: proc(hdc: HDC, pVertex: PTRIVERTEX, nVertex: ULONG, pMesh: PVOID, nCount: ULONG, ulMode: ULONG) -> BOOL ---
+	GdiAlphaBlend :: proc(hdcDest: HDC, xoriginDest, yoriginDest, wDest, hDest: INT, hdcSrc: HDC, xoriginSrc, yoriginSrc, wSrc, hSrc: INT, ftn: BLENDFUNCTION) -> BOOL ---
+}
+
+RGB :: #force_inline proc "contextless" (#any_int r, g, b: int) -> COLORREF {
+	return COLORREF(DWORD(BYTE(r)) | (DWORD(BYTE(g)) << 8) | (DWORD(BYTE(b)) << 16))
+}
+
+PALETTERGB :: #force_inline proc "contextless" (#any_int r, g, b: int) -> COLORREF {
+	return 0x02000000 | RGB(r, g, b)
 }
 
-RGB :: #force_inline proc "contextless" (r, g, b: u8) -> COLORREF {
-	return transmute(COLORREF)[4]u8{r, g, b, 0}
+PALETTEINDEX :: #force_inline proc "contextless" (#any_int i: int) -> COLORREF {
+	return COLORREF(DWORD(0x01000000) | DWORD(WORD(i)))
 }
 
 FXPT2DOT30 :: distinct fixed.Fixed(i32, 30)
 
 CIEXYZ :: struct {
-	ciexyzX: FXPT2DOT30,
-	ciexyzY: FXPT2DOT30,
-	ciexyzZ: FXPT2DOT30,
+	ciexyzX, ciexyzY, ciexyzZ: FXPT2DOT30,
 }
 
 CIEXYZTRIPLE :: struct {
-	ciexyzRed:   CIEXYZ,
-	ciexyzGreen: CIEXYZ,
-	ciexyzBlue:  CIEXYZ,
+	ciexyzRed, ciexyzGreen, ciexyzBlue: CIEXYZ,
 }
 
 // https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapv5header
@@ -138,3 +127,227 @@ BITMAPV5HEADER :: struct {
 	bV5ProfileSize:   DWORD,
 	bV5Reserved:      DWORD,
 }
+
+PALETTEENTRY :: struct {
+	peRed, peGreen, peBlue, peFlags: BYTE,
+}
+
+LOGPALETTE :: struct {
+	palVersion:    WORD,
+	palNumEntries: WORD,
+	palPalEntry:   []PALETTEENTRY,
+}
+
+BKMODE :: enum {
+	TRANSPARENT = 1,
+	OPAQUE      = 2,
+}
+
+ICONINFOEXW :: struct {
+	cbSize:             DWORD,
+	fIcon:              BOOL,
+	xHotspot, yHotspot: DWORD,
+	hbmMask, hbmColor:  HBITMAP,
+	wResID:             WORD,
+	szModName:          [MAX_PATH]WCHAR,
+	szResName:          [MAX_PATH]WCHAR,
+}
+PICONINFOEXW :: ^ICONINFOEXW
+
+AC_SRC_OVER :: 0x00
+AC_SRC_ALPHA :: 0x01
+
+TransparentBlt :: GdiTransparentBlt
+GradientFill :: GdiGradientFill
+AlphaBlend :: GdiAlphaBlend
+
+COLOR16 :: USHORT
+TRIVERTEX :: struct {
+	x, y:                    LONG,
+	Red, Green, Blue, Alpha: COLOR16,
+}
+PTRIVERTEX :: ^TRIVERTEX
+
+GRADIENT_TRIANGLE :: struct {
+	Vertex1, Vertex2, Vertex3: ULONG,
+}
+PGRADIENT_TRIANGLE :: ^GRADIENT_TRIANGLE
+
+GRADIENT_RECT :: struct {
+	UpperLeft, LowerRight: ULONG,
+}
+PGRADIENT_RECT :: ^GRADIENT_RECT
+
+BLENDFUNCTION :: struct {
+	BlendOp, BlendFlags, SourceConstantAlpha, AlphaFormat: BYTE,
+}
+
+GRADIENT_FILL_RECT_H    : ULONG : 0x00000000
+GRADIENT_FILL_RECT_V    : ULONG : 0x00000001
+GRADIENT_FILL_TRIANGLE  : ULONG : 0x00000002
+GRADIENT_FILL_OP_FLAG   : ULONG : 0x000000ff
+
+/* Brush Styles */
+BS_SOLID         :: 0
+BS_NULL          :: 1
+BS_HOLLOW        :: BS_NULL
+BS_HATCHED       :: 2
+BS_PATTERN       :: 3
+BS_INDEXED       :: 4
+BS_DIBPATTERN    :: 5
+BS_DIBPATTERNPT  :: 6
+BS_PATTERN8X8    :: 7
+BS_DIBPATTERN8X8 :: 8
+BS_MONOPATTERN   :: 9
+
+/* Hatch Styles */
+HS_HORIZONTAL    :: 0       /* ----- */
+HS_VERTICAL      :: 1       /* ||||| */
+HS_FDIAGONAL     :: 2       /* \\\\\ */
+HS_BDIAGONAL     :: 3       /* ///// */
+HS_CROSS         :: 4       /* +++++ */
+HS_DIAGCROSS     :: 5       /* xxxxx */
+HS_API_MAX       :: 12
+
+/* Pen Styles */
+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    ::  0x0000000F
+PS_ENDCAP_ROUND  ::  0x00000000
+PS_ENDCAP_SQUARE ::  0x00000100
+PS_ENDCAP_FLAT   ::  0x00000200
+PS_ENDCAP_MASK   ::  0x00000F00
+PS_JOIN_ROUND    ::  0x00000000
+PS_JOIN_BEVEL    ::  0x00001000
+PS_JOIN_MITER    ::  0x00002000
+PS_JOIN_MASK     ::  0x0000F000
+PS_COSMETIC      ::  0x00000000
+PS_GEOMETRIC     ::  0x00010000
+PS_TYPE_MASK     ::  0x000F0000
+
+LOGBRUSH :: struct {
+	lbStyle: UINT,
+	lbColor: COLORREF,
+	lbHatch: ULONG_PTR,
+}
+PLOGBRUSH :: ^LOGBRUSH
+
+/* CombineRgn() Styles */
+RGN_AND  :: 1
+RGN_OR   :: 2
+RGN_XOR  :: 3
+RGN_DIFF :: 4
+RGN_COPY :: 5
+
+/* StretchBlt() Modes */
+// BLACKONWHITE :: 1
+// WHITEONBLACK :: 2
+// COLORONCOLOR :: 3
+// HALFTONE     :: 4
+
+/* PolyFill() Modes */
+ALTERNATE :: 1
+WINDING   :: 2
+
+/* Layout Orientation Options */
+LAYOUT_RTL             :: 0x00000001 // Right to left
+LAYOUT_BTT             :: 0x00000002 // Bottom to top
+LAYOUT_VBH             :: 0x00000004 // Vertical before horizontal
+LAYOUT_ORIENTATIONMASK :: (LAYOUT_RTL | LAYOUT_BTT | LAYOUT_VBH)
+
+/* Text Alignment Options */
+TA_NOUPDATECP :: 0
+TA_UPDATECP   :: 1
+
+TA_LEFT       :: 0
+TA_RIGHT      :: 2
+TA_CENTER     :: 6
+
+TA_TOP        :: 0
+TA_BOTTOM     :: 8
+TA_BASELINE   :: 24
+TA_RTLREADING :: 256
+TA_MASK       :: (TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING)
+
+MM_MAX_NUMAXES :: 16
+DESIGNVECTOR :: struct {
+	dvReserved: DWORD,
+	dvNumAxes:  DWORD,
+	dvValues:   [MM_MAX_NUMAXES]LONG,
+}
+
+LF_FACESIZE :: 32
+LF_FULLFACESIZE :: 64
+
+LOGFONTW :: struct {
+	lfHeight:         LONG,
+	lfWidth:          LONG,
+	lfEscapement:     LONG,
+	lfOrientation:    LONG,
+	lfWeight:         LONG,
+	lfItalic:         BYTE,
+	lfUnderline:      BYTE,
+	lfStrikeOut:      BYTE,
+	lfCharSet:        BYTE,
+	lfOutPrecision:   BYTE,
+	lfClipPrecision:  BYTE,
+	lfQuality:        BYTE,
+	lfPitchAndFamily: BYTE,
+	lfFaceName:       [LF_FACESIZE]WCHAR,
+}
+LPLOGFONTW :: ^LOGFONTW
+
+ENUMLOGFONTW :: struct {
+	elfLogFont:  LOGFONTW,
+	elfFullName: [LF_FULLFACESIZE]WCHAR,
+	elfStyle:    [LF_FACESIZE]WCHAR,
+}
+LPENUMLOGFONTW :: ^ENUMLOGFONTW
+
+ENUMLOGFONTEXW :: struct {
+	elfLogFont:  LOGFONTW,
+	elfFullName: [LF_FULLFACESIZE]WCHAR,
+	elfStyle:    [LF_FACESIZE]WCHAR,
+	elfScript:   [LF_FACESIZE]WCHAR,
+}
+
+ENUMLOGFONTEXDVW :: struct {
+	elfEnumLogfontEx: ENUMLOGFONTEXW,
+	elfDesignVector:  DESIGNVECTOR,
+}
+
+NEWTEXTMETRICW :: struct {
+	tmHeight:           LONG,
+	tmAscent:           LONG,
+	tmDescent:          LONG,
+	tmInternalLeading:  LONG,
+	tmExternalLeading:  LONG,
+	tmAveCharWidth:     LONG,
+	tmMaxCharWidth:     LONG,
+	tmWeight:           LONG,
+	tmOverhang:         LONG,
+	tmDigitizedAspectX: LONG,
+	tmDigitizedAspectY: LONG,
+	tmFirstChar:        WCHAR,
+	tmLastChar:         WCHAR,
+	tmDefaultChar:      WCHAR,
+	tmBreakChar:        WCHAR,
+	tmItalic:           BYTE,
+	tmUnderlined:       BYTE,
+	tmStruckOut:        BYTE,
+	tmPitchAndFamily:   BYTE,
+	tmCharSet:          BYTE,
+	ntmFlags:           DWORD,
+	ntmSizeEM:          UINT,
+	ntmCellHeight:      UINT,
+	ntmAvgWidth:        UINT,
+}
+
+FONTENUMPROCW :: #type proc(lpelf: ^ENUMLOGFONTW, lpntm: ^NEWTEXTMETRICW, FontType: DWORD, lParam: LPARAM) -> INT

core/sys/windows/kernel32.odin

@@ -51,18 +51,14 @@ foreign kernel32 {
 	// https://learn.microsoft.com/en-us/windows/console/getnumberofconsoleinputevents
 	GetNumberOfConsoleInputEvents :: proc(hConsoleInput: HANDLE, lpcNumberOfEvents: LPDWORD) -> BOOL ---
 
-	GetConsoleMode :: proc(hConsoleHandle: HANDLE,
-	                       lpMode: LPDWORD) -> BOOL ---
-	SetConsoleMode :: proc(hConsoleHandle: HANDLE,
-	                       dwMode: DWORD) -> BOOL ---
-	SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE,
-	                                 dwCursorPosition: COORD) -> BOOL ---
-	SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE,
-	                                wAttributes: WORD) -> BOOL ---
-	GetConsoleCP :: proc() -> UINT ---
-	SetConsoleCP :: proc(wCodePageID: UINT) -> BOOL ---
-	GetConsoleOutputCP :: proc() -> UINT ---
-	SetConsoleOutputCP :: proc(wCodePageID: UINT) -> BOOL ---
+	GetConsoleMode :: proc(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL ---
+	SetConsoleMode :: proc(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL ---
+	SetConsoleCursorPosition :: proc(hConsoleHandle: HANDLE, dwCursorPosition: COORD) -> BOOL ---
+	SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL ---
+	GetConsoleCP :: proc() -> CODEPAGE ---
+	SetConsoleCP :: proc(wCodePageID: CODEPAGE) -> BOOL ---
+	GetConsoleOutputCP :: proc() -> CODEPAGE ---
+	SetConsoleOutputCP :: proc(wCodePageID: CODEPAGE) -> BOOL ---
 	FlushConsoleInputBuffer :: proc(hConsoleInput: HANDLE) -> BOOL ---
 
 	GetFileInformationByHandle :: proc(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) -> BOOL ---
@@ -256,6 +252,7 @@ foreign kernel32 {
 	SetEnvironmentVariableW :: proc(n: LPCWSTR, v: LPCWSTR) -> BOOL ---
 	GetEnvironmentStringsW :: proc() -> LPWCH ---
 	FreeEnvironmentStringsW :: proc(env_ptr: LPWCH) -> BOOL ---
+	ExpandEnvironmentStringsW :: proc(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD) -> DWORD ---
 	GetModuleFileNameW :: proc(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD) -> DWORD ---
 	CreateDirectoryW :: proc(
 		lpPathName: LPCWSTR,
@@ -440,12 +437,34 @@ foreign kernel32 {
 	GetFileAttributesExW :: proc(lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID) -> BOOL ---
 	GetSystemInfo :: proc(system_info: ^SYSTEM_INFO) ---
 	GetVersionExW :: proc(osvi: ^OSVERSIONINFOEXW) ---
-
+	GetSystemDirectoryW :: proc(lpBuffer: LPWSTR, uSize: UINT) -> UINT ---
+	GetWindowsDirectoryW :: proc(lpBuffer: LPWSTR, uSize: UINT) -> UINT ---
+	GetSystemDefaultLangID :: proc() -> LANGID ---
+	GetSystemDefaultLCID :: proc() -> LCID ---
+	GetSystemDefaultLocaleName :: proc(lpLocaleName: LPWSTR, cchLocaleName: INT) -> INT ---
+	LCIDToLocaleName :: proc(Locale: LCID, lpName: LPWSTR, cchName: INT, dwFlags: DWORD) -> INT ---
+	LocaleNameToLCID :: proc(lpName: LPCWSTR, dwFlags: DWORD) -> LCID ---
+	SetDllDirectoryW :: proc(lpPathName: LPCWSTR) -> BOOL ---
+	AddDllDirectory :: proc(NewDirectory: PCWSTR) -> rawptr ---
+	RemoveDllDirectory :: proc(Cookie: rawptr) -> BOOL ---
 	LoadLibraryW :: proc(c_str: LPCWSTR) -> HMODULE ---
+	LoadLibraryExW :: proc(c_str: LPCWSTR, hFile: HANDLE, dwFlags: LoadLibraryEx_Flags) -> HMODULE ---
 	FreeLibrary :: proc(h: HMODULE) -> BOOL ---
 	GetProcAddress :: proc(h: HMODULE, c_str: LPCSTR) -> rawptr ---
-	LoadLibraryExW :: proc(c_str: LPCWSTR, file: HANDLE, flags: LoadLibraryEx_Flags) -> HMODULE ---
 
+	LoadResource :: proc(hModule: HMODULE, hResInfo: HRSRC) -> HGLOBAL ---
+	FreeResource :: proc(hResData: HGLOBAL) -> BOOL ---
+	LockResource :: proc(hResData: HGLOBAL) -> LPVOID ---
+	SizeofResource :: proc(hModule: HMODULE, hResInfo: HRSRC) -> DWORD ---
+	FindResourceW :: proc(hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR) -> HRSRC ---
+	FindResourceExW :: proc(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: LANGID) -> HRSRC ---
+	EnumResourceNamesW :: proc(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR) -> BOOL ---
+	EnumResourceNamesExW :: proc(hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID) -> BOOL ---
+	EnumResourceTypesExW :: proc(hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID) -> BOOL ---
+	EnumResourceLanguagesExW :: proc(hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID) -> BOOL ---
+	LookupIconIdFromDirectory :: proc(presbits: PBYTE, fIcon: BOOL) -> INT ---
+	LookupIconIdFromDirectoryEx :: proc(presbits: PBYTE, fIcon: BOOL, cxDesired: INT, cyDesired: INT, Flags: UINT) -> INT ---
+	CreateIconFromResourceEx :: proc(presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD, cxDesired: INT, cyDesired: INT, Flags: UINT) -> HICON ---
 
 	GetFullPathNameW  :: proc(filename: LPCWSTR, buffer_length: DWORD, buffer: LPCWSTR, file_part: ^LPCWSTR) -> DWORD ---
 	GetLongPathNameW  :: proc(short, long: LPCWSTR, len: DWORD) -> DWORD ---

core/sys/windows/ole32.odin

@@ -40,7 +40,8 @@ LPUNKNOWN :: ^IUnknown
 
 @(default_calling_convention="system")
 foreign Ole32 {
-	CoInitializeEx :: proc(reserved: rawptr, co_init: COINIT) -> HRESULT ---
+	CoInitialize :: proc(reserved: rawptr = nil) -> HRESULT ---
+	CoInitializeEx :: proc(reserved: rawptr = nil, co_init: COINIT = .APARTMENTTHREADED) -> HRESULT ---
 	CoUninitialize :: proc() ---
 
 	CoCreateInstance :: proc(
@@ -52,4 +53,17 @@ foreign Ole32 {
 	) -> HRESULT ---
 
 	CoTaskMemFree :: proc(pv: rawptr) ---
+
+	CLSIDFromProgID :: proc(lpszProgID: LPCOLESTR, lpclsid: LPCLSID) -> HRESULT ---
+	CLSIDFromProgIDEx :: proc(lpszProgID, LPCOLESTR, lpclsid: LPCLSID) -> HRESULT ---
+	CLSIDFromString :: proc(lpsz: LPOLESTR, pclsid: LPCLSID) -> HRESULT ---
+	IIDFromString :: proc(lpsz: LPOLESTR, lpiid: LPIID) -> HRESULT ---
+	ProgIDFromCLSID :: proc(clsid: REFCLSID, lplpszProgID: ^LPOLESTR) -> HRESULT ---
+	StringFromCLSID :: proc(rclsid: REFCLSID, lplpsz: ^LPOLESTR) -> HRESULT ---
+	StringFromGUID2 :: proc(rclsid: REFCLSID, lplpsz: LPOLESTR, cchMax: INT) -> INT ---
+	StringFromIID :: proc(rclsid: REFIID, lplpsz: ^LPOLESTR) -> HRESULT ---
+
+	PropVariantClear :: proc(pvar: ^PROPVARIANT) -> HRESULT ---
+	PropVariantCopy :: proc(pvarDest: ^PROPVARIANT, pvarSrc: ^PROPVARIANT) -> HRESULT ---
+	FreePropVariantArray :: proc(cVariants: ULONG, rgvars: ^PROPVARIANT) -> HRESULT ---
 }

core/sys/windows/shcore.odin

@@ -0,0 +1,25 @@
+// +build windows
+
+package sys_windows
+
+foreign import shcore "system:Shcore.lib"
+
+@(default_calling_convention="system")
+foreign shcore {
+	GetProcessDpiAwareness :: proc(hprocess: HANDLE, value: ^PROCESS_DPI_AWARENESS) -> HRESULT ---
+	SetProcessDpiAwareness :: proc(value: PROCESS_DPI_AWARENESS) -> HRESULT ---
+	GetDpiForMonitor :: proc(hmonitor: HMONITOR, dpiType: MONITOR_DPI_TYPE, dpiX: ^UINT, dpiY: ^UINT) -> HRESULT ---
+}
+
+PROCESS_DPI_AWARENESS :: enum DWORD {
+	PROCESS_DPI_UNAWARE = 0,
+	PROCESS_SYSTEM_DPI_AWARE = 1,
+	PROCESS_PER_MONITOR_DPI_AWARE = 2,
+}
+
+MONITOR_DPI_TYPE :: enum DWORD {
+	MDT_EFFECTIVE_DPI = 0,
+	MDT_ANGULAR_DPI = 1,
+	MDT_RAW_DPI = 2,
+	MDT_DEFAULT,
+}

core/sys/windows/shell32.odin

@@ -31,6 +31,7 @@ foreign shell32 {
 	SHSetKnownFolderPath :: proc(rfid: REFKNOWNFOLDERID, dwFlags: /* KNOWN_FOLDER_FLAG */ DWORD, hToken: HANDLE, pszPath: PCWSTR ) -> HRESULT ---
 	SHGetKnownFolderPath :: proc(rfid: REFKNOWNFOLDERID, dwFlags: /* KNOWN_FOLDER_FLAG */ DWORD, hToken: HANDLE, ppszPath: ^LPWSTR) -> HRESULT ---
 
+	ExtractIconExW :: proc(pszFile: LPCWSTR, nIconIndex: INT, phiconLarge: ^HICON, phiconSmall: ^HICON, nIcons: UINT) -> UINT ---
 	DragAcceptFiles :: proc(hWnd: HWND, fAccept: BOOL) ---
 	DragQueryPoint :: proc(hDrop: HDROP, ppt: ^POINT) -> BOOL ---
 	DragQueryFileW :: proc(hDrop: HDROP, iFile: UINT, lpszFile: LPWSTR, cch: UINT) -> UINT ---

core/sys/windows/types.odin

@@ -30,8 +30,10 @@ HICON :: distinct HANDLE
 HCURSOR :: distinct HANDLE
 HMENU :: distinct HANDLE
 HBRUSH :: distinct HANDLE
+HPEN :: distinct HANDLE
 HGDIOBJ :: distinct HANDLE
 HBITMAP :: distinct HANDLE
+HPALETTE :: distinct HANDLE
 HGLOBAL :: distinct HANDLE
 HHOOK :: distinct HANDLE
 HWINEVENTHOOK :: distinct HANDLE
@@ -39,6 +41,9 @@ HKEY :: distinct HANDLE
 HDESK :: distinct HANDLE
 HFONT :: distinct HANDLE
 HRGN :: distinct HANDLE
+HRSRC :: distinct HANDLE
+HWINSTA :: distinct HANDLE
+HACCEL :: distinct HANDLE
 BOOL :: distinct b32
 BYTE :: distinct u8
 BOOLEAN :: distinct b8
@@ -139,11 +144,14 @@ LPSTR :: ^CHAR
 LPWSTR :: ^WCHAR
 OLECHAR :: WCHAR
 LPOLESTR :: ^OLECHAR
+LPCOLESTR :: LPCSTR
 LPFILETIME :: ^FILETIME
 LPWSABUF :: ^WSABUF
 LPWSAOVERLAPPED :: distinct rawptr
 LPWSAOVERLAPPED_COMPLETION_ROUTINE :: distinct rawptr
 LPCVOID :: rawptr
+SCODE :: LONG
+PSCODE :: ^SCODE
 
 PACCESS_TOKEN :: PVOID
 PSECURITY_DESCRIPTOR :: PVOID
@@ -699,6 +707,92 @@ FW_BLACK      :: FW_HEAVY
 
 PTIMERAPCROUTINE :: #type proc "system" (lpArgToCompletionRoutine: LPVOID, dwTimerLowValue, dwTimerHighValue: DWORD)
 
+// Character Sets
+ANSI_CHARSET        :: 0
+DEFAULT_CHARSET     :: 1
+SYMBOL_CHARSET      :: 2
+SHIFTJIS_CHARSET    :: 128
+HANGEUL_CHARSET     :: 129
+HANGUL_CHARSET      :: 129
+GB2312_CHARSET      :: 134
+CHINESEBIG5_CHARSET :: 136
+OEM_CHARSET         :: 255
+JOHAB_CHARSET       :: 130
+HEBREW_CHARSET      :: 177
+ARABIC_CHARSET      :: 178
+GREEK_CHARSET       :: 161
+TURKISH_CHARSET     :: 162
+VIETNAMESE_CHARSET  :: 163
+THAI_CHARSET        :: 222
+EASTEUROPE_CHARSET  :: 238
+RUSSIAN_CHARSET     :: 204
+MAC_CHARSET         :: 77
+BALTIC_CHARSET      :: 186
+
+// Font Signature Bitmaps
+FS_LATIN1      :: 0x00000001
+FS_LATIN2      :: 0x00000002
+FS_CYRILLIC    :: 0x00000004
+FS_GREEK       :: 0x00000008
+FS_TURKISH     :: 0x00000010
+FS_HEBREW      :: 0x00000020
+FS_ARABIC      :: 0x00000040
+FS_BALTIC      :: 0x00000080
+FS_VIETNAMESE  :: 0x00000100
+FS_THAI        :: 0x00010000
+FS_JISJAPAN    :: 0x00020000
+FS_CHINESESIMP :: 0x00040000
+FS_WANSUNG     :: 0x00080000
+FS_CHINESETRAD :: 0x00100000
+FS_JOHAB       :: 0x00200000
+FS_SYMBOL      :: 0x80000000
+
+// Output Precisions
+OUT_DEFAULT_PRECIS        :: 0
+OUT_STRING_PRECIS         :: 1
+OUT_CHARACTER_PRECIS      :: 2
+OUT_STROKE_PRECIS         :: 3
+OUT_TT_PRECIS             :: 4
+OUT_DEVICE_PRECIS         :: 5
+OUT_RASTER_PRECIS         :: 6
+OUT_TT_ONLY_PRECIS        :: 7
+OUT_OUTLINE_PRECIS        :: 8
+OUT_SCREEN_OUTLINE_PRECIS :: 9
+OUT_PS_ONLY_PRECIS        :: 10
+
+// Clipping Precisions
+CLIP_DEFAULT_PRECIS   :: 0
+CLIP_CHARACTER_PRECIS :: 1
+CLIP_STROKE_PRECIS    :: 2
+CLIP_MASK             :: 0xf
+CLIP_LH_ANGLES        :: 1 << 4
+CLIP_TT_ALWAYS        :: 2 << 4
+CLIP_DFA_DISABLE      :: 4 << 4
+CLIP_EMBEDDED         :: 8 << 4
+
+// Output Qualities
+DEFAULT_QUALITY           :: 0
+DRAFT_QUALITY             :: 1
+PROOF_QUALITY             :: 2
+NONANTIALIASED_QUALITY    :: 3
+ANTIALIASED_QUALITY       :: 4
+CLEARTYPE_QUALITY         :: 5
+CLEARTYPE_NATURAL_QUALITY :: 6
+
+// Font Pitches
+DEFAULT_PITCH  :: 0
+FIXED_PITCH    :: 1
+VARIABLE_PITCH :: 2
+MONO_FONT      :: 8
+
+// Font Families
+FF_DONTCARE   :: 0 << 4
+FF_ROMAN      :: 1 << 4
+FF_SWISS      :: 2 << 4
+FF_MODERN     :: 3 << 4
+FF_SCRIPT     :: 4 << 4
+FF_DECORATIVE :: 5 << 4
+
 TIMERPROC :: #type proc "system" (HWND, UINT, UINT_PTR, DWORD)
 
 WNDPROC :: #type proc "system" (HWND, UINT, WPARAM, LPARAM) -> LRESULT
@@ -932,6 +1026,16 @@ MF_RIGHTJUSTIFY :: 0x00004000
 MF_MOUSESELECT :: 0x00008000
 MF_END :: 0x00000080  // Obsolete -- only used by old RES files
 
+// Menu flags for Add/Check/EnableMenuItem()
+MFS_GRAYED    :: 0x00000003
+MFS_DISABLED  :: MFS_GRAYED
+MFS_CHECKED   :: MF_CHECKED
+MFS_HILITE    :: MF_HILITE
+MFS_ENABLED   :: MF_ENABLED
+MFS_UNCHECKED :: MF_UNCHECKED
+MFS_UNHILITE  :: MF_UNHILITE
+MFS_DEFAULT   :: MF_DEFAULT
+
 // Flags for TrackPopupMenu
 TPM_LEFTBUTTON :: 0x0000
 TPM_RIGHTBUTTON :: 0x0002
@@ -1037,9 +1141,6 @@ WIN32_FIND_DATAW :: struct {
 	dwReserved1:        DWORD,
 	cFileName:          [MAX_PATH]WCHAR,
 	cAlternateFileName: [14]WCHAR,
-	_OBSOLETE_dwFileType:    DWORD, // Obsolete. Do not use.
-	_OBSOLETE_dwCreatorType: DWORD, // Obsolete. Do not use
-	_OBSOLETE_wFinderFlags:  WORD,  // Obsolete. Do not use
 }
 
 FILE_ID_128 :: struct {
@@ -2207,6 +2308,14 @@ CP_SYMBOL     :: 42    // SYMBOL translations
 CP_UTF7       :: 65000 // UTF-7 translation
 CP_UTF8       :: 65001 // UTF-8 translation
 
+LCID :: DWORD
+LANGID :: WORD
+
+LANG_NEUTRAL :: 0x00
+LANG_INVARIANT :: 0x7f
+SUBLANG_NEUTRAL :: 0x00 // language neutral
+SUBLANG_DEFAULT :: 0x01 // user default
+
 MB_ERR_INVALID_CHARS :: 8
 WC_ERR_INVALID_CHARS :: 128
 
@@ -2422,8 +2531,10 @@ REFIID  :: ^GUID
 
 REFGUID :: GUID
 IID :: GUID
+LPIID :: ^IID
 CLSID :: GUID
 REFCLSID :: ^CLSID
+LPCLSID :: ^CLSID
 
 CLSCTX_INPROC_SERVER                  :: 0x1
 CLSCTX_INPROC_HANDLER                 :: 0x2
@@ -4391,7 +4502,7 @@ DNS_STATUS :: distinct DWORD // zero is success
 DNS_INFO_NO_RECORDS :: 9501
 DNS_QUERY_NO_RECURSION :: 0x00000004
 
-DNS_RECORD :: struct {
+DNS_RECORD :: struct { // aka DNS_RECORDA
     pNext: ^DNS_RECORD,
     pName: cstring,
     wType: WORD,
@@ -4435,6 +4546,10 @@ SOCKADDR :: struct {
 	sa_data:   [14]CHAR,
 }
 
+ENUMRESNAMEPROCW :: #type proc (hModule: HMODULE, lpType: LPCWSTR, lpName: LPWSTR, lParam: LONG_PTR)-> BOOL
+ENUMRESTYPEPROCW :: #type proc (hModule: HMODULE, lpType: LPCWSTR, lParam: LONG_PTR)-> BOOL
+ENUMRESLANGPROCW :: #type proc (hModule: HMODULE, lpType: LPCWSTR, lpName: LPWSTR, wIDLanguage: LANGID, lParam: LONG_PTR)-> BOOL
+
 DTR_Control :: enum byte {
 	Disable = 0,
 	Enable = 1,

core/sys/windows/user32.odin

@@ -6,19 +6,18 @@ foreign import user32 "system:User32.lib"
 
 @(default_calling_convention="system")
 foreign user32 {
-	GetClassInfoW :: proc(hInstance: HINSTANCE, lpClassNAme: LPCWSTR, lpWndClass: ^WNDCLASSW) -> BOOL ---
-	GetClassInfoExW :: proc(hInsatnce: HINSTANCE, lpszClass: LPCWSTR, lpwcx: ^WNDCLASSEXW) -> BOOL ---
+	GetClassInfoW :: proc(hInstance: HINSTANCE, lpClassName: LPCWSTR, lpWndClass: ^WNDCLASSW) -> BOOL ---
+	GetClassInfoExW :: proc(hInstance: HINSTANCE, lpszClass: LPCWSTR, lpwcx: ^WNDCLASSEXW) -> BOOL ---
 
-	GetClassLongW :: proc(hWnd: HWND, nIndex: c_int) -> DWORD ---
-	SetClassLongW :: proc(hWnd: HWND, nIndex: c_int, dwNewLong: LONG) -> DWORD ---
+	GetClassLongW :: proc(hWnd: HWND, nIndex: INT) -> DWORD ---
+	SetClassLongW :: proc(hWnd: HWND, nIndex: INT, dwNewLong: LONG) -> DWORD ---
 
-	GetWindowLongW :: proc(hWnd: HWND, nIndex: c_int) -> LONG ---
-	SetWindowLongW :: proc(hWnd: HWND, nIndex: c_int, dwNewLong: LONG) -> LONG ---
+	GetWindowLongW :: proc(hWnd: HWND, nIndex: INT) -> LONG ---
+	SetWindowLongW :: proc(hWnd: HWND, nIndex: INT, dwNewLong: LONG) -> LONG ---
 
-	GetClassNameW :: proc(hWnd: HWND, lpClassName: LPWSTR, nMaxCount: c_int) -> c_int ---
+	GetClassNameW :: proc(hWnd: HWND, lpClassName: LPWSTR, nMaxCount: INT) -> INT ---
 
 	GetParent :: proc(hWnd: HWND) -> HWND ---
-	IsWindowVisible :: proc(hWnd: HWND) -> BOOL ---
 	SetWinEventHook :: proc(
 		eventMin, eventMax: DWORD,
 		hmodWinEventProc: HMODULE,
@@ -38,10 +37,7 @@ foreign user32 {
 		lpClassName: LPCWSTR,
 		lpWindowName: LPCWSTR,
 		dwStyle: DWORD,
-		X: c_int,
-		Y: c_int,
-		nWidth: c_int,
-		nHeight: c_int,
+		X, Y, nWidth, nHeight: INT,
 		hWndParent: HWND,
 		hMenu: HMENU,
 		hInstance: HINSTANCE,
@@ -50,24 +46,33 @@ foreign user32 {
 
 	DestroyWindow :: proc(hWnd: HWND) -> BOOL ---
 
-	ShowWindow :: proc(hWnd: HWND, nCmdShow: c_int) -> BOOL ---
+	ShowWindow :: proc(hWnd: HWND, nCmdShow: INT) -> BOOL ---
 	IsWindow :: proc(hWnd: HWND) -> BOOL ---
+	IsWindowVisible :: proc(hwnd: HWND) -> BOOL ---
+	IsWindowEnabled :: proc(hwnd: HWND) -> BOOL ---
+	IsIconic :: proc(hwnd: HWND) -> BOOL ---
 	BringWindowToTop :: proc(hWnd: HWND) -> BOOL ---
 	GetTopWindow :: proc(hWnd: HWND) -> HWND ---
 	SetForegroundWindow :: proc(hWnd: HWND) -> BOOL ---
 	GetForegroundWindow :: proc() -> HWND ---
+	GetDesktopWindow :: proc() -> HWND ---
 	UpdateWindow :: proc(hWnd: HWND) -> BOOL ---
 	SetActiveWindow :: proc(hWnd: HWND) -> HWND ---
 	GetActiveWindow :: proc() -> HWND ---
 	RedrawWindow :: proc(hwnd: HWND, lprcUpdate: LPRECT, hrgnUpdate: HRGN, flags: RedrawWindowFlags) -> BOOL ---
-
+	SetParent :: proc(hWndChild: HWND, hWndNewParent: HWND) -> HWND ---
+	SetPropW :: proc(hWnd: HWND, lpString: LPCWSTR, hData: HANDLE) -> BOOL ---
+	GetPropW :: proc(hWnd: HWND, lpString: LPCWSTR) -> HANDLE ---
+	RemovePropW :: proc(hWnd: HWND, lpString: LPCWSTR) -> HANDLE ---
+	EnumPropsW :: proc(hWnd: HWND, lpEnumFunc: PROPENUMPROCW) -> INT ---
+	EnumPropsExW :: proc(hWnd: HWND, lpEnumFunc: PROPENUMPROCW, lParam: LPARAM) -> INT ---
 	GetMessageW :: proc(lpMsg: ^MSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT) -> BOOL ---
 
 	TranslateMessage :: proc(lpMsg: ^MSG) -> BOOL ---
 	DispatchMessageW :: proc(lpMsg: ^MSG) -> LRESULT ---
 
 	WaitMessage :: proc() -> BOOL ---
-	MsgWaitForMultipleObjects :: proc(nCount: DWORD, pHandles: ^HANDLE, fWaitAll: bool, dwMilliseconds: DWORD, dwWakeMask: DWORD) -> DWORD ---
+	MsgWaitForMultipleObjects :: proc(nCount: DWORD, pHandles: ^HANDLE, fWaitAll: BOOL, dwMilliseconds: DWORD, dwWakeMask: DWORD) -> DWORD ---
 
 	PeekMessageA :: proc(lpMsg: ^MSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT) -> BOOL ---
 	PeekMessageW :: proc(lpMsg: ^MSG, hWnd: HWND, wMsgFilterMin: UINT, wMsgFilterMax: UINT, wRemoveMsg: UINT) -> BOOL ---
@@ -80,7 +85,7 @@ foreign user32 {
 	PostThreadMessageA :: proc(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM) -> BOOL ---
 	PostThreadMessageW :: proc(idThread: DWORD, Msg: UINT, wParam: WPARAM, lParam: LPARAM) -> BOOL ---
 
-	PostQuitMessage :: proc(nExitCode: c_int) ---
+	PostQuitMessage :: proc(nExitCode: INT) ---
 
 	GetQueueStatus :: proc(flags: UINT) -> DWORD ---
 
@@ -94,33 +99,26 @@ foreign user32 {
 
 	LoadIconA :: proc(hInstance: HINSTANCE, lpIconName: LPCSTR) -> HICON ---
 	LoadIconW :: proc(hInstance: HINSTANCE, lpIconName: LPCWSTR) -> HICON ---
+	GetIconInfoExW :: proc(hIcon: HICON, piconinfo: PICONINFOEXW) -> BOOL ---
 	LoadCursorA :: proc(hInstance: HINSTANCE, lpCursorName: LPCSTR) -> HCURSOR ---
 	LoadCursorW :: proc(hInstance: HINSTANCE, lpCursorName: LPCWSTR) -> HCURSOR ---
-	LoadImageW :: proc(hInst: HINSTANCE, name: LPCWSTR, type: UINT, cx: c_int, cy: c_int, fuLoad: UINT) -> HANDLE ---
+	LoadImageW :: proc(hInst: HINSTANCE, name: LPCWSTR, type: UINT, cx, cy: INT, fuLoad: UINT) -> HANDLE ---
 
-	CreateIcon :: proc(hInstance: HINSTANCE, nWidth: c_int, nHeight: c_int, cPlanes: BYTE, cBitsPixel: BYTE, lpbANDbits: PBYTE, lpbXORbits: PBYTE) -> HICON ---
+	CreateIcon :: proc(hInstance: HINSTANCE, nWidth, nHeight: INT, cPlanes: BYTE, cBitsPixel: BYTE, lpbANDbits: PBYTE, lpbXORbits: PBYTE) -> HICON ---
 	CreateIconFromResource :: proc(presbits: PBYTE, dwResSize: DWORD, fIcon: BOOL, dwVer: DWORD) -> HICON ---
 	DestroyIcon :: proc(hIcon: HICON) -> BOOL ---
-	DrawIcon :: proc(hDC: HDC, X: c_int, Y: c_int, hIcon: HICON) -> BOOL ---
+	DrawIcon :: proc(hDC: HDC, X, Y: INT, hIcon: HICON) -> BOOL ---
 
-	CreateCursor :: proc(hInst: HINSTANCE, xHotSpot: c_int, yHotSpot: c_int, nWidth: c_int, nHeight: c_int, pvANDPlane: PVOID, pvXORPlane: PVOID) -> HCURSOR ---
+	CreateCursor :: proc(hInst: HINSTANCE, xHotSpot, yHotSpot, nWidth, nHeight: INT, pvANDPlane: PVOID, pvXORPlane: PVOID) -> HCURSOR ---
 	DestroyCursor :: proc(hCursor: HCURSOR) -> BOOL ---
 
 	GetWindowRect :: proc(hWnd: HWND, lpRect: LPRECT) -> BOOL ---
 	GetClientRect :: proc(hWnd: HWND, lpRect: LPRECT) -> BOOL ---
 	ClientToScreen :: proc(hWnd: HWND, lpPoint: LPPOINT) -> BOOL ---
 	ScreenToClient :: proc(hWnd: HWND, lpPoint: LPPOINT) -> BOOL ---
-	SetWindowPos :: proc(
-		hWnd: HWND,
-		hWndInsertAfter: HWND,
-		X: c_int,
-		Y: c_int,
-		cx: c_int,
-		cy: c_int,
-		uFlags: UINT,
-	) -> BOOL ---
-	MoveWindow :: proc(hWnd: HWND, X, Y, hWidth, hHeight: c_int, bRepaint: BOOL) -> BOOL ---
-	GetSystemMetrics :: proc(nIndex: c_int) -> c_int ---
+	SetWindowPos :: proc(hWnd: HWND, hWndInsertAfter: HWND, X, Y, cx, cy: INT, uFlags: UINT) -> BOOL ---
+	MoveWindow :: proc(hWnd: HWND, X, Y, hWidth, hHeight: INT, bRepaint: BOOL) -> BOOL ---
+	GetSystemMetrics :: proc(nIndex: INT) -> INT ---
 	AdjustWindowRect :: proc(lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL) -> BOOL ---
 	AdjustWindowRectEx :: proc(lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL, dwExStyle: DWORD) -> BOOL ---
 	AdjustWindowRectExForDpi :: proc(lpRect: LPRECT, dwStyle: DWORD, bMenu: BOOL, dwExStyle: DWORD, dpi: UINT) -> BOOL ---
@@ -130,18 +128,36 @@ foreign user32 {
 
 	GetWindowDC :: proc(hWnd: HWND) -> HDC ---
 	GetDC :: proc(hWnd: HWND) -> HDC ---
-	ReleaseDC :: proc(hWnd: HWND, hDC: HDC) -> c_int ---
+	GetDCEx :: proc(hWnd: HWND, hrgnClip: HRGN, flags: DWORD) -> HDC ---
+	ReleaseDC :: proc(hWnd: HWND, hDC: HDC) -> INT ---
 
-	GetDlgCtrlID :: proc(hWnd: HWND) -> c_int ---
-	GetDlgItem :: proc(hDlg: HWND, nIDDlgItem: c_int) -> HWND ---
+	GetDlgCtrlID :: proc(hWnd: HWND) -> INT ---
+	GetDlgItem :: proc(hDlg: HWND, nIDDlgItem: INT) -> HWND ---
 
+	CreateMenu :: proc() -> HMENU ---
 	CreatePopupMenu :: proc() -> HMENU ---
+	DeleteMenu :: proc(hMenu: HMENU, uPosition: UINT, uFlags: UINT) -> BOOL ---
 	DestroyMenu :: proc(hMenu: HMENU) -> BOOL ---
+	InsertMenuW :: proc(hMenu: HMENU, uPosition: UINT, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR) -> BOOL ---
 	AppendMenuW :: proc(hMenu: HMENU, uFlags: UINT, uIDNewItem: UINT_PTR, lpNewItem: LPCWSTR) -> BOOL ---
+	GetMenu :: proc(hWnd: HWND) -> HMENU ---
 	SetMenu :: proc(hWnd: HWND, hMenu: HMENU) -> BOOL ---
-	TrackPopupMenu :: proc(hMenu: HMENU, uFlags: UINT, x: int, y: int, nReserved: int, hWnd: HWND, prcRect: ^RECT) -> i32 ---
+	TrackPopupMenu :: proc(hMenu: HMENU, uFlags: UINT, x, y: INT, nReserved: INT, hWnd: HWND, prcRect: ^RECT) -> BOOL ---
 	RegisterWindowMessageW :: proc(lpString: LPCWSTR) -> UINT ---
 
+	CreateAcceleratorTableW :: proc(paccel: LPACCEL, cAccel: INT) -> HACCEL ---
+	DestroyAcceleratorTable :: proc(hAccel: HACCEL) -> BOOL ---
+	LoadAcceleratorsW :: proc(hInstance: HINSTANCE, lpTableName: LPCWSTR) -> HACCEL ---
+	TranslateAcceleratorW :: proc(hWnd: HWND, hAccTable: HACCEL, lpMsg: LPMSG) -> INT ---
+	CopyAcceleratorTableW :: proc(hAccelSrc: HACCEL, lpAccelDst: LPACCEL, cAccelEntries: INT) -> INT ---
+
+	InsertMenuItemW :: proc(hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmi: LPMENUITEMINFOW) -> BOOL ---
+	GetMenuItemInfoW :: proc(hmenu: HMENU, item: UINT, fByPosition: BOOL, lpmii: LPMENUITEMINFOW) -> BOOL ---
+	SetMenuItemInfoW :: proc(hmenu: HMENU, item: UINT, fByPositon: BOOL, lpmii: LPMENUITEMINFOW) -> BOOL ---
+	GetMenuDefaultItem :: proc(hMenu: HMENU, fByPos: UINT, gmdiFlags: UINT) -> UINT ---
+	SetMenuDefaultItem :: proc(hMenu: HMENU, uItem: UINT, fByPos: UINT) -> BOOL ---
+	GetMenuItemRect :: proc(hWnd: HWND, hMenu: HMENU, uItem: UINT, lprcItem: LPRECT) -> c_int ---
+
 	GetUpdateRect :: proc(hWnd: HWND, lpRect: LPRECT, bErase: BOOL) -> BOOL ---
 	ValidateRect :: proc(hWnd: HWND, lpRect: ^RECT) -> BOOL ---
 	InvalidateRect :: proc(hWnd: HWND, lpRect: ^RECT, bErase: BOOL) -> BOOL ---
@@ -154,34 +170,35 @@ foreign user32 {
 	ReleaseCapture :: proc() -> BOOL ---
 	TrackMouseEvent :: proc(lpEventTrack: LPTRACKMOUSEEVENT) -> BOOL ---
 
-	GetKeyState :: proc(nVirtKey: c_int) -> SHORT ---
-	GetAsyncKeyState :: proc(vKey: c_int) -> SHORT ---
+	GetKeyState :: proc(nVirtKey: INT) -> SHORT ---
+	GetAsyncKeyState :: proc(vKey: INT) -> SHORT ---
 
 	GetKeyboardState :: proc(lpKeyState: PBYTE) -> BOOL ---
 
 	MapVirtualKeyW :: proc(uCode: UINT, uMapType: UINT) -> UINT ---
-	ToUnicode :: proc(nVirtKey: UINT, wScanCode: UINT, lpKeyState: ^BYTE, pwszBuff: LPWSTR, cchBuff: c_int, wFlags: UINT) -> c_int ---
+	ToUnicode :: proc(nVirtKey: UINT, wScanCode: UINT, lpKeyState: ^BYTE, pwszBuff: LPWSTR, cchBuff: INT, wFlags: UINT) -> INT ---
 
-	SetWindowsHookExW :: proc(idHook: c_int, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD) -> HHOOK ---
+	SetWindowsHookExW :: proc(idHook: INT, lpfn: HOOKPROC, hmod: HINSTANCE, dwThreadId: DWORD) -> HHOOK ---
 	UnhookWindowsHookEx :: proc(hhk: HHOOK) -> BOOL ---
-	CallNextHookEx :: proc(hhk: HHOOK, nCode: c_int, wParam: WPARAM, lParam: LPARAM) -> LRESULT ---
+	CallNextHookEx :: proc(hhk: HHOOK, nCode: INT, wParam: WPARAM, lParam: LPARAM) -> LRESULT ---
 
 	SetTimer :: proc(hWnd: HWND, nIDEvent: UINT_PTR, uElapse: UINT, lpTimerFunc: TIMERPROC) -> UINT_PTR ---
 	KillTimer :: proc(hWnd: HWND, uIDEvent: UINT_PTR) -> BOOL ---
 
-	// MessageBoxA :: proc(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT) -> c_int ---
-	MessageBoxW :: proc(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT) -> c_int ---
-	// MessageBoxExA :: proc(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD) -> c_int ---
-	MessageBoxExW :: proc(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD) -> c_int ---
+	// MessageBoxA :: proc(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT) -> INT ---
+	MessageBoxW :: proc(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT) -> INT ---
+	// MessageBoxExA :: proc(hWnd: HWND, lpText: LPCSTR, lpCaption: LPCSTR, uType: UINT, wLanguageId: WORD) -> INT ---
+	MessageBoxExW :: proc(hWnd: HWND, lpText: LPCWSTR, lpCaption: LPCWSTR, uType: UINT, wLanguageId: WORD) -> INT ---
 
 	ClipCursor :: proc(lpRect: LPRECT) -> BOOL ---
 	GetCursorPos :: proc(lpPoint: LPPOINT) -> BOOL ---
-	SetCursorPos :: proc(X: c_int, Y: c_int) -> BOOL ---
+	SetCursorPos :: proc(X, Y: INT) -> BOOL ---
 	SetCursor :: proc(hCursor: HCURSOR) -> HCURSOR ---
 	when !intrinsics.is_package_imported("raylib") {
 		ShowCursor :: proc(bShow: BOOL) -> INT ---
 	}
 
+	EnumDisplayDevicesW :: proc (lpDevice: LPCWSTR, iDevNum: DWORD, lpDisplayDevice: PDISPLAY_DEVICEW, dwFlags: DWORD) -> BOOL ---
 	EnumDisplaySettingsW :: proc(lpszDeviceName: LPCWSTR, iModeNum: DWORD, lpDevMode: ^DEVMODEW) -> BOOL ---
 
 	MonitorFromPoint  :: proc(pt: POINT, dwFlags: Monitor_From_Flags) -> HMONITOR ---
@@ -191,6 +208,9 @@ foreign user32 {
 
 	EnumWindows :: proc(lpEnumFunc: Window_Enum_Proc, lParam: LPARAM) -> BOOL ---
 
+	IsProcessDPIAware :: proc() -> BOOL ---
+	SetProcessDPIAware :: proc() -> BOOL ---
+
 	SetThreadDpiAwarenessContext :: proc(dpiContext: DPI_AWARENESS_CONTEXT) -> DPI_AWARENESS_CONTEXT ---
 	GetThreadDpiAwarenessContext :: proc() -> DPI_AWARENESS_CONTEXT ---
 	GetWindowDpiAwarenessContext :: proc(hwnd: HWND) -> DPI_AWARENESS_CONTEXT ---
@@ -225,14 +245,14 @@ foreign user32 {
 		lpdwResult: PDWORD_PTR,
 	) -> LRESULT ---
 
-	GetSysColor :: proc(nIndex: c_int) -> DWORD ---
-	GetSysColorBrush :: proc(nIndex: c_int) -> HBRUSH ---
-	SetSysColors :: proc(cElements: c_int, lpaElements: ^INT, lpaRgbValues: ^COLORREF) -> BOOL ---
+	GetSysColor :: proc(nIndex: INT) -> DWORD ---
+	GetSysColorBrush :: proc(nIndex: INT) -> HBRUSH ---
+	SetSysColors :: proc(cElements: INT, lpaElements: ^INT, lpaRgbValues: ^COLORREF) -> BOOL ---
 	MessageBeep :: proc(uType: UINT) -> BOOL ---
 
 	IsDialogMessageW :: proc(hDlg: HWND, lpMsg: LPMSG) -> BOOL ---
-	GetWindowTextLengthW :: proc(hWnd: HWND) -> c_int ---
-	GetWindowTextW :: proc(hWnd: HWND, lpString: LPWSTR, nMaxCount: c_int) -> c_int ---
+	GetWindowTextLengthW :: proc(hWnd: HWND) -> INT ---
+	GetWindowTextW :: proc(hWnd: HWND, lpString: LPWSTR, nMaxCount: INT) -> INT ---
 	SetWindowTextW :: proc(hWnd: HWND, lpString: LPCWSTR) -> BOOL ---
 	CallWindowProcW :: proc(lpPrevWndFunc: WNDPROC, hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM) -> LRESULT ---
 	EnableWindow :: proc(hWnd: HWND, bEnable: BOOL) -> BOOL ---
@@ -245,12 +265,20 @@ foreign user32 {
 	GetRegisteredRawInputDevices :: proc(pRawInputDevices: PRAWINPUTDEVICE, puiNumDevices: PUINT, cbSize: UINT) -> UINT ---
 	RegisterRawInputDevices :: proc(pRawInputDevices: PCRAWINPUTDEVICE, uiNumDevices: UINT, cbSize: UINT) -> BOOL ---
 
-	SendInput :: proc(cInputs: UINT, pInputs: [^]INPUT, cbSize: c_int) -> UINT ---
+	SendInput :: proc(cInputs: UINT, pInputs: [^]INPUT, cbSize: INT) -> UINT ---
 
 	SetLayeredWindowAttributes  :: proc(hWnd: HWND, crKey: COLORREF, bAlpha: BYTE, dwFlags: DWORD) -> BOOL ---
 
 	FillRect :: proc(hDC: HDC, lprc: ^RECT, hbr: HBRUSH) -> int ---
-	EqualRect :: proc(lprc1: ^RECT, lprc2: ^RECT) -> BOOL ---
+	EqualRect :: proc(lprc1, lprc2: ^RECT) -> BOOL ---
+	OffsetRect :: proc(lprc1: ^RECT, dx, dy: INT) -> BOOL ---
+	InflateRect :: proc(lprc1: ^RECT, dx, dy: INT) -> BOOL ---
+	IntersectRect :: proc(lprcDst, lprcSrc1, lprcSrc2: ^RECT) -> BOOL ---
+	SubtractRect :: proc(lprcDst, lprcSrc1, lprcSrc2: ^RECT) -> BOOL ---
+	UnionRect :: proc(lprcDst, lprcSrc1, lprcSrc2: ^RECT) -> BOOL ---
+	IsRectEmpty :: proc(lprc: ^RECT) -> BOOL ---
+	SetRectEmpty :: proc(lprc: ^RECT) -> BOOL ---
+	CopyRect :: proc(lprcDst, lprcSrc: ^RECT) -> BOOL ---
 
 	GetWindowInfo :: proc(hwnd: HWND, pwi: PWINDOWINFO) -> BOOL ---
 	GetWindowPlacement :: proc(hWnd: HWND, lpwndpl: ^WINDOWPLACEMENT) -> BOOL ---
@@ -259,21 +287,34 @@ foreign user32 {
 	CreateRectRgnIndirect :: proc(lprect: ^RECT) -> HRGN ---
 	GetSystemMetricsForDpi :: proc(nIndex: int, dpi: UINT) -> int ---
 
+	GetCursorInfo :: proc(pci: PCURSORINFO) -> BOOL ---
+
 	GetSystemMenu :: proc(hWnd: HWND, bRevert: BOOL) -> HMENU ---
 	EnableMenuItem :: proc(hMenu: HMENU, uIDEnableItem: UINT, uEnable: UINT) -> BOOL ---
+	MenuItemFromPoint :: proc(hWnd: HWND, hMenu: HMENU, ptScreen: POINT) -> INT ---
 
 	DrawTextW :: proc(hdc: HDC, lpchText: LPCWSTR, cchText: INT, lprc: LPRECT, format: DrawTextFormat) -> INT ---
 	DrawTextExW :: proc(hdc: HDC, lpchText: LPCWSTR, cchText: INT, lprc: LPRECT, format: DrawTextFormat, lpdtp: PDRAWTEXTPARAMS) -> INT ---
+
+	GetLocaleInfoEx :: proc(lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: INT) -> INT ---
+	IsValidLocaleName :: proc(lpLocaleName: LPCWSTR) -> BOOL ---
+	ResolveLocaleName :: proc(lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: INT) -> INT ---
+	IsValidCodePage :: proc(CodePage: UINT) -> BOOL ---
+	GetACP :: proc() -> CODEPAGE ---
+	GetCPInfoExW :: proc(CodePage: CODEPAGE, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW) -> BOOL ---
+
+	GetProcessWindowStation :: proc() -> HWINSTA ---
+	GetUserObjectInformationW :: proc(hObj: HANDLE, nIndex: GetUserObjectInformationFlags, pvInfo: PVOID, nLength: DWORD, lpnLengthNeeded: LPDWORD) -> BOOL ---
 }
 
 CreateWindowW :: #force_inline proc "system" (
 	lpClassName: LPCTSTR,
 	lpWindowName: LPCTSTR,
 	dwStyle: DWORD,
-	X: c_int,
-	Y: c_int,
-	nWidth: c_int,
-	nHeight: c_int,
+	X: INT,
+	Y: INT,
+	nWidth: INT,
+	nHeight: INT,
 	hWndParent: HWND,
 	hMenu: HMENU,
 	hInstance: HINSTANCE,
@@ -298,11 +339,11 @@ CreateWindowW :: #force_inline proc "system" (
 when ODIN_ARCH == .amd64 {
 	@(default_calling_convention="system")
 	foreign user32 {
-		GetClassLongPtrW :: proc(hWnd: HWND, nIndex: c_int) -> ULONG_PTR ---
-		SetClassLongPtrW :: proc(hWnd: HWND, nIndex: c_int, dwNewLong: LONG_PTR) -> ULONG_PTR ---
+		GetClassLongPtrW :: proc(hWnd: HWND, nIndex: INT) -> ULONG_PTR ---
+		SetClassLongPtrW :: proc(hWnd: HWND, nIndex: INT, dwNewLong: LONG_PTR) -> ULONG_PTR ---
 
-		GetWindowLongPtrW :: proc(hWnd: HWND, nIndex: c_int) -> LONG_PTR ---
-		SetWindowLongPtrW :: proc(hWnd: HWND, nIndex: c_int, dwNewLong: LONG_PTR) -> LONG_PTR ---
+		GetWindowLongPtrW :: proc(hWnd: HWND, nIndex: INT) -> LONG_PTR ---
+		SetWindowLongPtrW :: proc(hWnd: HWND, nIndex: INT, dwNewLong: LONG_PTR) -> LONG_PTR ---
 	}
 } else when ODIN_ARCH == .i386 {
 	GetClassLongPtrW :: GetClassLongW
@@ -312,8 +353,8 @@ when ODIN_ARCH == .amd64 {
 	SetWindowLongPtrW :: SetWindowLongW
 }
 
-GET_SC_WPARAM :: #force_inline proc "contextless" (wParam: WPARAM) -> c_int {
-	return c_int(wParam) & 0xFFF0
+GET_SC_WPARAM :: #force_inline proc "contextless" (wParam: WPARAM) -> INT {
+	return INT(wParam) & 0xFFF0
 }
 
 GET_WHEEL_DELTA_WPARAM :: #force_inline proc "contextless" (wParam: WPARAM) -> c_short {
@@ -332,6 +373,10 @@ GET_XBUTTON_WPARAM :: #force_inline proc "contextless" (wParam: WPARAM) -> WORD
 	return HIWORD(cast(DWORD)wParam)
 }
 
+GET_RAWINPUT_CODE_WPARAM :: #force_inline proc "contextless" (wParam: WPARAM) -> BYTE {
+	return BYTE(wParam) & 0xFF
+}
+
 MAKEINTRESOURCEW :: #force_inline proc "contextless" (#any_int i: int) -> LPWSTR {
 	return cast(LPWSTR)uintptr(WORD(i))
 }
@@ -512,8 +557,8 @@ WINDOWPLACEMENT :: struct {
 	flags: UINT,
 	showCmd: UINT,
 	ptMinPosition: POINT,
-  	ptMaxPosition: POINT,
-  	rcNormalPosition: RECT,
+	ptMaxPosition: POINT,
+	rcNormalPosition: RECT,
 }
 
 WINDOWINFO :: struct {
@@ -530,11 +575,20 @@ WINDOWINFO :: struct {
 }
 PWINDOWINFO :: ^WINDOWINFO
 
+CURSORINFO :: struct {
+	cbSize: DWORD,
+	flags: DWORD,
+	hCursor: HCURSOR,
+	ptScreenPos: POINT,
+}
+PCURSORINFO :: ^CURSORINFO
+
+
 DRAWTEXTPARAMS :: struct {
 	cbSize: UINT,
-	iTabLength: int,
-	iLeftMargin: int,
-	iRightMargin: int,
+	iTabLength: INT,
+	iLeftMargin: INT,
+	iRightMargin: INT,
 	uiLengthDrawn: UINT,
 }
 PDRAWTEXTPARAMS :: ^DRAWTEXTPARAMS
@@ -581,11 +635,103 @@ RedrawWindowFlags :: enum UINT {
 	RDW_NOFRAME         = 0x0800,
 }
 
+GetUserObjectInformationFlags :: enum INT {
+	UOI_FLAGS      = 1,
+	UOI_NAME       = 2,
+	UOI_TYPE       = 3,
+	UOI_USER_SID   = 4,
+	UOI_HEAPSIZE   = 5,
+	UOI_IO         = 6,
+	UOI_TIMERPROC_EXCEPTION_SUPPRESSION = 7,
+}
+
+USEROBJECTFLAGS :: struct  {
+	fInherit: BOOL,
+	fReserved: BOOL,
+	dwFlags: DWORD,
+}
+
+PROPENUMPROCW :: #type proc(unnamedParam1: HWND, unnamedParam2: LPCWSTR, unnamedParam3: HANDLE) -> BOOL
+PROPENUMPROCEXW :: #type proc(unnamedParam1: HWND, unnamedParam2: LPCWSTR, unnamedParam3: HANDLE, unnamedParam4: ULONG_PTR) -> BOOL
+
+RT_CURSOR       :: LPWSTR(uintptr(0x00000001))
+RT_BITMAP       :: LPWSTR(uintptr(0x00000002))
+RT_ICON         :: LPWSTR(uintptr(0x00000003))
+RT_MENU         :: LPWSTR(uintptr(0x00000004))
+RT_DIALOG       :: LPWSTR(uintptr(0x00000005))
+RT_STRING       :: LPWSTR(uintptr(0x00000006))
+RT_FONTDIR      :: LPWSTR(uintptr(0x00000007))
+RT_FONT         :: LPWSTR(uintptr(0x00000008))
+RT_ACCELERATOR  :: LPWSTR(uintptr(0x00000009))
+RT_RCDATA       :: LPWSTR(uintptr(0x0000000A))
+RT_MESSAGETABLE :: LPWSTR(uintptr(0x0000000B))
+RT_GROUP_CURSOR :: LPWSTR(uintptr(0x0000000C))
+RT_GROUP_ICON   :: LPWSTR(uintptr(0x0000000E))
+RT_VERSION      :: LPWSTR(uintptr(0x00000010))
+RT_DLGINCLUDE   :: LPWSTR(uintptr(0x00000011))
+RT_PLUGPLAY     :: LPWSTR(uintptr(0x00000013))
+RT_VXD          :: LPWSTR(uintptr(0x00000014))
+RT_ANICURSOR    :: LPWSTR(uintptr(0x00000015))
+RT_ANIICON      :: LPWSTR(uintptr(0x00000016))
+RT_MANIFEST     :: LPWSTR(uintptr(0x00000018))
+
+CREATEPROCESS_MANIFEST_RESOURCE_ID                 :: LPWSTR(uintptr(0x00000001))
+ISOLATIONAWARE_MANIFEST_RESOURCE_ID                :: LPWSTR(uintptr(0x00000002))
+ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID :: LPWSTR(uintptr(0x00000003))
+ISOLATIONPOLICY_MANIFEST_RESOURCE_ID               :: LPWSTR(uintptr(0x00000004))
+ISOLATIONPOLICY_BROWSER_MANIFEST_RESOURCE_ID       :: LPWSTR(uintptr(0x00000005))
+MINIMUM_RESERVED_MANIFEST_RESOURCE_ID              :: LPWSTR(uintptr(0x00000001))
+MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID              :: LPWSTR(uintptr(0x00000010))
+
+ACCEL :: struct {
+	/* Also called the flags field */
+	fVirt: BYTE,
+	key: WORD,
+	cmd: WORD,
+}
+LPACCEL :: ^ACCEL
+
+MIIM_STATE      :: 0x00000001
+MIIM_ID         :: 0x00000002
+MIIM_SUBMENU    :: 0x00000004
+MIIM_CHECKMARKS :: 0x00000008
+MIIM_TYPE       :: 0x00000010
+MIIM_DATA       :: 0x00000020
+
+MIIM_STRING :: 0x00000040
+MIIM_BITMAP :: 0x00000080
+MIIM_FTYPE  :: 0x00000100
+
+MENUITEMINFOW :: struct {
+	cbSize: UINT,
+	fMask: UINT,
+	fType: UINT,         // used if MIIM_TYPE (4.0) or MIIM_FTYPE (>4.0)
+	fState: UINT,        // used if MIIM_STATE
+	wID: UINT,           // used if MIIM_ID
+	hSubMenu: HMENU,      // used if MIIM_SUBMENU
+	hbmpChecked: HBITMAP,   // used if MIIM_CHECKMARKS
+	hbmpUnchecked: HBITMAP, // used if MIIM_CHECKMARKS
+	dwItemData: ULONG_PTR,   // used if MIIM_DATA
+	dwTypeData: LPWSTR,    // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
+	cch: UINT,           // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0)
+	hbmpItem: HBITMAP,      // used if MIIM_BITMAP
+}
+LPMENUITEMINFOW :: ^MENUITEMINFOW
+DISPLAY_DEVICEW :: struct {
+	cb: DWORD,
+	DeviceName: [32]WCHAR,
+	DeviceString: [128]WCHAR,
+	StateFlags: DWORD,
+	DeviceID: [128]WCHAR,
+	DeviceKey: [128]WCHAR,
+}
+PDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW
+
 // OUTOFCONTEXT is the zero value, use {}
 WinEventFlags :: bit_set[WinEventFlag; DWORD]
 
 WinEventFlag :: enum DWORD {
-    SKIPOWNTHREAD  = 0,
-    SKIPOWNPROCESS = 1,
-    INCONTEXT      = 2,
+	SKIPOWNTHREAD  = 0,
+	SKIPOWNPROCESS = 1,
+	INCONTEXT      = 2,
 }

core/sys/windows/util.odin

@@ -6,22 +6,79 @@ import "base:intrinsics"
 
 L :: intrinsics.constant_utf16_cstring
 
-LOWORD :: #force_inline proc "contextless" (x: DWORD) -> WORD {
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/makeword
+MAKEWORD :: #force_inline proc "contextless" (#any_int a, b: int) -> WORD {
+	return WORD(BYTE(DWORD_PTR(a) & 0xff)) | (WORD(BYTE(DWORD_PTR(b) & 0xff)) << 8)
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/makelong
+MAKELONG :: #force_inline proc "contextless" (#any_int a, b: int) -> LONG {
+	return LONG(WORD(DWORD_PTR(a) & 0xffff)) | (LONG(WORD(DWORD_PTR(b) & 0xffff)) << 16)
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/loword
+LOWORD :: #force_inline proc "contextless" (#any_int x: int) -> WORD {
 	return WORD(x & 0xffff)
 }
 
-HIWORD :: #force_inline proc "contextless" (x: DWORD) -> WORD {
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/hiword
+HIWORD :: #force_inline proc "contextless" (#any_int x: int) -> WORD {
 	return WORD(x >> 16)
 }
 
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/lobyte
+LOBYTE :: #force_inline proc "contextless" (w: WORD) -> BYTE {
+	return BYTE((DWORD_PTR(w)) & 0xff)
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/winmsg/hibyte
+HIBYTE :: #force_inline proc "contextless" (w: WORD) -> BYTE {
+	return BYTE(((DWORD_PTR(w)) >> 8) & 0xff)
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-makewparam
+MAKEWPARAM :: #force_inline proc "contextless" (#any_int l, h: int) -> WPARAM {
+	return WPARAM(MAKELONG(l, h))
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-makelparam
+MAKELPARAM :: #force_inline proc "contextless" (#any_int l, h: int) -> LPARAM {
+	return LPARAM(MAKELONG(l, h))
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-makelresult
+MAKELRESULT :: #force_inline proc "contextless" (#any_int l, h: int) -> LRESULT {
+	return LRESULT(MAKELONG(l, h))
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/windowsx/nf-windowsx-get_x_lparam
 GET_X_LPARAM :: #force_inline proc "contextless" (lp: LPARAM) -> c_int {
 	return cast(c_int)cast(c_short)LOWORD(cast(DWORD)lp)
 }
 
+// https://learn.microsoft.com/en-us/windows/win32/api/windowsx/nf-windowsx-get_y_lparam
 GET_Y_LPARAM :: #force_inline proc "contextless" (lp: LPARAM) -> c_int {
 	return cast(c_int)cast(c_short)HIWORD(cast(DWORD)lp)
 }
 
+// https://learn.microsoft.com/en-us/windows/win32/api/winnt/nf-winnt-makelcid
+MAKELCID :: #force_inline proc "contextless" (lgid, srtid: WORD) -> LCID {
+	return (DWORD(WORD(srtid)) << 16) | DWORD(WORD(lgid))
+}
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winnt/nf-winnt-makelangid
+MAKELANGID :: #force_inline proc "contextless" (p, s: WORD) -> DWORD {
+	return DWORD(WORD(s)) << 10 | DWORD(WORD(p))
+}
+
+LANGIDFROMLCID :: #force_inline proc "contextless" (lcid: LCID) -> LANGID {
+	return LANGID(lcid)
+}
+
+// this one gave me trouble as it do not mask the values.
+// the _ in the name is also off comparing to the c code
+// i can't find any usage in the odin repo
+@(deprecated = "use MAKEWORD")
 MAKE_WORD :: #force_inline proc "contextless" (x, y: WORD) -> WORD {
 	return x << 8 | y
 }

core/sys/windows/winerror.odin

@@ -1,6 +1,189 @@
 // +build windows
 package sys_windows
 
+// https://learn.microsoft.com/en-us/windows/win32/api/winerror/
+
+//  Values are 32 bit values laid out as follows:
+//
+//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+//  +---+-+-+-----------------------+-------------------------------+
+//  |Sev|C|R|     Facility          |               Code            |
+//  +---+-+-+-----------------------+-------------------------------+
+//
+//  where
+//
+//      Sev - is the severity code
+//
+//          00 - Success
+//          01 - Informational
+//          10 - Warning
+//          11 - Error
+//
+//      C - is the Customer code flag
+//
+//      R - is a reserved bit
+//
+//      Facility - is the facility code
+//
+//      Code - is the facility's status code
+
+// Define the facility codes
+FACILITY :: enum DWORD {
+	NULL                                     = 0,
+	RPC                                      = 1,
+	DISPATCH                                 = 2,
+	STORAGE                                  = 3,
+	ITF                                      = 4,
+	WIN32                                    = 7,
+	WINDOWS                                  = 8,
+	SSPI                                     = 9,
+	SECURITY                                 = 9,
+	CONTROL                                  = 10,
+	CERT                                     = 11,
+	INTERNET                                 = 12,
+	MEDIASERVER                              = 13,
+	MSMQ                                     = 14,
+	SETUPAPI                                 = 15,
+	SCARD                                    = 16,
+	COMPLUS                                  = 17,
+	AAF                                      = 18,
+	URT                                      = 19,
+	ACS                                      = 20,
+	DPLAY                                    = 21,
+	UMI                                      = 22,
+	SXS                                      = 23,
+	WINDOWS_CE                               = 24,
+	HTTP                                     = 25,
+	USERMODE_COMMONLOG                       = 26,
+	WER                                      = 27,
+	USERMODE_FILTER_MANAGER                  = 31,
+	BACKGROUNDCOPY                           = 32,
+	CONFIGURATION                            = 33,
+	WIA                                      = 33,
+	STATE_MANAGEMENT                         = 34,
+	METADIRECTORY                            = 35,
+	WINDOWSUPDATE                            = 36,
+	DIRECTORYSERVICE                         = 37,
+	GRAPHICS                                 = 38,
+	SHELL                                    = 39,
+	NAP                                      = 39,
+	TPM_SERVICES                             = 40,
+	TPM_SOFTWARE                             = 41,
+	UI                                       = 42,
+	XAML                                     = 43,
+	ACTION_QUEUE                             = 44,
+	PLA                                      = 48,
+	WINDOWS_SETUP                            = 48,
+	FVE                                      = 49,
+	FWP                                      = 50,
+	WINRM                                    = 51,
+	NDIS                                     = 52,
+	USERMODE_HYPERVISOR                      = 53,
+	CMI                                      = 54,
+	USERMODE_VIRTUALIZATION                  = 55,
+	USERMODE_VOLMGR                          = 56,
+	BCD                                      = 57,
+	USERMODE_VHD                             = 58,
+	USERMODE_HNS                             = 59,
+	SDIAG                                    = 60,
+	WEBSERVICES                              = 61,
+	WINPE                                    = 61,
+	WPN                                      = 62,
+	WINDOWS_STORE                            = 63,
+	INPUT                                    = 64,
+	QUIC                                     = 65,
+	EAP                                      = 66,
+	IORING                                   = 70,
+	WINDOWS_DEFENDER                         = 80,
+	OPC                                      = 81,
+	XPS                                      = 82,
+	MBN                                      = 84,
+	POWERSHELL                               = 84,
+	RAS                                      = 83,
+	P2P_INT                                  = 98,
+	P2P                                      = 99,
+	DAF                                      = 100,
+	BLUETOOTH_ATT                            = 101,
+	AUDIO                                    = 102,
+	STATEREPOSITORY                          = 103,
+	VISUALCPP                                = 109,
+	SCRIPT                                   = 112,
+	PARSE                                    = 113,
+	BLB                                      = 120,
+	BLB_CLI                                  = 121,
+	WSBAPP                                   = 122,
+	BLBUI                                    = 128,
+	USN                                      = 129,
+	USERMODE_VOLSNAP                         = 130,
+	TIERING                                  = 131,
+	WSB_ONLINE                               = 133,
+	ONLINE_ID                                = 134,
+	DEVICE_UPDATE_AGENT                      = 135,
+	DRVSERVICING                             = 136,
+	DLS                                      = 153,
+	DELIVERY_OPTIMIZATION                    = 208,
+	USERMODE_SPACES                          = 231,
+	USER_MODE_SECURITY_CORE                  = 232,
+	USERMODE_LICENSING                       = 234,
+	SOS                                      = 160,
+	OCP_UPDATE_AGENT                         = 173,
+	DEBUGGERS                                = 176,
+	SPP                                      = 256,
+	RESTORE                                  = 256,
+	DMSERVER                                 = 256,
+	DEPLOYMENT_SERVICES_SERVER               = 257,
+	DEPLOYMENT_SERVICES_IMAGING              = 258,
+	DEPLOYMENT_SERVICES_MANAGEMENT           = 259,
+	DEPLOYMENT_SERVICES_UTIL                 = 260,
+	DEPLOYMENT_SERVICES_BINLSVC              = 261,
+	DEPLOYMENT_SERVICES_PXE                  = 263,
+	DEPLOYMENT_SERVICES_TFTP                 = 264,
+	DEPLOYMENT_SERVICES_TRANSPORT_MANAGEMENT = 272,
+	DEPLOYMENT_SERVICES_DRIVER_PROVISIONING  = 278,
+	DEPLOYMENT_SERVICES_MULTICAST_SERVER     = 289,
+	DEPLOYMENT_SERVICES_MULTICAST_CLIENT     = 290,
+	DEPLOYMENT_SERVICES_CONTENT_PROVIDER     = 293,
+	HSP_SERVICES                             = 296,
+	HSP_SOFTWARE                             = 297,
+	LINGUISTIC_SERVICES                      = 305,
+	AUDIOSTREAMING                           = 1094,
+	TTD                                      = 1490,
+	ACCELERATOR                              = 1536,
+	WMAAECMA                                 = 1996,
+	DIRECTMUSIC                              = 2168,
+	DIRECT3D10                               = 2169,
+	DXGI                                     = 2170,
+	DXGI_DDI                                 = 2171,
+	DIRECT3D11                               = 2172,
+	DIRECT3D11_DEBUG                         = 2173,
+	DIRECT3D12                               = 2174,
+	DIRECT3D12_DEBUG                         = 2175,
+	DXCORE                                   = 2176,
+	PRESENTATION                             = 2177,
+	LEAP                                     = 2184,
+	AUDCLNT                                  = 2185,
+	WINCODEC_DWRITE_DWM                      = 2200,
+	WINML                                    = 2192,
+	DIRECT2D                                 = 2201,
+	DEFRAG                                   = 2304,
+	USERMODE_SDBUS                           = 2305,
+	JSCRIPT                                  = 2306,
+	PIDGENX                                  = 2561,
+	EAS                                      = 85,
+	WEB                                      = 885,
+	WEB_SOCKET                               = 886,
+	MOBILE                                   = 1793,
+	SQLITE                                   = 1967,
+	SERVICE_FABRIC                           = 1968,
+	UTC                                      = 1989,
+	WEP                                      = 2049,
+	SYNCENGINE                               = 2050,
+	XBOX                                     = 2339,
+	GAME                                     = 2340,
+	PIX                                      = 2748,
+}
+
 ERROR_SUCCESS : DWORD : 0
 NO_ERROR :: 0
 SEC_E_OK : HRESULT : 0x00000000
@@ -42,14 +225,55 @@ ERROR_TIMEOUT                : DWORD : 1460
 ERROR_DATATYPE_MISMATCH      : DWORD : 1629
 ERROR_UNSUPPORTED_TYPE       : DWORD : 1630
 ERROR_NOT_SAME_OBJECT        : DWORD : 1656
-ERROR_PIPE_CONNECTED         : DWORD : 0x80070217
+ERROR_PIPE_CONNECTED         : DWORD : 535
 ERROR_PIPE_BUSY              : DWORD : 231
 
-E_NOTIMPL :: HRESULT(-0x7fff_bfff) // 0x8000_4001
+// https://learn.microsoft.com/en-us/windows/win32/seccrypto/common-hresult-values
+S_OK           :: 0x00000000 // Operation successful
+E_NOTIMPL      :: 0x80004001 // Not implemented
+E_NOINTERFACE  :: 0x80004002 // No such interface supported
+E_POINTER      :: 0x80004003 // Pointer that is not valid
+E_ABORT        :: 0x80004004 // Operation aborted
+E_FAIL         :: 0x80004005 // Unspecified failure
+E_UNEXPECTED   :: 0x8000FFFF // Unexpected failure
+E_ACCESSDENIED :: 0x80070005 // General access denied error
+E_HANDLE       :: 0x80070006 // Handle that is not valid
+E_OUTOFMEMORY  :: 0x8007000E // Failed to allocate necessary memory
+E_INVALIDARG   :: 0x80070057 // One or more arguments are not valid
+
+// Severity values
+SEVERITY :: enum DWORD {
+	SUCCESS = 0,
+	ERROR   = 1,
+}
+
+// Generic test for success on any status value (non-negative numbers indicate success).
+SUCCEEDED :: #force_inline proc "contextless" (#any_int result: int) -> bool { return result >= S_OK }
+// and the inverse
+FAILED :: #force_inline proc(#any_int result: int) -> bool { return result < S_OK }
 
-SUCCEEDED :: #force_inline proc "contextless" (#any_int result: int) -> bool { return result >= 0 }
+// Generic test for error on any status value.
+IS_ERROR :: #force_inline proc(#any_int status: int) -> bool { return u32(status) >> 31 == u32(SEVERITY.ERROR) }
 
+// Return the code
+HRESULT_CODE :: #force_inline proc(#any_int hr: int) -> int { return int(u32(hr) & 0xFFFF) }
+
+//  Return the facility
+HRESULT_FACILITY :: #force_inline proc(#any_int hr: int) -> FACILITY { return FACILITY((u32(hr) >> 16) & 0x1FFF) }
+
+//  Return the severity
+HRESULT_SEVERITY :: #force_inline proc(#any_int hr: int) -> SEVERITY { return SEVERITY((u32(hr) >> 31) & 0x1) }
+
+// Create an HRESULT value from component pieces
+MAKE_HRESULT :: #force_inline proc(#any_int sev: int, #any_int fac: int, #any_int code: int) -> HRESULT {
+	return HRESULT((uint(sev)<<31) | (uint(fac)<<16) | (uint(code)))
+}
+
+DECODE_HRESULT :: #force_inline proc(#any_int hr: int) -> (SEVERITY, FACILITY, int) {
+	return HRESULT_SEVERITY(hr), HRESULT_FACILITY(hr), HRESULT_CODE(hr)
+}
 
+// aka ERROR or WIN32_ERROR to hint the WIN32 facility
 System_Error :: enum DWORD {
 	// The operation completed successfully.
 	SUCCESS = 0x0,

core/sys/windows/winmm.odin

@@ -270,7 +270,7 @@ LPHWAVEOUT :: ^HWAVEOUT
 
 // https://learn.microsoft.com/en-us/windows/win32/multimedia/multimedia-timer-structures
 MMTIME :: struct {
-	wType: UINT,
+	wType: MMTIME_TYPE,
 	u: struct #raw_union {
 		ms: DWORD,
 		sample: DWORD,
@@ -292,6 +292,21 @@ MMTIME :: struct {
 }
 LPMMTIME :: ^MMTIME
 
+MMTIME_TYPE :: enum UINT {
+	/* time in milliseconds */
+	TIME_MS      = 0x0001,
+	/* number of wave samples */
+	TIME_SAMPLES = 0x0002,
+	/* current byte offset */
+	TIME_BYTES   = 0x0004,
+	/* SMPTE time */
+	TIME_SMPTE   = 0x0008,
+	/* MIDI time */
+	TIME_MIDI    = 0x0010,
+	/* Ticks within MIDI stream */
+	TIME_TICKS   = 0x0020,
+}
+
 MAXPNAMELEN :: 32
 MAXERRORLENGTH :: 256
 MMVERSION :: UINT

core/sys/windows/winnls.odin

@@ -0,0 +1,31 @@
+// +build windows
+package sys_windows
+
+LCTYPE :: distinct DWORD
+
+LOCALE_NAME_MAX_LENGTH     :: 85
+LOCALE_NAME_USER_DEFAULT   :: 0
+LOCALE_NAME_INVARIANT      : wstring = L("")
+LOCALE_NAME_SYSTEM_DEFAULT : wstring = L("!x-sys-default-locale")
+
+// String Length Maximums.
+// 5 ranges, 2 bytes ea., 0 term.
+MAX_LEADBYTES   :: 12
+// single or double byte
+MAX_DEFAULTCHAR :: 2
+
+CPINFOEXW :: struct{
+	// Maximum length, in bytes, of a character in the code page.
+	MaxCharSize: UINT,
+	// The default is usually the "?" character for the code page.
+	DefaultChar: [MAX_DEFAULTCHAR]BYTE,
+	// A fixed-length array of lead byte ranges, for which the number of lead byte ranges is variable.
+	LeadByte: [MAX_LEADBYTES]BYTE,
+	// The default is usually the "?" character or the katakana middle dot character.
+	UnicodeDefaultChar: WCHAR,
+	// Code page value. This value reflects the code page passed to the GetCPInfoEx function.
+	CodePage: CODEPAGE,
+	// Full name of the code page.
+	CodePageName: [MAX_PATH]WCHAR,
+}
+LPCPINFOEXW :: ^CPINFOEXW

core/sys/windows/winver.odin

@@ -0,0 +1,92 @@
+// +build windows
+package sys_windows
+
+foreign import version "system:version.lib"
+
+@(default_calling_convention = "system")
+foreign version {
+	GetFileVersionInfoSizeW :: proc(lpwstrFilename: LPCWSTR, lpdwHandle: LPDWORD) -> DWORD ---
+	GetFileVersionInfoW :: proc(lptstrFilename: LPCWSTR, dwHandle: DWORD, dwLen: DWORD, lpData: LPVOID) -> BOOL ---
+
+	GetFileVersionInfoSizeExW :: proc(dwFlags: FILE_VER_GET_FLAGS, lpwstrFilename: LPCWSTR, lpdwHandle: LPDWORD) -> DWORD ---
+	GetFileVersionInfoExW :: proc(dwFlags: FILE_VER_GET_FLAGS, lpwstrFilename: LPCWSTR, dwHandle, dwLen: DWORD, lpData: LPVOID) -> DWORD ---
+
+	VerLanguageNameW :: proc(wLang: DWORD, szLang: LPWSTR, cchLang: DWORD) -> DWORD ---
+	VerQueryValueW :: proc(pBlock: LPCVOID, lpSubBlock: LPCWSTR, lplpBuffer: ^LPVOID, puLen: PUINT) -> BOOL ---
+}
+
+FILE_VER_GET :: enum DWORD {LOCALISED, NEUTRAL, PREFETCHED}
+FILE_VER_GET_FLAGS :: bit_set[FILE_VER_GET; DWORD]
+
+/* ----- Symbols ----- */
+VS_FILE_INFO            :: RT_VERSION
+VS_VERSION_INFO         :: 1
+VS_USER_DEFINED         :: 100
+
+VS_FFI_SIGNATURE : DWORD : 0xFEEF04BD
+
+VS_FFI_STRUCVERSION     :: 0x00010000
+VS_FFI_FILEFLAGSMASK    :: 0x0000003F
+
+/* ----- VS_VERSION.dwFileFlags ----- */
+VS_FILEFLAG :: enum DWORD {
+	DEBUG,
+	PRERELEASE,
+	PATCHED,
+	PRIVATEBUILD,
+	INFOINFERRED,
+	SPECIALBUILD,
+}
+VS_FILEFLAGS :: bit_set[VS_FILEFLAG;DWORD]
+
+/* ----- VS_VERSION.dwFileOS ----- */
+VOS :: enum WORD {
+	UNKNOWN = 0x0000,
+	DOS     = 0x0001,
+	OS216   = 0x0002,
+	OS232   = 0x0003,
+	NT      = 0x0004,
+	WINCE   = 0x0005,
+}
+VOS2 :: enum WORD {
+	BASE      = 0x0000,
+	WINDOWS16 = 0x0001,
+	PM16      = 0x0002,
+	PM32      = 0x0003,
+	WINDOWS32 = 0x0004,
+}
+
+/* ----- VS_VERSION.dwFileType ----- */
+VFT :: enum DWORD {
+	UNKNOWN    = 0x00000000,
+	APP        = 0x00000001,
+	DLL        = 0x00000002,
+	DRV        = 0x00000003,
+	FONT       = 0x00000004,
+	VXD        = 0x00000005,
+	STATIC_LIB = 0x00000007,
+}
+
+/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_DRV ----- */
+VFT2_WINDOWS_DRV :: enum DWORD {
+	UNKNOWN               = 0x00000000,
+	DRV_PRINTER           = 0x00000001,
+	DRV_KEYBOARD          = 0x00000002,
+	DRV_LANGUAGE          = 0x00000003,
+	DRV_DISPLAY           = 0x00000004,
+	DRV_MOUSE             = 0x00000005,
+	DRV_NETWORK           = 0x00000006,
+	DRV_SYSTEM            = 0x00000007,
+	DRV_INSTALLABLE       = 0x00000008,
+	DRV_SOUND             = 0x00000009,
+	DRV_COMM              = 0x0000000A,
+	DRV_INPUTMETHOD       = 0x0000000B,
+	DRV_VERSIONED_PRINTER = 0x0000000C,
+}
+
+/* ----- VS_VERSION.dwFileSubtype for VFT_WINDOWS_FONT ----- */
+VFT2_WINDOWS_FONT :: enum DWORD {
+	FONT_RASTER   = 0x00000001,
+	FONT_VECTOR   = 0x00000002,
+	FONT_TRUETYPE = 0x00000003,
+}

tests/core/normal.odin

@@ -36,6 +36,7 @@ download_assets :: proc() {
 @(require) import "slice"
 @(require) import "strconv"
 @(require) import "strings"
+@(require) import "sys/windows"
 @(require) import "text/i18n"
 @(require) import "text/match"
 @(require) import "thread"

tests/core/sys/windows/test_kernel32.odin

@@ -0,0 +1,24 @@
+//+build windows
+package test_core_sys_windows
+
+import "base:intrinsics"
+import win32 "core:sys/windows"
+import "core:testing"
+
+@(test)
+lcid_to_local :: proc(t: ^testing.T) {
+	lcid: win32.LCID = win32.MAKELANGID(0x09, win32.SUBLANG_DEFAULT)
+	wname: [512]win32.WCHAR
+	cc := win32.LCIDToLocaleName(lcid, &wname[0], len(wname) - 1, 0)
+	testing.expectf(t, cc == 6, "%#x (should be: %#x)", u32(cc), 6)
+	if cc == 0 {return}
+	str, err := win32.wstring_to_utf8(win32.wstring(&wname), int(cc))
+	testing.expectf(t, err == .None, "%v (should be: %x)", err, 0)
+	exp :: "en-US"
+	testing.expectf(t, str == exp, "%v (should be: %v)", str, exp)
+
+	cc2 := win32.LocaleNameToLCID(L(exp), 0)
+	testing.expectf(t, cc2 == 0x0409, "%#x (should be: %#x)", u32(cc2), 0x0409)
+
+	//fmt.printfln("%0X", lcid)
+}

tests/core/sys/windows/test_ole32.odin

@@ -0,0 +1,62 @@
+//+build windows
+package test_core_sys_windows
+
+import "base:intrinsics"
+import win32 "core:sys/windows"
+import "core:testing"
+
+@(test)
+string_from_clsid :: proc(t: ^testing.T) {
+	p: win32.LPOLESTR
+	hr := win32.StringFromCLSID(win32.CLSID_FileOpenDialog, &p)
+	defer if p != nil {win32.CoTaskMemFree(p)}
+
+	testing.expectf(t, win32.SUCCEEDED(hr), "%x (should be: %x)", u32(hr), 0)
+	testing.expectf(t, p != nil, "%v is nil", p)
+
+	str, err := win32.wstring_to_utf8(p, 38)
+	testing.expectf(t, err == .None, "%v (should be: %x)", err, 0)
+	exp :: "{DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7}"
+	testing.expectf(t, str == exp, "%v (should be: %v)", str, exp)
+}
+
+@(test)
+clsid_from_string :: proc(t: ^testing.T) {
+	iid: win32.IID
+	hr := win32.CLSIDFromString(L("{D20BEEC4-5CA8-4905-AE3B-BF251EA09B53}"), &iid)
+	testing.expectf(t, win32.SUCCEEDED(hr), "%x (should be: %x)", u32(hr), 0)
+	exp := win32.FOLDERID_NetworkFolder
+	testing.expectf(t, iid == exp, "%v (should be: %v)", iid, exp)
+}
+
+@(test)
+string_from_iid :: proc(t: ^testing.T) {
+	p: win32.LPOLESTR
+	hr := win32.StringFromIID(win32.IID_IFileDialog, &p)
+	defer if p != nil {win32.CoTaskMemFree(p)}
+
+	testing.expectf(t, win32.SUCCEEDED(hr), "%x (should be: %x)", u32(hr), 0)
+	testing.expectf(t, p != nil, "%v is nil", p)
+
+	str, err := win32.wstring_to_utf8(p, 40)
+	testing.expectf(t, err == .None, "%v (should be: %x)", err, 0)
+	exp :: "{42F85136-DB7E-439C-85F1-E4075D135FC8}"
+	testing.expectf(t, str == exp, "%v (should be: %v)", str, exp)
+}
+
+@(test)
+iid_from_string :: proc(t: ^testing.T) {
+	iid: win32.IID
+	hr := win32.IIDFromString(L("{D20BEEC4-5CA8-4905-AE3B-BF251EA09B53}"), &iid)
+	testing.expectf(t, win32.SUCCEEDED(hr), "%x (should be: %x)", u32(hr), 0)
+	exp := win32.FOLDERID_NetworkFolder
+	testing.expectf(t, iid == exp, "%v (should be: %v)", iid, exp)
+}
+
+@(test)
+verify_coinit :: proc(t: ^testing.T) {
+	expect_value(t, win32.COINIT.MULTITHREADED, 0x00000000)
+	expect_value(t, win32.COINIT.APARTMENTTHREADED, 0x00000002)
+	expect_value(t, win32.COINIT.DISABLE_OLE1DDE, 0x00000004)
+	expect_value(t, win32.COINIT.SPEED_OVER_MEMORY, 0x00000008)
+}

tests/core/sys/windows/test_windows.odin

@@ -0,0 +1,46 @@
+//+build windows
+package test_core_sys_windows
+
+import "base:intrinsics"
+import "base:runtime"
+import win32 "core:sys/windows"
+import "core:testing"
+
+L :: intrinsics.constant_utf16_cstring
+expectf :: testing.expectf
+
+@(private)
+expect_size :: proc(t: ^testing.T, $act: typeid, exp: int, loc := #caller_location) {
+	expectf(t, size_of(act) == exp, "size_of(%v) should be %d was %d", typeid_of(act), exp, size_of(act), loc = loc)
+}
+
+@(private)
+expect_value :: proc(t: ^testing.T, #any_int act: u32, #any_int exp: u32, loc := #caller_location) {
+	expectf(t, act == exp, "0x%8X (should be: 0x%8X)", act, exp, loc = loc)
+}
+
+@(private)
+expect_value_64 :: proc(t: ^testing.T, #any_int act: u64, #any_int exp: u64, loc := #caller_location) {
+	expectf(t, act == exp, "0x%8X (should be: 0x%8X)", act, exp, loc = loc)
+}
+
+@(private)
+expect_value_int :: proc(t: ^testing.T, act, exp: int, loc := #caller_location) {
+	expectf(t, act == exp, "0x%8X (should be: 0x%8X)", act, exp, loc = loc)
+}
+
+@(private)
+expect_value_uintptr :: proc(t: ^testing.T, act: uintptr, exp: int, loc := #caller_location) {
+	expectf(t, act == uintptr(exp), "0x%8X (should be: 0x%8X)", act, uintptr(exp), loc = loc)
+}
+
+@(private)
+expect_value_str :: proc(t: ^testing.T, wact, wexp: win32.wstring, loc := #caller_location) {
+	act, exp: string
+	err: runtime.Allocator_Error
+	act, err = win32.wstring_to_utf8(wact, 16)
+	expectf(t, err == .None, "0x%8X (should be: 0x%8X)", err, 0, loc = loc)
+	exp, err = win32.wstring_to_utf8(wexp, 16)
+	expectf(t, err == .None, "0x%8X (should be: 0x%8X)", err, 0, loc = loc)
+	expectf(t, act == exp, "0x%8X (should be: 0x%8X)", act, exp, loc = loc)
+}

tests/core/sys/windows/test_windows_generated.odin

@@ -0,0 +1,699 @@
+//+build windows
+package test_core_sys_windows // generated by win32gen
+
+import "core:testing"
+import win32 "core:sys/windows"
+
+@(test)
+verify_win32_type_sizes :: proc(t: ^testing.T) {
+	// minwindef.h
+	expect_size(t, win32.ULONG, 4)
+	expect_size(t, win32.PULONG, 8)
+	expect_size(t, win32.USHORT, 2)
+	expect_size(t, win32.PUSHORT, 8)
+	expect_size(t, win32.UCHAR, 1)
+	expect_size(t, win32.DWORD, 4)
+	expect_size(t, win32.BOOL, 4)
+	expect_size(t, win32.BYTE, 1)
+	expect_size(t, win32.WORD, 2)
+	expect_size(t, win32.PBOOL, 8)
+	expect_size(t, win32.LPBOOL, 8)
+	expect_size(t, win32.PBYTE, 8)
+	expect_size(t, win32.LPBYTE, 8)
+	expect_size(t, win32.PINT, 8)
+	expect_size(t, win32.LPINT, 8)
+	expect_size(t, win32.LPWORD, 8)
+	expect_size(t, win32.PDWORD, 8)
+	expect_size(t, win32.LPDWORD, 8)
+	expect_size(t, win32.LPVOID, 8)
+	expect_size(t, win32.LPCVOID, 8)
+	expect_size(t, win32.INT, 4)
+	expect_size(t, win32.UINT, 4)
+	expect_size(t, win32.PUINT, 8)
+	expect_size(t, win32.UINT_PTR, 8)
+	expect_size(t, win32.LONG_PTR, 8)
+	expect_size(t, win32.HANDLE, 8)
+	expect_size(t, win32.WPARAM, 8)
+	expect_size(t, win32.LPARAM, 8)
+	expect_size(t, win32.LRESULT, 8)
+	expect_size(t, win32.LPHANDLE, 8)
+	expect_size(t, win32.HGLOBAL, 8)
+	expect_size(t, win32.ATOM, 2)
+	expect_size(t, win32.HKEY, 8)
+	expect_size(t, win32.PHKEY, 8)
+	expect_size(t, win32.HINSTANCE, 8)
+	expect_size(t, win32.HMODULE, 8)
+	expect_size(t, win32.HRGN, 8)
+	expect_size(t, win32.HRSRC, 8)
+	// windef.h
+	expect_size(t, win32.HWND, 8)
+	expect_size(t, win32.HHOOK, 8)
+	expect_size(t, win32.HGDIOBJ, 8)
+	expect_size(t, win32.HBITMAP, 8)
+	expect_size(t, win32.HPALETTE, 8)
+	expect_size(t, win32.HBRUSH, 8)
+	expect_size(t, win32.HPEN, 8)
+	expect_size(t, win32.HFONT, 8)
+	expect_size(t, win32.HICON, 8)
+	expect_size(t, win32.HMENU, 8)
+	expect_size(t, win32.HCURSOR, 8)
+	expect_size(t, win32.COLORREF, 4)
+	expect_size(t, win32.RECT, 16)
+	expect_size(t, win32.POINT, 8)
+	expect_size(t, win32.SIZE, 8)
+	// wtypes.h
+	expect_size(t, win32.DECIMAL, 16)
+	// fileapi.h
+	expect_size(t, win32.WIN32_FILE_ATTRIBUTE_DATA, 36)
+	// libloaderapi.h
+	expect_size(t, win32.ENUMRESNAMEPROCW, 8)
+	expect_size(t, win32.ENUMRESTYPEPROCW, 8)
+	// minwinbase.h
+	expect_size(t, win32.SYSTEMTIME, 16)
+	expect_size(t, win32.WIN32_FIND_DATAW, 592)
+	expect_size(t, win32.CRITICAL_SECTION, 40)
+	expect_size(t, win32.REASON_CONTEXT, 32)
+	// guiddef.h
+	expect_size(t, win32.GUID, 16)
+	expect_size(t, win32.IID, 16)
+	expect_size(t, win32.CLSID, 16)
+	// combaseapi.h
+	expect_size(t, win32.SCODE, 4)
+	// commdlg.h
+	expect_size(t, win32.OPENFILENAMEW, 152)
+	// wtypesbase.h
+	expect_size(t, win32.OLECHAR, 2)
+}
+
+@(test)
+verify_macros :: proc(t: ^testing.T) {
+	// minwindef.h
+	expect_value(t, win32.MAKEWORD(1, 2), 0x00000201)
+	expect_value(t, win32.MAKEWORD(0x1111, 0x2222), 0x00002211)
+	expect_value(t, win32.MAKELONG(1, 2), 0x00020001)
+	expect_value(t, win32.MAKELONG(0x1111, 0x2222), 0x22221111)
+	expect_value(t, win32.LOWORD(0x12345678), 0x00005678)
+	expect_value(t, win32.HIWORD(0x12345678), 0x00001234)
+	expect_value(t, u32(win32.LOBYTE(0x1234)), 0x00000034)
+	expect_value(t, u32(win32.HIBYTE(0x1234)), 0x00000012)
+	// winuser.h
+	expect_value(t, win32.MAKEWPARAM(1, 2), 0x00020001)
+	expect_value(t, win32.MAKEWPARAM(0x1111, 0x2222), 0x22221111)
+	expect_value(t, win32.MAKELPARAM(1, 2), 0x00020001)
+	expect_value(t, win32.MAKELPARAM(0x1111, 0x2222), 0x22221111)
+	expect_value(t, win32.MAKELRESULT(1, 2), 0x00020001)
+	expect_value(t, win32.MAKELRESULT(0x1111, 0x2222), 0x22221111)
+	// winnt.h
+	expect_value(t, win32.MAKELCID(1, 2), 0x00020001)
+	expect_value(t, win32.MAKELCID(0x1111, 0x2222), 0x22221111)
+	expect_value(t, win32.MAKELANGID(1, 2), 0x00000801)
+	expect_value(t, win32.MAKELANGID(0x111, 0x222), 0x00088911)
+	expect_value(t, win32.LANGIDFROMLCID(0x12345678), 0x00005678)
+}
+
+@(test)
+verify_winnt :: proc(t: ^testing.T) {
+	// winnt.h
+	expect_size(t, win32.CHAR, 1)
+	expect_size(t, win32.SHORT, 2)
+	expect_size(t, win32.LONG, 4)
+	expect_size(t, win32.INT, 4)
+	expect_size(t, win32.WCHAR, 2)
+	expect_size(t, win32.ULONGLONG, 8)
+	expect_size(t, win32.LARGE_INTEGER, 8)
+	expect_size(t, win32.PLARGE_INTEGER, 8)
+	expect_size(t, win32.ULARGE_INTEGER, 8)
+	expect_size(t, win32.PULARGE_INTEGER, 8)
+	expect_size(t, win32.BOOLEAN, 1)
+	expect_size(t, win32.HANDLE, 8)
+	expect_size(t, win32.PHANDLE, 8)
+	expect_size(t, win32.HRESULT, 4)
+	expect_size(t, win32.LCID, 4)
+	expect_size(t, win32.LANGID, 2)
+	expect_size(t, win32.LUID, 8)
+	expect_size(t, win32.SECURITY_INFORMATION, 4)
+	expect_size(t, win32.ACCESS_MASK, 4)
+	expect_size(t, win32.REGSAM, 4)
+	expect_value(t, win32.LANG_NEUTRAL, 0x00000000)
+	expect_value(t, win32.LANG_INVARIANT, 0x0000007F)
+	expect_value(t, win32.SUBLANG_NEUTRAL, 0x00000000)
+	expect_value(t, win32.SUBLANG_DEFAULT, 0x00000001)
+}
+
+@(test)
+verify_winuser :: proc(t: ^testing.T) {
+	// winuser.h
+	expect_size(t, win32.USEROBJECTFLAGS, 12)
+	expect_size(t, win32.MSG, 48)
+	expect_size(t, win32.WINDOWPOS, 40)
+	expect_size(t, win32.ACCEL, 6)
+	expect_size(t, win32.MENUITEMINFOW, 80)
+	expect_size(t, win32.PAINTSTRUCT, 72)
+	expect_size(t, win32.CREATESTRUCTW, 80)
+	expect_size(t, win32.WINDOWPLACEMENT, 44)
+	expect_size(t, win32.MOUSEINPUT, 32)
+	expect_size(t, win32.KEYBDINPUT, 24)
+	expect_size(t, win32.HARDWAREINPUT, 8)
+	expect_size(t, win32.INPUT, 40)
+	expect_size(t, win32.ICONINFOEXW, 1080)
+	expect_size(t, win32.CURSORINFO, 24)
+	expect_size(t, win32.WINDOWINFO, 60)
+	expect_size(t, win32.RAWINPUTHEADER, 24)
+	expect_size(t, win32.RAWMOUSE, 24)
+	expect_size(t, win32.RAWKEYBOARD, 16)
+	expect_size(t, win32.RAWINPUT, 48)
+	expect_size(t, win32.RAWINPUTDEVICE, 16)
+	expect_size(t, win32.RAWINPUTDEVICELIST, 16)
+	expect_size(t, win32.RID_DEVICE_INFO_HID, 16)
+	expect_size(t, win32.RID_DEVICE_INFO_KEYBOARD, 24)
+	expect_size(t, win32.RID_DEVICE_INFO_MOUSE, 16)
+	expect_size(t, win32.RID_DEVICE_INFO, 32)
+	expect_value(t, win32.GET_RAWINPUT_CODE_WPARAM(0x12345678), 0x00000078)
+	expect_size(t, win32.DRAWTEXTPARAMS, 20)
+	expect_size(t, win32.BSMINFO, 32)
+	expect_value(t, win32.BROADCAST_QUERY_DENY, 0x424D5144)
+	expect_value_64(t, u64(win32.HWND_BROADCAST), 0x0000FFFF)
+	expect_value_64(t, u64(win32.HWND_MESSAGE), 0xFFFFFFFFFFFFFFFD)
+	expect_value_64(t, uintptr(win32.MAKEINTRESOURCEW(1)), 0x00000001)
+	expect_value_64(t, uintptr(win32.MAKEINTRESOURCEW(0x12345678)), 0x00005678)
+	expect_value_64(t, uintptr(win32.RT_CURSOR), 0x00000001)
+	expect_value_64(t, uintptr(win32.RT_BITMAP), 0x00000002)
+	expect_value_64(t, uintptr(win32.RT_ICON), 0x00000003)
+	expect_value_64(t, uintptr(win32.RT_MENU), 0x00000004)
+	expect_value_64(t, uintptr(win32.RT_DIALOG), 0x00000005)
+	expect_value_64(t, uintptr(win32.RT_STRING), 0x00000006)
+	expect_value_64(t, uintptr(win32.RT_FONTDIR), 0x00000007)
+	expect_value_64(t, uintptr(win32.RT_FONT), 0x00000008)
+	expect_value_64(t, uintptr(win32.RT_ACCELERATOR), 0x00000009)
+	expect_value_64(t, uintptr(win32.RT_RCDATA), 0x0000000A)
+	expect_value_64(t, uintptr(win32.RT_MESSAGETABLE), 0x0000000B)
+	expect_value_64(t, uintptr(win32.RT_GROUP_CURSOR), 0x0000000C)
+	expect_value_64(t, uintptr(win32.RT_GROUP_ICON), 0x0000000E)
+	expect_value_64(t, uintptr(win32.RT_VERSION), 0x00000010)
+	expect_value_64(t, uintptr(win32.RT_DLGINCLUDE), 0x00000011)
+	expect_value_64(t, uintptr(win32.RT_PLUGPLAY), 0x00000013)
+	expect_value_64(t, uintptr(win32.RT_VXD), 0x00000014)
+	expect_value_64(t, uintptr(win32.RT_ANICURSOR), 0x00000015)
+	expect_value_64(t, uintptr(win32.RT_ANIICON), 0x00000016)
+	expect_value_64(t, uintptr(win32.RT_MANIFEST), 0x00000018)
+	expect_value_64(t, uintptr(win32.CREATEPROCESS_MANIFEST_RESOURCE_ID), 0x00000001)
+	expect_value_64(t, uintptr(win32.ISOLATIONAWARE_MANIFEST_RESOURCE_ID), 0x00000002)
+	expect_value_64(t, uintptr(win32.ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID), 0x00000003)
+	expect_value_64(t, uintptr(win32.ISOLATIONPOLICY_MANIFEST_RESOURCE_ID), 0x00000004)
+	expect_value_64(t, uintptr(win32.ISOLATIONPOLICY_BROWSER_MANIFEST_RESOURCE_ID), 0x00000005)
+	expect_value_64(t, uintptr(win32.MINIMUM_RESERVED_MANIFEST_RESOURCE_ID), 0x00000001)
+	expect_value_64(t, uintptr(win32.MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID), 0x00000010)
+	expect_value(t, win32.SM_CXICON, 0x0000000B)
+	expect_value(t, win32.SM_CYICON, 0x0000000C)
+	expect_value(t, win32.LR_DEFAULTCOLOR, 0x00000000)
+	expect_value(t, win32.LR_MONOCHROME, 0x00000001)
+	expect_value(t, win32.LR_COLOR, 0x00000002)
+	expect_value(t, win32.LR_COPYRETURNORG, 0x00000004)
+	expect_value(t, win32.LR_COPYDELETEORG, 0x00000008)
+	expect_value(t, win32.LR_LOADFROMFILE, 0x00000010)
+	expect_value(t, win32.LR_LOADTRANSPARENT, 0x00000020)
+	expect_value(t, win32.LR_DEFAULTSIZE, 0x00000040)
+	expect_value(t, win32.LR_VGACOLOR, 0x00000080)
+	expect_value(t, win32.LR_LOADMAP3DCOLORS, 0x00001000)
+	expect_value(t, win32.LR_CREATEDIBSECTION, 0x00002000)
+	expect_value(t, win32.LR_COPYFROMRESOURCE, 0x00004000)
+	expect_value(t, win32.LR_SHARED, 0x00008000)
+	expect_value(t, win32.NIM_ADD, 0x00000000)
+	expect_value(t, win32.NIM_MODIFY, 0x00000001)
+	expect_value(t, win32.NIM_DELETE, 0x00000002)
+	expect_value(t, win32.NIM_SETFOCUS, 0x00000003)
+	expect_value(t, win32.NIM_SETVERSION, 0x00000004)
+	expect_value(t, win32.NIF_MESSAGE, 0x00000001)
+	expect_value(t, win32.NIF_ICON, 0x00000002)
+	expect_value(t, win32.NIF_TIP, 0x00000004)
+	expect_value(t, win32.NIF_STATE, 0x00000008)
+	expect_value(t, win32.NIF_INFO, 0x00000010)
+	expect_value(t, win32.NIF_GUID, 0x00000020)
+	expect_value(t, win32.NIF_REALTIME, 0x00000040)
+	expect_value(t, win32.NIF_SHOWTIP, 0x00000080)
+	expect_value(t, win32.MF_INSERT, 0x00000000)
+	expect_value(t, win32.MF_CHANGE, 0x00000080)
+	expect_value(t, win32.MF_APPEND, 0x00000100)
+	expect_value(t, win32.MF_DELETE, 0x00000200)
+	expect_value(t, win32.MF_REMOVE, 0x00001000)
+	expect_value(t, win32.MF_BYCOMMAND, 0x00000000)
+	expect_value(t, win32.MF_BYPOSITION, 0x00000400)
+	expect_value(t, win32.MF_SEPARATOR, 0x00000800)
+	expect_value(t, win32.MF_ENABLED, 0x00000000)
+	expect_value(t, win32.MF_GRAYED, 0x00000001)
+	expect_value(t, win32.MF_DISABLED, 0x00000002)
+	expect_value(t, win32.MF_UNCHECKED, 0x00000000)
+	expect_value(t, win32.MF_CHECKED, 0x00000008)
+	expect_value(t, win32.MF_USECHECKBITMAPS, 0x00000200)
+	expect_value(t, win32.MF_STRING, 0x00000000)
+	expect_value(t, win32.MF_BITMAP, 0x00000004)
+	expect_value(t, win32.MF_OWNERDRAW, 0x00000100)
+	expect_value(t, win32.MF_POPUP, 0x00000010)
+	expect_value(t, win32.MF_MENUBARBREAK, 0x00000020)
+	expect_value(t, win32.MF_MENUBREAK, 0x00000040)
+	expect_value(t, win32.MF_UNHILITE, 0x00000000)
+	expect_value(t, win32.MF_HILITE, 0x00000080)
+	expect_value(t, win32.MF_DEFAULT, 0x00001000)
+	expect_value(t, win32.MF_SYSMENU, 0x00002000)
+	expect_value(t, win32.MF_HELP, 0x00004000)
+	expect_value(t, win32.MF_RIGHTJUSTIFY, 0x00004000)
+	expect_value(t, win32.MF_MOUSESELECT, 0x00008000)
+	expect_value(t, win32.MF_END, 0x00000080)
+	expect_value(t, win32.MFS_GRAYED, 0x00000003)
+	expect_value(t, win32.MFS_DISABLED, 0x00000003)
+	expect_value(t, win32.MFS_CHECKED, 0x00000008)
+	expect_value(t, win32.MFS_HILITE, 0x00000080)
+	expect_value(t, win32.MFS_ENABLED, 0x00000000)
+	expect_value(t, win32.MFS_UNCHECKED, 0x00000000)
+	expect_value(t, win32.MFS_UNHILITE, 0x00000000)
+	expect_value(t, win32.MFS_DEFAULT, 0x00001000)
+	expect_value(t, win32.TPM_LEFTBUTTON, 0x00000000)
+	expect_value(t, win32.TPM_RIGHTBUTTON, 0x00000002)
+	expect_value(t, win32.TPM_LEFTALIGN, 0x00000000)
+	expect_value(t, win32.TPM_CENTERALIGN, 0x00000004)
+	expect_value(t, win32.TPM_RIGHTALIGN, 0x00000008)
+	expect_value(t, win32.TPM_TOPALIGN, 0x00000000)
+	expect_value(t, win32.TPM_VCENTERALIGN, 0x00000010)
+	expect_value(t, win32.TPM_BOTTOMALIGN, 0x00000020)
+	expect_value(t, win32.TPM_HORIZONTAL, 0x00000000)
+	expect_value(t, win32.TPM_VERTICAL, 0x00000040)
+	expect_value(t, win32.TPM_NONOTIFY, 0x00000080)
+	expect_value(t, win32.TPM_RETURNCMD, 0x00000100)
+	expect_value(t, win32.TPM_RECURSE, 0x00000001)
+	expect_value(t, win32.TPM_HORPOSANIMATION, 0x00000400)
+	expect_value(t, win32.TPM_HORNEGANIMATION, 0x00000800)
+	expect_value(t, win32.TPM_VERPOSANIMATION, 0x00001000)
+	expect_value(t, win32.TPM_VERNEGANIMATION, 0x00002000)
+	expect_value(t, win32.TPM_NOANIMATION, 0x00004000)
+	expect_value(t, win32.TPM_LAYOUTRTL, 0x00008000)
+	expect_value(t, win32.TPM_WORKAREA, 0x00010000)
+	expect_value(t, win32.MIIM_STATE, 0x00000001)
+	expect_value(t, win32.MIIM_ID, 0x00000002)
+	expect_value(t, win32.MIIM_SUBMENU, 0x00000004)
+	expect_value(t, win32.MIIM_CHECKMARKS, 0x00000008)
+	expect_value(t, win32.MIIM_TYPE, 0x00000010)
+	expect_value(t, win32.MIIM_DATA, 0x00000020)
+	expect_value(t, win32.MIIM_STRING, 0x00000040)
+	expect_value(t, win32.MIIM_BITMAP, 0x00000080)
+	expect_value(t, win32.MIIM_FTYPE, 0x00000100)
+	expect_value(t, win32.ANSI_CHARSET, 0x00000000)
+	expect_value(t, win32.DEFAULT_CHARSET, 0x00000001)
+	expect_value(t, win32.SYMBOL_CHARSET, 0x00000002)
+	expect_value(t, win32.SHIFTJIS_CHARSET, 0x00000080)
+	expect_value(t, win32.HANGEUL_CHARSET, 0x00000081)
+	expect_value(t, win32.HANGUL_CHARSET, 0x00000081)
+	expect_value(t, win32.GB2312_CHARSET, 0x00000086)
+	expect_value(t, win32.CHINESEBIG5_CHARSET, 0x00000088)
+	expect_value(t, win32.OEM_CHARSET, 0x000000FF)
+	expect_value(t, win32.JOHAB_CHARSET, 0x00000082)
+	expect_value(t, win32.HEBREW_CHARSET, 0x000000B1)
+	expect_value(t, win32.ARABIC_CHARSET, 0x000000B2)
+	expect_value(t, win32.GREEK_CHARSET, 0x000000A1)
+	expect_value(t, win32.TURKISH_CHARSET, 0x000000A2)
+	expect_value(t, win32.VIETNAMESE_CHARSET, 0x000000A3)
+	expect_value(t, win32.THAI_CHARSET, 0x000000DE)
+	expect_value(t, win32.EASTEUROPE_CHARSET, 0x000000EE)
+	expect_value(t, win32.RUSSIAN_CHARSET, 0x000000CC)
+	expect_value(t, win32.MAC_CHARSET, 0x0000004D)
+	expect_value(t, win32.BALTIC_CHARSET, 0x000000BA)
+	expect_value(t, win32.FS_LATIN1, 0x00000001)
+	expect_value(t, win32.FS_LATIN2, 0x00000002)
+	expect_value(t, win32.FS_CYRILLIC, 0x00000004)
+	expect_value(t, win32.FS_GREEK, 0x00000008)
+	expect_value(t, win32.FS_TURKISH, 0x00000010)
+	expect_value(t, win32.FS_HEBREW, 0x00000020)
+	expect_value(t, win32.FS_ARABIC, 0x00000040)
+	expect_value(t, win32.FS_BALTIC, 0x00000080)
+	expect_value(t, win32.FS_VIETNAMESE, 0x00000100)
+	expect_value(t, win32.FS_THAI, 0x00010000)
+	expect_value(t, win32.FS_JISJAPAN, 0x00020000)
+	expect_value(t, win32.FS_CHINESESIMP, 0x00040000)
+	expect_value(t, win32.FS_WANSUNG, 0x00080000)
+	expect_value(t, win32.FS_CHINESETRAD, 0x00100000)
+	expect_value(t, win32.FS_JOHAB, 0x00200000)
+	expect_value(t, win32.FS_SYMBOL, 0x80000000)
+	expect_value(t, win32.OUT_DEFAULT_PRECIS, 0x00000000)
+	expect_value(t, win32.OUT_STRING_PRECIS, 0x00000001)
+	expect_value(t, win32.OUT_CHARACTER_PRECIS, 0x00000002)
+	expect_value(t, win32.OUT_STROKE_PRECIS, 0x00000003)
+	expect_value(t, win32.OUT_TT_PRECIS, 0x00000004)
+	expect_value(t, win32.OUT_DEVICE_PRECIS, 0x00000005)
+	expect_value(t, win32.OUT_RASTER_PRECIS, 0x00000006)
+	expect_value(t, win32.OUT_TT_ONLY_PRECIS, 0x00000007)
+	expect_value(t, win32.OUT_OUTLINE_PRECIS, 0x00000008)
+	expect_value(t, win32.OUT_SCREEN_OUTLINE_PRECIS, 0x00000009)
+	expect_value(t, win32.OUT_PS_ONLY_PRECIS, 0x0000000A)
+	expect_value(t, win32.CLIP_DEFAULT_PRECIS, 0x00000000)
+	expect_value(t, win32.CLIP_CHARACTER_PRECIS, 0x00000001)
+	expect_value(t, win32.CLIP_STROKE_PRECIS, 0x00000002)
+	expect_value(t, win32.CLIP_MASK, 0x0000000F)
+	expect_value(t, win32.CLIP_LH_ANGLES, 0x00000010)
+	expect_value(t, win32.CLIP_TT_ALWAYS, 0x00000020)
+	expect_value(t, win32.CLIP_DFA_DISABLE, 0x00000040)
+	expect_value(t, win32.CLIP_EMBEDDED, 0x00000080)
+	expect_value(t, win32.DEFAULT_QUALITY, 0x00000000)
+	expect_value(t, win32.DRAFT_QUALITY, 0x00000001)
+	expect_value(t, win32.PROOF_QUALITY, 0x00000002)
+	expect_value(t, win32.NONANTIALIASED_QUALITY, 0x00000003)
+	expect_value(t, win32.ANTIALIASED_QUALITY, 0x00000004)
+	expect_value(t, win32.CLEARTYPE_QUALITY, 0x00000005)
+	expect_value(t, win32.CLEARTYPE_NATURAL_QUALITY, 0x00000006)
+	expect_value(t, win32.DEFAULT_PITCH, 0x00000000)
+	expect_value(t, win32.FIXED_PITCH, 0x00000001)
+	expect_value(t, win32.VARIABLE_PITCH, 0x00000002)
+	expect_value(t, win32.MONO_FONT, 0x00000008)
+	expect_value(t, win32.FF_DONTCARE, 0x00000000)
+	expect_value(t, win32.FF_ROMAN, 0x00000010)
+	expect_value(t, win32.FF_SWISS, 0x00000020)
+	expect_value(t, win32.FF_MODERN, 0x00000030)
+	expect_value(t, win32.FF_SCRIPT, 0x00000040)
+	expect_value(t, win32.FF_DECORATIVE, 0x00000050)
+}
+
+@(test)
+verify_gdi32 :: proc(t: ^testing.T) {
+	// wingdi.h
+	expect_size(t, win32.DEVMODEW, 220)
+	expect_size(t, win32.RGBQUAD, 4)
+	expect_size(t, win32.PIXELFORMATDESCRIPTOR, 40)
+	expect_size(t, win32.BITMAPINFOHEADER, 40)
+	expect_size(t, win32.BITMAP, 32)
+	expect_size(t, win32.BITMAPV5HEADER, 124)
+	expect_size(t, win32.CIEXYZTRIPLE, 36)
+	expect_size(t, win32.CIEXYZ, 12)
+	expect_size(t, win32.FXPT2DOT30, 4)
+	expect_size(t, win32.TEXTMETRICW, 60)
+	expect_size(t, win32.POINTFLOAT, 8)
+	expect_size(t, win32.GLYPHMETRICSFLOAT, 24)
+	expect_size(t, win32.PALETTEENTRY, 4)
+	expect_size(t, win32.DESIGNVECTOR, 72)
+	expect_value(t, win32.LF_FACESIZE, 0x00000020)
+	expect_value(t, win32.LF_FULLFACESIZE, 0x00000040)
+	expect_size(t, win32.LOGFONTW, 92)
+	expect_size(t, win32.ENUMLOGFONTW, 284)
+	expect_size(t, win32.ENUMLOGFONTEXW, 348)
+	expect_size(t, win32.ENUMLOGFONTEXDVW, 420)
+	expect_size(t, win32.NEWTEXTMETRICW, 76)
+	expect_size(t, win32.LAYERPLANEDESCRIPTOR, 32)
+	expect_size(t, win32.COLOR16, 2)
+	expect_size(t, win32.TRIVERTEX, 16)
+	expect_size(t, win32.GRADIENT_TRIANGLE, 12)
+	expect_size(t, win32.GRADIENT_RECT, 8)
+	expect_size(t, win32.BLENDFUNCTION, 4)
+	expect_size(t, win32.DISPLAY_DEVICEW, 840)
+	expect_value(t, win32.AC_SRC_OVER, 0x00000000)
+	expect_value(t, win32.AC_SRC_ALPHA, 0x00000001)
+	expect_value(t, win32.RGB(12, 34, 56), 0x0038220C)
+	expect_value(t, win32.PALETTERGB(12, 34, 56), 0x0238220C)
+	expect_value(t, win32.PALETTEINDEX(123), 0x0100007B)
+	expect_value(t, win32.GRADIENT_FILL_RECT_H, 0x00000000)
+	expect_value(t, win32.GRADIENT_FILL_RECT_V, 0x00000001)
+	expect_value(t, win32.GRADIENT_FILL_TRIANGLE, 0x00000002)
+	expect_value(t, win32.BS_SOLID, 0x00000000)
+	expect_value(t, win32.BS_NULL, 0x00000001)
+	expect_value(t, win32.BS_HOLLOW, 0x00000001)
+	expect_value(t, win32.BS_HATCHED, 0x00000002)
+	expect_value(t, win32.BS_PATTERN, 0x00000003)
+	expect_value(t, win32.BS_INDEXED, 0x00000004)
+	expect_value(t, win32.BS_DIBPATTERN, 0x00000005)
+	expect_value(t, win32.BS_DIBPATTERNPT, 0x00000006)
+	expect_value(t, win32.BS_PATTERN8X8, 0x00000007)
+	expect_value(t, win32.BS_DIBPATTERN8X8, 0x00000008)
+	expect_value(t, win32.BS_MONOPATTERN, 0x00000009)
+	expect_value(t, win32.HS_HORIZONTAL, 0x00000000)
+	expect_value(t, win32.HS_VERTICAL, 0x00000001)
+	expect_value(t, win32.HS_FDIAGONAL, 0x00000002)
+	expect_value(t, win32.HS_BDIAGONAL, 0x00000003)
+	expect_value(t, win32.HS_CROSS, 0x00000004)
+	expect_value(t, win32.HS_DIAGCROSS, 0x00000005)
+	expect_value(t, win32.HS_API_MAX, 0x0000000C)
+	expect_value(t, win32.PS_SOLID, 0x00000000)
+	expect_value(t, win32.PS_DASH, 0x00000001)
+	expect_value(t, win32.PS_DOT, 0x00000002)
+	expect_value(t, win32.PS_DASHDOT, 0x00000003)
+	expect_value(t, win32.PS_DASHDOTDOT, 0x00000004)
+	expect_value(t, win32.PS_NULL, 0x00000005)
+	expect_value(t, win32.PS_INSIDEFRAME, 0x00000006)
+	expect_value(t, win32.PS_USERSTYLE, 0x00000007)
+	expect_value(t, win32.PS_ALTERNATE, 0x00000008)
+	expect_value(t, win32.PS_STYLE_MASK, 0x0000000F)
+	expect_value(t, win32.PS_ENDCAP_ROUND, 0x00000000)
+	expect_value(t, win32.PS_ENDCAP_SQUARE, 0x00000100)
+	expect_value(t, win32.PS_ENDCAP_FLAT, 0x00000200)
+	expect_value(t, win32.PS_ENDCAP_MASK, 0x00000F00)
+	expect_value(t, win32.PS_JOIN_ROUND, 0x00000000)
+	expect_value(t, win32.PS_JOIN_BEVEL, 0x00001000)
+	expect_value(t, win32.PS_JOIN_MITER, 0x00002000)
+	expect_value(t, win32.PS_COSMETIC, 0x00000000)
+	expect_value(t, win32.PS_GEOMETRIC, 0x00010000)
+	expect_value(t, win32.PS_TYPE_MASK, 0x000F0000)
+	// Binary raster ops
+	expect_value(t, win32.R2_BLACK, 0x00000001)
+	expect_value(t, win32.R2_NOTMERGEPEN, 0x00000002)
+	expect_value(t, win32.R2_MASKNOTPEN, 0x00000003)
+	expect_value(t, win32.R2_NOTCOPYPEN, 0x00000004)
+	expect_value(t, win32.R2_MASKPENNOT, 0x00000005)
+	expect_value(t, win32.R2_NOT, 0x00000006)
+	expect_value(t, win32.R2_XORPEN, 0x00000007)
+	expect_value(t, win32.R2_NOTMASKPEN, 0x00000008)
+	expect_value(t, win32.R2_MASKPEN, 0x00000009)
+	expect_value(t, win32.R2_NOTXORPEN, 0x0000000A)
+	expect_value(t, win32.R2_NOP, 0x0000000B)
+	expect_value(t, win32.R2_MERGENOTPEN, 0x0000000C)
+	expect_value(t, win32.R2_COPYPEN, 0x0000000D)
+	expect_value(t, win32.R2_MERGEPENNOT, 0x0000000E)
+	expect_value(t, win32.R2_MERGEPEN, 0x0000000F)
+	expect_value(t, win32.R2_WHITE, 0x00000010)
+	// Ternary raster operations
+	expect_value(t, win32.SRCCOPY, 0x00CC0020)
+	expect_value(t, win32.SRCPAINT, 0x00EE0086)
+	expect_value(t, win32.SRCAND, 0x008800C6)
+	expect_value(t, win32.SRCINVERT, 0x00660046)
+	expect_value(t, win32.SRCERASE, 0x00440328)
+	expect_value(t, win32.NOTSRCCOPY, 0x00330008)
+	expect_value(t, win32.NOTSRCERASE, 0x001100A6)
+	expect_value(t, win32.MERGECOPY, 0x00C000CA)
+	expect_value(t, win32.MERGEPAINT, 0x00BB0226)
+	expect_value(t, win32.PATCOPY, 0x00F00021)
+	expect_value(t, win32.PATPAINT, 0x00FB0A09)
+	expect_value(t, win32.PATINVERT, 0x005A0049)
+	expect_value(t, win32.DSTINVERT, 0x00550009)
+	expect_value(t, win32.BLACKNESS, 0x00000042)
+	expect_value(t, win32.WHITENESS, 0x00FF0062)
+	expect_value(t, win32.NOMIRRORBITMAP, 0x80000000)
+	expect_value(t, win32.CAPTUREBLT, 0x40000000)
+	// Region Flags
+	expect_value(t, win32.ERROR, 0x00000000)
+	expect_value(t, win32.NULLREGION, 0x00000001)
+	expect_value(t, win32.SIMPLEREGION, 0x00000002)
+	expect_value(t, win32.COMPLEXREGION, 0x00000003)
+	expect_value(t, win32.RGN_ERROR, 0x00000000)
+	// CombineRgn() Styles
+	expect_value(t, win32.RGN_AND, 0x00000001)
+	expect_value(t, win32.RGN_OR, 0x00000002)
+	expect_value(t, win32.RGN_XOR, 0x00000003)
+	expect_value(t, win32.RGN_DIFF, 0x00000004)
+	expect_value(t, win32.RGN_COPY, 0x00000005)
+	// StretchBlt() Modes
+	expect_value(t, win32.BLACKONWHITE, 0x00000001)
+	expect_value(t, win32.WHITEONBLACK, 0x00000002)
+	expect_value(t, win32.COLORONCOLOR, 0x00000003)
+	expect_value(t, win32.HALFTONE, 0x00000004)
+	// PolyFill() Modes
+	expect_value(t, win32.ALTERNATE, 0x00000001)
+	expect_value(t, win32.WINDING, 0x00000002)
+	// Layout Orientation Options
+	expect_value(t, win32.LAYOUT_RTL, 0x00000001)
+	expect_value(t, win32.LAYOUT_BTT, 0x00000002)
+	expect_value(t, win32.LAYOUT_VBH, 0x00000004)
+	expect_value(t, win32.LAYOUT_ORIENTATIONMASK, 0x00000007)
+	// Text Alignment Options
+	expect_value(t, win32.TA_NOUPDATECP, 0x00000000)
+	expect_value(t, win32.TA_UPDATECP, 0x00000001)
+	expect_value(t, win32.TA_LEFT, 0x00000000)
+	expect_value(t, win32.TA_RIGHT, 0x00000002)
+	expect_value(t, win32.TA_CENTER, 0x00000006)
+	expect_value(t, win32.TA_TOP, 0x00000000)
+	expect_value(t, win32.TA_BOTTOM, 0x00000008)
+	expect_value(t, win32.TA_BASELINE, 0x00000018)
+	expect_value(t, win32.TA_RTLREADING, 0x00000100)
+	expect_value(t, win32.TA_MASK, 0x0000011F)
+}
+
+@(test)
+verify_winmm :: proc(t: ^testing.T) {
+	// timeapi.h
+	expect_size(t, win32.TIMECAPS, 8)
+	// mmsyscom.h
+	expect_size(t, win32.MMVERSION, 4)
+	expect_size(t, win32.MMTIME, 12)
+	// mmeapi.h
+	expect_size(t, win32.WAVEFORMATEX, 20)
+	expect_size(t, win32.WAVEHDR, 48)
+	expect_size(t, win32.WAVEINCAPSW, 80)
+	expect_size(t, win32.WAVEOUTCAPSW, 84)
+}
+
+@(test)
+verify_advapi32 :: proc(t: ^testing.T) {
+	// wincrypt.h
+	expect_size(t, win32.HCRYPTPROV, 8)
+}
+
+@(test)
+verify_winnls :: proc(t: ^testing.T) {
+	// winnls.h
+	expect_value(t, win32.CP_ACP, 0x00000000)
+	expect_value(t, win32.CP_OEMCP, 0x00000001)
+	expect_value(t, win32.CP_MACCP, 0x00000002)
+	expect_value(t, win32.CP_THREAD_ACP, 0x00000003)
+	expect_value(t, win32.CP_SYMBOL, 0x0000002A)
+	expect_value(t, win32.CP_UTF7, 0x0000FDE8)
+	expect_value(t, win32.CP_UTF8, 0x0000FDE9)
+	expect_value(t, win32.MAX_DEFAULTCHAR, 0x00000002)
+	expect_value(t, win32.MAX_LEADBYTES, 0x0000000C)
+	expect_value(t, win32.LOCALE_NAME_MAX_LENGTH, 0x00000055)
+	expect_value(t, win32.LOCALE_NAME_USER_DEFAULT, 0x00000000)
+	expect_value_str(t, win32.LOCALE_NAME_INVARIANT, L(""))
+	expect_value_str(t, win32.LOCALE_NAME_SYSTEM_DEFAULT, L("!x-sys-default-locale"))
+	expect_size(t, win32.LCTYPE, 4)
+	expect_size(t, win32.CPINFOEXW, 544)
+}
+
+@(test)
+verify_winreg :: proc(t: ^testing.T) {
+	// winreg.h
+	expect_value(t, win32.RRF_RT_REG_NONE, 0x00000001)
+	expect_value(t, win32.RRF_RT_REG_SZ, 0x00000002)
+	expect_value(t, win32.RRF_RT_REG_EXPAND_SZ, 0x00000004)
+	expect_value(t, win32.RRF_RT_REG_BINARY, 0x00000008)
+	expect_value(t, win32.RRF_RT_REG_DWORD, 0x00000010)
+	expect_value(t, win32.RRF_RT_REG_MULTI_SZ, 0x00000020)
+	expect_value(t, win32.RRF_RT_REG_QWORD, 0x00000040)
+	expect_value(t, win32.RRF_RT_DWORD, 0x00000018)
+	expect_value(t, win32.RRF_RT_QWORD, 0x00000048)
+	expect_value(t, win32.RRF_RT_ANY, 0x0000FFFF)
+	expect_value(t, win32.RRF_NOEXPAND, 0x10000000)
+	expect_value(t, win32.RRF_ZEROONFAILURE, 0x20000000)
+	// winnt.h
+	expect_value(t, u32(win32.HKEY_CLASSES_ROOT), 0x80000000)
+	expect_value(t, u32(win32.HKEY_CURRENT_USER), 0x80000001)
+	expect_value(t, u32(win32.HKEY_LOCAL_MACHINE), 0x80000002)
+	expect_value(t, u32(win32.HKEY_USERS), 0x80000003)
+	expect_value(t, u32(win32.HKEY_PERFORMANCE_DATA), 0x80000004)
+	expect_value(t, u32(win32.HKEY_PERFORMANCE_TEXT), 0x80000050)
+	expect_value(t, u32(win32.HKEY_PERFORMANCE_NLSTEXT), 0x80000060)
+	expect_value(t, u32(win32.HKEY_CURRENT_CONFIG), 0x80000005)
+	expect_value(t, u32(win32.HKEY_DYN_DATA), 0x80000006)
+	expect_value(t, u32(win32.HKEY_CURRENT_USER_LOCAL_SETTINGS), 0x80000007)
+	expect_value(t, win32.DELETE, 0x00010000)
+	expect_value(t, win32.READ_CONTROL, 0x00020000)
+	expect_value(t, win32.WRITE_DAC, 0x00040000)
+	expect_value(t, win32.WRITE_OWNER, 0x00080000)
+	expect_value(t, win32.SYNCHRONIZE, 0x00100000)
+	expect_value(t, win32.KEY_QUERY_VALUE, 0x00000001)
+	expect_value(t, win32.KEY_SET_VALUE, 0x00000002)
+	expect_value(t, win32.KEY_CREATE_SUB_KEY, 0x00000004)
+	expect_value(t, win32.KEY_ENUMERATE_SUB_KEYS, 0x00000008)
+	expect_value(t, win32.KEY_NOTIFY, 0x00000010)
+	expect_value(t, win32.KEY_CREATE_LINK, 0x00000020)
+	expect_value(t, win32.KEY_WOW64_32KEY, 0x00000200)
+	expect_value(t, win32.KEY_WOW64_64KEY, 0x00000100)
+	expect_value(t, win32.KEY_WOW64_RES, 0x00000300)
+	expect_value(t, win32.KEY_READ, 0x00020019)
+	expect_value(t, win32.KEY_WRITE, 0x00020006)
+	expect_value(t, win32.KEY_EXECUTE, 0x00020019)
+	expect_value(t, win32.KEY_ALL_ACCESS, 0x000F003F)
+}
+
+@(test)
+verify_verrsrc :: proc(t: ^testing.T) {
+	// verrsrc.h
+	expect_value(t, win32.VS_VERSION_INFO, 0x00000001)
+	expect_value(t, win32.VS_USER_DEFINED, 0x00000064)
+	expect_size(t, win32.VS_FIXEDFILEINFO, 52)
+	expect_value(t, win32.VS_FFI_SIGNATURE, 0xFEEF04BD)
+}
+
+@(test)
+verify_error_codes :: proc(t: ^testing.T) {
+	// winerror.h
+	expect_value(t, win32.ERROR_SUCCESS, 0x00000000)
+	expect_value(t, win32.NO_ERROR, 0x00000000)
+	expect_value(t, win32.SEC_E_OK, 0x00000000)
+
+	expect_value(t, win32.ERROR_INVALID_FUNCTION, 0x00000001)
+	expect_value(t, win32.ERROR_FILE_NOT_FOUND, 0x00000002)
+	expect_value(t, win32.ERROR_PATH_NOT_FOUND, 0x00000003)
+	expect_value(t, win32.ERROR_ACCESS_DENIED, 0x00000005)
+	expect_value(t, win32.ERROR_INVALID_HANDLE, 0x00000006)
+	expect_value(t, win32.ERROR_NOT_ENOUGH_MEMORY, 0x00000008)
+	expect_value(t, win32.ERROR_INVALID_BLOCK, 0x00000009)
+	expect_value(t, win32.ERROR_BAD_ENVIRONMENT, 0x0000000A)
+	expect_value(t, win32.ERROR_BAD_FORMAT, 0x0000000B)
+	expect_value(t, win32.ERROR_INVALID_ACCESS, 0x0000000C)
+	expect_value(t, win32.ERROR_INVALID_DATA, 0x0000000D)
+	expect_value(t, win32.ERROR_OUTOFMEMORY, 0x0000000E)
+	expect_value(t, win32.ERROR_INVALID_DRIVE, 0x0000000F)
+	expect_value(t, win32.ERROR_CURRENT_DIRECTORY, 0x00000010)
+	expect_value(t, win32.ERROR_NO_MORE_FILES, 0x00000012)
+	expect_value(t, win32.ERROR_SHARING_VIOLATION, 0x00000020)
+	expect_value(t, win32.ERROR_LOCK_VIOLATION, 0x00000021)
+	expect_value(t, win32.ERROR_HANDLE_EOF, 0x00000026)
+	expect_value(t, win32.ERROR_NOT_SUPPORTED, 0x00000032)
+	expect_value(t, win32.ERROR_FILE_EXISTS, 0x00000050)
+	expect_value(t, win32.ERROR_INVALID_PARAMETER, 0x00000057)
+	expect_value(t, win32.ERROR_BROKEN_PIPE, 0x0000006D)
+	expect_value(t, win32.ERROR_CALL_NOT_IMPLEMENTED, 0x00000078)
+	expect_value(t, win32.ERROR_INSUFFICIENT_BUFFER, 0x0000007A)
+	expect_value(t, win32.ERROR_INVALID_NAME, 0x0000007B)
+	expect_value(t, win32.ERROR_BAD_ARGUMENTS, 0x000000A0)
+	expect_value(t, win32.ERROR_LOCK_FAILED, 0x000000A7)
+	expect_value(t, win32.ERROR_ALREADY_EXISTS, 0x000000B7)
+	expect_value(t, win32.ERROR_NO_DATA, 0x000000E8)
+	expect_value(t, win32.ERROR_ENVVAR_NOT_FOUND, 0x000000CB)
+	expect_value(t, win32.ERROR_OPERATION_ABORTED, 0x000003E3)
+	expect_value(t, win32.ERROR_IO_PENDING, 0x000003E5)
+	expect_value(t, win32.ERROR_NO_UNICODE_TRANSLATION, 0x00000459)
+	expect_value(t, win32.ERROR_TIMEOUT, 0x000005B4)
+	expect_value(t, win32.ERROR_DATATYPE_MISMATCH, 0x0000065D)
+	expect_value(t, win32.ERROR_UNSUPPORTED_TYPE, 0x0000065E)
+	expect_value(t, win32.ERROR_NOT_SAME_OBJECT, 0x00000678)
+	expect_value(t, win32.ERROR_PIPE_CONNECTED, 0x00000217)
+	expect_value(t, win32.ERROR_PIPE_BUSY, 0x000000E7)
+
+	expect_value(t, win32.S_OK, 0x00000000)
+	expect_value(t, win32.E_NOTIMPL, 0x80004001)
+	expect_value(t, win32.E_NOINTERFACE, 0x80004002)
+	expect_value(t, win32.E_POINTER, 0x80004003)
+	expect_value(t, win32.E_ABORT, 0x80004004)
+	expect_value(t, win32.E_FAIL, 0x80004005)
+	expect_value(t, win32.E_UNEXPECTED, 0x8000FFFF)
+	expect_value(t, win32.E_ACCESSDENIED, 0x80070005)
+	expect_value(t, win32.E_HANDLE, 0x80070006)
+	expect_value(t, win32.E_OUTOFMEMORY, 0x8007000E)
+	expect_value(t, win32.E_INVALIDARG, 0x80070057)
+}
+
+@(test)
+verify_error_helpers :: proc(t: ^testing.T) {
+	// winerror.h
+	expect_value(t, win32.SUCCEEDED(-1), 0x00000000)
+	expect_value(t, win32.SUCCEEDED(0), 0x00000001)
+	expect_value(t, win32.SUCCEEDED(1), 0x00000001)
+
+	expect_value(t, win32.FAILED(-1), 0x00000001)
+	expect_value(t, win32.FAILED(0), 0x00000000)
+	expect_value(t, win32.FAILED(1), 0x00000000)
+
+	expect_value(t, win32.IS_ERROR(-1), 0x00000001)
+	expect_value(t, win32.IS_ERROR(0), 0x00000000)
+	expect_value(t, win32.IS_ERROR(1), 0x00000000)
+
+	expect_value(t, win32.HRESULT_CODE(0xFFFFCCCC), 0x0000CCCC)
+	expect_value(t, win32.HRESULT_FACILITY(0xFFFFCCCC), 0x00001FFF)
+	expect_value(t, win32.HRESULT_SEVERITY(0x12345678), 0x00000000)
+	expect_value(t, win32.HRESULT_SEVERITY(0x87654321), 0x00000001)
+
+	expect_value(t, win32.MAKE_HRESULT(1, 2, 3), 0x80020003)
+}

tests/core/sys/windows/test_winerror.odin

@@ -0,0 +1,34 @@
+//+build windows
+package test_core_sys_windows
+
+import "core:testing"
+import win32 "core:sys/windows"
+
+@(test)
+make_hresult :: proc(t: ^testing.T) {
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.SUCCESS, win32.FACILITY.NULL, win32.ERROR_SUCCESS), win32.S_OK)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0x4001), win32.E_NOTIMPL)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0x4002), win32.E_NOINTERFACE)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0x4003), win32.E_POINTER)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0x4004), win32.E_ABORT)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0x4005), win32.E_FAIL)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.NULL, 0xFFFF), win32.E_UNEXPECTED)
+
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.ERROR_ACCESS_DENIED), win32.E_ACCESSDENIED)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.ERROR_INVALID_HANDLE), win32.E_HANDLE)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.ERROR_OUTOFMEMORY), win32.E_OUTOFMEMORY)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.ERROR_INVALID_PARAMETER), win32.E_INVALIDARG)
+
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.System_Error.ACCESS_DENIED), win32.E_ACCESSDENIED)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.System_Error.INVALID_HANDLE), win32.E_HANDLE)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.System_Error.OUTOFMEMORY), win32.E_OUTOFMEMORY)
+	expect_value(t, win32.MAKE_HRESULT(win32.SEVERITY.ERROR, win32.FACILITY.WIN32, win32.System_Error.INVALID_PARAMETER), win32.E_INVALIDARG)
+}
+
+@(test)
+decode_hresult :: proc(t: ^testing.T) {
+	s, f, c := win32.DECODE_HRESULT(win32.E_INVALIDARG)
+	expect_value(t, s, win32.SEVERITY.ERROR)
+	expect_value(t, f, win32.FACILITY.WIN32)
+	expect_value(t, c, win32.System_Error.INVALID_PARAMETER)
+}

tests/core/sys/windows/win32gen/build.bat

@@ -0,0 +1,70 @@
+@echo off
+if "%VSCMD_ARG_TGT_ARCH%"=="" call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64
+set genconfig=Release
+pushd %~dp0
+
+set genname=win32gen
+set cl_output_path=%genname%\x64\%genconfig%
+set gen_output_path=x64\%genconfig%
+set genexe=%gen_output_path%\%genname%.exe
+
+if exist "%genexe%" (del /f "%genexe%" > NUL 2> NUL)
+
+:compiling
+echo Compiling...
+mkdir %cl_output_path% > NUL 2> NUL
+set compiler_flags=^
+/c /Zi /nologo /W3 /WX- ^
+/diagnostics:column /sdl /O2 /Oi /GL ^
+/D NDEBUG /D _CONSOLE /D _UNICODE /D UNICODE ^
+/Gm- /EHsc /MD /GS /Gy /fp:precise ^
+/Zc:wchar_t /Zc:forScope /Zc:inline ^
+/std:c++20 /permissive- /Fo"%cl_output_path%\\" ^
+/external:W3 /Gd /TP /FC /errorReport:queue
+
+@echo on
+cl %compiler_flags% win32gen.cpp
+@echo off
+if %ERRORLEVEL% NEQ 0 (goto error)
+
+:linking
+echo Linking...
+mkdir "%gen_output_path%" > NUL 2> NUL
+set libs=^
+kernel32.lib ^
+user32.lib ^
+gdi32.lib ^
+comdlg32.lib ^
+advapi32.lib ^
+shell32.lib ^
+ole32.lib ^
+uuid.lib
+set linker_flags=^
+/ERRORREPORT:QUEUE ^
+/OUT:%genexe% ^
+/NOLOGO ^
+%libs% ^
+/MANIFEST /MANIFESTUAC:"level='asInvoker' uiAccess='false'" /manifest:embed ^
+/SUBSYSTEM:CONSOLE ^
+/OPT:REF /OPT:ICF /LTCG:incremental ^
+/LTCGOUT:"%cl_output_path%\%genname%.iobj" ^
+/TLBID:1 /DYNAMICBASE /NXCOMPAT ^
+/IMPLIB:"%gen_output_path%\%genname%.lib" ^
+/MACHINE:X64
+
+@echo on
+link %linker_flags% %cl_output_path%\%genname%.obj
+@echo off
+if %ERRORLEVEL% NEQ 0 (goto error)
+
+:generate
+echo Generating...
+%genexe% ..\test_windows_generated.odin
+goto done
+
+:error
+echo Last command returned %ERRORLEVEL%
+
+:done
+popd
+echo Done.

tests/core/sys/windows/win32gen/win32gen.cpp

@@ -0,0 +1,932 @@
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#include <timeapi.h>
+#include <mmeapi.h>
+#include <windns.h>
+#include <commdlg.h>
+#include <winver.h>
+#include <shobjidl.h>
+#include <shellapi.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <wincrypt.h>
+#include <iostream>
+#include <fstream>
+#include <filesystem>
+#include <map>
+
+#include <cassert>
+#include <codecvt>
+#include <cstdint>
+#include <iostream>
+#include <locale>
+#include <string>
+using namespace std;
+using namespace std::filesystem;
+
+static std::string ConvertLPCWSTRToString(const LPCWSTR lpcwszStr)
+{
+	int strLength = WideCharToMultiByte(CP_UTF8, 0, lpcwszStr, -1, nullptr, 0, nullptr, nullptr) - 1;
+	string str(strLength, 0);
+	WideCharToMultiByte(CP_UTF8, 0, lpcwszStr, -1, &str[0], strLength, nullptr, nullptr);
+	return std::string(str);
+}
+
+#define test_proc_begin() out \
+	<< endl \
+	<< "@(test)" << endl \
+	<< __func__ << " :: proc(t: ^testing.T) {" << endl
+
+#define test_proc_end() out \
+	<< "}" << endl
+
+#define test_proc_using(name) out \
+	<< '\t' << "using " << name << endl
+
+#define test_proc_comment(comment) out \
+	<< '\t' << "// " << comment << endl
+
+#define expect_size(s) out \
+	<< '\t' << "expect_size(t, win32." << #s << ", " \
+	<< std::dec << sizeof(s) << ")" << endl
+
+#define expect_value(s) out \
+	<< '\t' << "expect_value(t, win32." << #s << ", " \
+	<< "0x" << std::uppercase << std::setfill('0') << std::setw(8) << std::hex << s << ")" << endl
+
+#define expect_value_32(s) out \
+	<< '\t' << "expect_value(t, u32(win32." << #s << "), " \
+	<< "0x" << std::uppercase << std::setfill('0') << std::setw(8) << std::hex << (ULONG)(ULONG_PTR)(s) << ")" << endl
+
+#define expect_value_64(s) out \
+	<< '\t' << "expect_value_64(t, u64(win32." << #s << "), " \
+	<< "0x" << std::uppercase << std::setfill('0') << std::setw(8) << std::hex << (ULONGLONG)(ULONG_PTR)(s) << ")" << endl
+
+#define expect_value_uintptr(s) out \
+	<< '\t' << "expect_value_64(t, uintptr(win32." << #s << "), " \
+	<< "0x" << std::uppercase << std::setfill('0') << std::setw(8) << std::hex << (ULONG_PTR)(s) << ")" << endl
+
+#define expect_value_str(s) out \
+	<< '\t' << "expect_value_str(t, win32." << #s << ", L(\"" << ConvertLPCWSTRToString(s) << "\"))" << endl
+
+static void verify_win32_type_sizes(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("minwindef.h");
+	expect_size(ULONG);	  // unsigned long
+	expect_size(PULONG);  // unsigned long*
+	expect_size(USHORT);  // unsigned short
+	expect_size(PUSHORT); // unsigned short*
+	expect_size(UCHAR);	  // unsigned char
+	// expect_size(PUCHAR);
+	// expect_size(PSZ);
+	expect_size(DWORD); // unsigned long
+	expect_size(BOOL);	// int
+	expect_size(BYTE);	// unsigned char
+	expect_size(WORD);	// unsigned short
+#ifdef PROPVARIANT
+	expect_size(FLOAT); // float
+	expect_size(DOUBLE); // double
+	expect_size(DATE); // double
+#endif
+	// expect_size(PFLOAT);
+	expect_size(PBOOL);
+	expect_size(LPBOOL);
+	expect_size(PBYTE);
+	expect_size(LPBYTE);
+	expect_size(PINT);
+	expect_size(LPINT);
+	// expect_size(PWORD);
+	expect_size(LPWORD);
+	// expect_size(LPLONG);
+	expect_size(PDWORD);
+	expect_size(LPDWORD);
+	expect_size(LPVOID);
+	expect_size(LPCVOID);
+
+	expect_size(INT);	// int
+	expect_size(UINT);	// unsigned int
+	expect_size(PUINT); // unsigned int*
+
+	expect_size(UINT_PTR); // unsigned __int64
+	expect_size(LONG_PTR); // __int64
+
+	expect_size(HANDLE);  // void *
+	expect_size(WPARAM);  // unsigned __int64
+	expect_size(LPARAM);  // __int64
+	expect_size(LRESULT); // __int64
+
+	expect_size(LPHANDLE);
+	expect_size(HGLOBAL); // void *
+	// expect_size(HLOCAL);
+	// expect_size(GLOBALHANDLE);
+	// expect_size(LOCALHANDLE);
+
+	expect_size(ATOM); // unsigned short
+	expect_size(HKEY);
+	expect_size(PHKEY);
+	// expect_size(HMETAFILE);
+	expect_size(HINSTANCE);
+	expect_size(HMODULE);
+	expect_size(HRGN);
+	expect_size(HRSRC);
+	// expect_size(HSPRITE);
+	// expect_size(HLSURF);
+	// expect_size(HSTR);
+	// expect_size(HTASK);
+	// expect_size(HWINSTA);
+	// expect_size(HKL);
+
+	//expect_size(HFILE);
+
+	test_proc_comment("windef.h");
+	expect_size(HWND);
+	expect_size(HHOOK);
+	expect_size(HGDIOBJ);
+	expect_size(HBITMAP);
+	expect_size(HPALETTE);
+	expect_size(HBRUSH);
+	expect_size(HPEN);
+	expect_size(HFONT);
+	expect_size(HICON);
+	expect_size(HMENU);
+	expect_size(HCURSOR);
+	expect_size(COLORREF);
+	expect_size(RECT);
+	expect_size(POINT);
+	expect_size(SIZE);
+
+	test_proc_comment("wtypes.h");
+	expect_size(DECIMAL);
+#ifdef PROPVARIANT
+	expect_size(CY);
+#endif
+
+	test_proc_comment("fileapi.h");
+	expect_size(WIN32_FILE_ATTRIBUTE_DATA);
+
+	test_proc_comment("libloaderapi.h");
+	expect_size(ENUMRESNAMEPROCW);
+	expect_size(ENUMRESTYPEPROCW);
+
+	test_proc_comment("minwinbase.h");
+	expect_size(SYSTEMTIME);
+	expect_size(WIN32_FIND_DATAW);
+	expect_size(CRITICAL_SECTION);
+	// expect_size(PROCESS_HEAP_ENTRY);
+	expect_size(REASON_CONTEXT);
+
+	test_proc_comment("guiddef.h");
+	expect_size(GUID);
+	expect_size(IID);
+	expect_size(CLSID);
+	test_proc_comment("combaseapi.h");
+	expect_size(SCODE);
+#ifdef PROPVARIANT
+	expect_size(VARTYPE);
+	expect_size(VARIANT_BOOL);
+	expect_size(CLIPDATA);
+	expect_size(SAFEARRAYBOUND);
+	expect_size(SAFEARRAY);
+	expect_size(CAPROPVARIANT);
+	expect_size(PROPVARIANT);
+#endif
+	test_proc_comment("commdlg.h");
+	expect_size(OPENFILENAMEW);
+	// test_proc_comment("windns.h");
+	// expect_size(DNS_RECORDA);
+	// expect_size(DNS_RECORDW);
+	// SHCreateLibrary
+	test_proc_comment("wtypesbase.h");
+	expect_size(OLECHAR);
+	//test_proc_comment("objbase.h");
+	//expect_value(COINIT_MULTITHREADED);
+	//expect_value(COINIT_APARTMENTTHREADED);
+	//expect_value(COINIT_DISABLE_OLE1DDE);
+	//expect_value(COINIT_SPEED_OVER_MEMORY);
+	test_proc_end();
+}
+
+static void verify_macros(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("minwindef.h");
+	expect_value(MAKEWORD(1, 2));
+	expect_value(MAKEWORD(0x1111, 0x2222));
+	expect_value(MAKELONG(1, 2));
+	expect_value(MAKELONG(0x1111, 0x2222));
+	expect_value(LOWORD(0x12345678));
+	expect_value(HIWORD(0x12345678));
+	expect_value_32(LOBYTE(0x1234));
+	expect_value_32(HIBYTE(0x1234));
+	test_proc_comment("winuser.h");
+	expect_value(MAKEWPARAM(1, 2));
+	expect_value(MAKEWPARAM(0x1111, 0x2222));
+	expect_value(MAKELPARAM(1, 2));
+	expect_value(MAKELPARAM(0x1111, 0x2222));
+	expect_value(MAKELRESULT(1, 2));
+	expect_value(MAKELRESULT(0x1111, 0x2222));
+	test_proc_comment("winnt.h");
+	expect_value(MAKELCID(1, 2));
+	expect_value(MAKELCID(0x1111, 0x2222));
+	expect_value(MAKELANGID(1, 2));
+	expect_value(MAKELANGID(0x111, 0x222));
+	expect_value(LANGIDFROMLCID(0x12345678));
+	test_proc_end();
+}
+
+static void verify_winnt(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winnt.h");
+	expect_size(CHAR);
+	expect_size(SHORT);
+	expect_size(LONG);
+	expect_size(INT);
+	expect_size(WCHAR);
+	// expect_size(LONGLONG);
+	expect_size(ULONGLONG);
+	expect_size(LARGE_INTEGER);
+	expect_size(PLARGE_INTEGER);
+	expect_size(ULARGE_INTEGER);
+	expect_size(PULARGE_INTEGER);
+	expect_size(BOOLEAN);
+	expect_size(HANDLE);
+	expect_size(PHANDLE);
+	expect_size(HRESULT);
+	// expect_size(CCHAR);
+	expect_size(LCID);
+	expect_size(LANGID);
+
+	expect_size(LUID);
+	expect_size(SECURITY_INFORMATION);
+	expect_size(ACCESS_MASK);
+	expect_size(REGSAM);
+	expect_value(LANG_NEUTRAL);
+	expect_value(LANG_INVARIANT);
+	expect_value(SUBLANG_NEUTRAL);
+	expect_value(SUBLANG_DEFAULT);
+	test_proc_end();
+}
+
+static void verify_winuser(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winuser.h");
+	//expect_value(UOI_FLAGS);
+	expect_size(USEROBJECTFLAGS);
+	expect_size(MSG);
+	expect_size(WINDOWPOS);
+	expect_size(ACCEL);
+	expect_size(MENUITEMINFOW);
+	expect_size(PAINTSTRUCT);
+	expect_size(CREATESTRUCTW);
+	expect_size(WINDOWPLACEMENT);
+	expect_size(MOUSEINPUT);
+	expect_size(KEYBDINPUT);
+	expect_size(HARDWAREINPUT);
+	expect_size(INPUT);
+
+	// expect_size(ICONINFO);
+	// expect_size(CURSORSHAPE);
+	expect_size(ICONINFOEXW);
+
+	expect_size(CURSORINFO);
+	//expect_value(CURSOR_SHOWING);
+	//expect_value(CURSOR_SUPPRESSED);
+
+	expect_size(WINDOWINFO);
+
+	expect_size(RAWINPUTHEADER);
+	//expect_size(RAWHID);
+	expect_size(RAWMOUSE);
+	expect_size(RAWKEYBOARD);
+	expect_size(RAWINPUT);
+	expect_size(RAWINPUTDEVICE);
+	expect_size(RAWINPUTDEVICELIST);
+
+	expect_size(RID_DEVICE_INFO_HID);
+	expect_size(RID_DEVICE_INFO_KEYBOARD);
+	expect_size(RID_DEVICE_INFO_MOUSE);
+	expect_size(RID_DEVICE_INFO);
+	expect_value(GET_RAWINPUT_CODE_WPARAM(0x12345678));
+
+	expect_size(DRAWTEXTPARAMS);
+	expect_size(BSMINFO);
+
+	expect_value(BROADCAST_QUERY_DENY);
+	expect_value_64(HWND_BROADCAST);
+	expect_value_64(HWND_MESSAGE);
+
+	expect_value_uintptr(MAKEINTRESOURCEW(1));
+	expect_value_uintptr(MAKEINTRESOURCEW(0x12345678));
+
+	expect_value_uintptr(RT_CURSOR);
+	expect_value_uintptr(RT_BITMAP);
+	expect_value_uintptr(RT_ICON);
+	expect_value_uintptr(RT_MENU);
+	expect_value_uintptr(RT_DIALOG);
+	expect_value_uintptr(RT_STRING);
+	expect_value_uintptr(RT_FONTDIR);
+	expect_value_uintptr(RT_FONT);
+	expect_value_uintptr(RT_ACCELERATOR);
+	expect_value_uintptr(RT_RCDATA);
+	expect_value_uintptr(RT_MESSAGETABLE);
+	expect_value_uintptr(RT_GROUP_CURSOR);
+	expect_value_uintptr(RT_GROUP_ICON);
+	expect_value_uintptr(RT_VERSION);
+	expect_value_uintptr(RT_DLGINCLUDE);
+	expect_value_uintptr(RT_PLUGPLAY);
+	expect_value_uintptr(RT_VXD);
+	expect_value_uintptr(RT_ANICURSOR);
+	expect_value_uintptr(RT_ANIICON);
+	expect_value_uintptr(RT_MANIFEST);
+
+	expect_value_uintptr(CREATEPROCESS_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(ISOLATIONAWARE_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(ISOLATIONPOLICY_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(ISOLATIONPOLICY_BROWSER_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(MINIMUM_RESERVED_MANIFEST_RESOURCE_ID);
+	expect_value_uintptr(MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID);
+
+	expect_value(SM_CXICON);
+	expect_value(SM_CYICON);
+
+	expect_value(LR_DEFAULTCOLOR);
+	expect_value(LR_MONOCHROME);
+	expect_value(LR_COLOR);
+	expect_value(LR_COPYRETURNORG);
+	expect_value(LR_COPYDELETEORG);
+	expect_value(LR_LOADFROMFILE);
+	expect_value(LR_LOADTRANSPARENT);
+	expect_value(LR_DEFAULTSIZE);
+	expect_value(LR_VGACOLOR);
+	expect_value(LR_LOADMAP3DCOLORS);
+	expect_value(LR_CREATEDIBSECTION);
+	expect_value(LR_COPYFROMRESOURCE);
+	expect_value(LR_SHARED);
+
+	expect_value(NIM_ADD);
+	expect_value(NIM_MODIFY);
+	expect_value(NIM_DELETE);
+	expect_value(NIM_SETFOCUS);
+	expect_value(NIM_SETVERSION);
+
+	expect_value(NIF_MESSAGE);
+	expect_value(NIF_ICON);
+	expect_value(NIF_TIP);
+	expect_value(NIF_STATE);
+	expect_value(NIF_INFO);
+	expect_value(NIF_GUID);
+	expect_value(NIF_REALTIME);
+	expect_value(NIF_SHOWTIP);
+
+	expect_value(MF_INSERT);
+	expect_value(MF_CHANGE);
+	expect_value(MF_APPEND);
+	expect_value(MF_DELETE);
+	expect_value(MF_REMOVE);
+	expect_value(MF_BYCOMMAND);
+	expect_value(MF_BYPOSITION);
+	expect_value(MF_SEPARATOR);
+	expect_value(MF_ENABLED);
+	expect_value(MF_GRAYED);
+	expect_value(MF_DISABLED);
+	expect_value(MF_UNCHECKED);
+	expect_value(MF_CHECKED);
+	expect_value(MF_USECHECKBITMAPS);
+	expect_value(MF_STRING);
+	expect_value(MF_BITMAP);
+	expect_value(MF_OWNERDRAW);
+	expect_value(MF_POPUP);
+	expect_value(MF_MENUBARBREAK);
+	expect_value(MF_MENUBREAK);
+	expect_value(MF_UNHILITE);
+	expect_value(MF_HILITE);
+	expect_value(MF_DEFAULT);
+	expect_value(MF_SYSMENU);
+	expect_value(MF_HELP);
+	expect_value(MF_RIGHTJUSTIFY);
+	expect_value(MF_MOUSESELECT);
+	expect_value(MF_END);
+
+	expect_value(MFS_GRAYED);
+	expect_value(MFS_DISABLED);
+	expect_value(MFS_CHECKED);
+	expect_value(MFS_HILITE);
+	expect_value(MFS_ENABLED);
+	expect_value(MFS_UNCHECKED);
+	expect_value(MFS_UNHILITE);
+	expect_value(MFS_DEFAULT);
+
+	expect_value(TPM_LEFTBUTTON);
+	expect_value(TPM_RIGHTBUTTON);
+	expect_value(TPM_LEFTALIGN);
+	expect_value(TPM_CENTERALIGN);
+	expect_value(TPM_RIGHTALIGN);
+	expect_value(TPM_TOPALIGN);
+	expect_value(TPM_VCENTERALIGN);
+	expect_value(TPM_BOTTOMALIGN);
+
+	expect_value(TPM_HORIZONTAL);
+	expect_value(TPM_VERTICAL);
+	expect_value(TPM_NONOTIFY);
+	expect_value(TPM_RETURNCMD);
+	expect_value(TPM_RECURSE);
+	expect_value(TPM_HORPOSANIMATION);
+	expect_value(TPM_HORNEGANIMATION);
+	expect_value(TPM_VERPOSANIMATION);
+	expect_value(TPM_VERNEGANIMATION);
+	expect_value(TPM_NOANIMATION);
+	expect_value(TPM_LAYOUTRTL);
+	expect_value(TPM_WORKAREA);
+
+	expect_value(MIIM_STATE);
+	expect_value(MIIM_ID);
+	expect_value(MIIM_SUBMENU);
+	expect_value(MIIM_CHECKMARKS);
+	expect_value(MIIM_TYPE);
+	expect_value(MIIM_DATA);
+	expect_value(MIIM_STRING);
+	expect_value(MIIM_BITMAP);
+	expect_value(MIIM_FTYPE);
+
+	expect_value(ANSI_CHARSET);
+	expect_value(DEFAULT_CHARSET);
+	expect_value(SYMBOL_CHARSET);
+	expect_value(SHIFTJIS_CHARSET);
+	expect_value(HANGEUL_CHARSET);
+	expect_value(HANGUL_CHARSET);
+	expect_value(GB2312_CHARSET);
+	expect_value(CHINESEBIG5_CHARSET);
+	expect_value(OEM_CHARSET);
+	expect_value(JOHAB_CHARSET);
+	expect_value(HEBREW_CHARSET);
+	expect_value(ARABIC_CHARSET);
+	expect_value(GREEK_CHARSET);
+	expect_value(TURKISH_CHARSET);
+	expect_value(VIETNAMESE_CHARSET);
+	expect_value(THAI_CHARSET);
+	expect_value(EASTEUROPE_CHARSET);
+	expect_value(RUSSIAN_CHARSET);
+	expect_value(MAC_CHARSET);
+	expect_value(BALTIC_CHARSET);
+
+	expect_value(FS_LATIN1);
+	expect_value(FS_LATIN2);
+	expect_value(FS_CYRILLIC);
+	expect_value(FS_GREEK);
+	expect_value(FS_TURKISH);
+	expect_value(FS_HEBREW);
+	expect_value(FS_ARABIC);
+	expect_value(FS_BALTIC);
+	expect_value(FS_VIETNAMESE);
+	expect_value(FS_THAI);
+	expect_value(FS_JISJAPAN);
+	expect_value(FS_CHINESESIMP);
+	expect_value(FS_WANSUNG);
+	expect_value(FS_CHINESETRAD);
+	expect_value(FS_JOHAB);
+	expect_value(FS_SYMBOL);
+
+	expect_value(OUT_DEFAULT_PRECIS);
+	expect_value(OUT_STRING_PRECIS);
+	expect_value(OUT_CHARACTER_PRECIS);
+	expect_value(OUT_STROKE_PRECIS);
+	expect_value(OUT_TT_PRECIS);
+	expect_value(OUT_DEVICE_PRECIS);
+	expect_value(OUT_RASTER_PRECIS);
+	expect_value(OUT_TT_ONLY_PRECIS);
+	expect_value(OUT_OUTLINE_PRECIS);
+	expect_value(OUT_SCREEN_OUTLINE_PRECIS);
+	expect_value(OUT_PS_ONLY_PRECIS);
+
+	expect_value(CLIP_DEFAULT_PRECIS);
+	expect_value(CLIP_CHARACTER_PRECIS);
+	expect_value(CLIP_STROKE_PRECIS);
+	expect_value(CLIP_MASK);
+	expect_value(CLIP_LH_ANGLES);
+	expect_value(CLIP_TT_ALWAYS);
+	expect_value(CLIP_DFA_DISABLE);
+	expect_value(CLIP_EMBEDDED);
+
+	expect_value(DEFAULT_QUALITY);
+	expect_value(DRAFT_QUALITY);
+	expect_value(PROOF_QUALITY);
+	expect_value(NONANTIALIASED_QUALITY);
+	expect_value(ANTIALIASED_QUALITY);
+	expect_value(CLEARTYPE_QUALITY);
+	expect_value(CLEARTYPE_NATURAL_QUALITY);
+
+	expect_value(DEFAULT_PITCH);
+	expect_value(FIXED_PITCH);
+	expect_value(VARIABLE_PITCH);
+	expect_value(MONO_FONT);
+
+	expect_value(FF_DONTCARE);
+	expect_value(FF_ROMAN);
+	expect_value(FF_SWISS);
+	expect_value(FF_MODERN);
+	expect_value(FF_SCRIPT);
+	expect_value(FF_DECORATIVE);
+
+	test_proc_end();
+}
+
+static void verify_gdi32(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("wingdi.h");
+	expect_size(DEVMODEW);
+	// expect_size(RGBTRIPLE);
+	expect_size(RGBQUAD);
+	expect_size(PIXELFORMATDESCRIPTOR);
+	expect_size(BITMAPINFOHEADER);
+	expect_size(BITMAP);
+	expect_size(BITMAPV5HEADER);
+	expect_size(CIEXYZTRIPLE);
+	expect_size(CIEXYZ);
+	expect_size(FXPT2DOT30);
+	expect_size(TEXTMETRICW);
+	expect_size(POINTFLOAT);
+	expect_size(GLYPHMETRICSFLOAT);
+	// expect_size(LOGPALETTE);
+	expect_size(PALETTEENTRY);
+	expect_size(DESIGNVECTOR);
+	expect_value(LF_FACESIZE);
+	expect_value(LF_FULLFACESIZE);
+	expect_size(LOGFONTW);
+	expect_size(ENUMLOGFONTW);
+	expect_size(ENUMLOGFONTEXW);
+	expect_size(ENUMLOGFONTEXDVW);
+	expect_size(NEWTEXTMETRICW);
+
+	expect_size(LAYERPLANEDESCRIPTOR);
+	expect_size(COLOR16);
+	expect_size(TRIVERTEX);
+	expect_size(GRADIENT_TRIANGLE);
+	expect_size(GRADIENT_RECT);
+	expect_size(BLENDFUNCTION);
+	expect_size(DISPLAY_DEVICEW);
+	expect_value(AC_SRC_OVER);
+	expect_value(AC_SRC_ALPHA);
+	expect_value(RGB(12, 34, 56));
+	expect_value(PALETTERGB(12, 34, 56));
+	expect_value(PALETTEINDEX(123));
+	expect_value(GRADIENT_FILL_RECT_H);
+	expect_value(GRADIENT_FILL_RECT_V);
+	expect_value(GRADIENT_FILL_TRIANGLE);
+
+	expect_value(BS_SOLID);
+	expect_value(BS_NULL);
+	expect_value(BS_HOLLOW);
+	expect_value(BS_HATCHED);
+	expect_value(BS_PATTERN);
+	expect_value(BS_INDEXED);
+	expect_value(BS_DIBPATTERN);
+	expect_value(BS_DIBPATTERNPT);
+	expect_value(BS_PATTERN8X8);
+	expect_value(BS_DIBPATTERN8X8);
+	expect_value(BS_MONOPATTERN);
+
+	expect_value(HS_HORIZONTAL);
+	expect_value(HS_VERTICAL);
+	expect_value(HS_FDIAGONAL);
+	expect_value(HS_BDIAGONAL);
+	expect_value(HS_CROSS);
+	expect_value(HS_DIAGCROSS);
+	expect_value(HS_API_MAX);
+
+	expect_value(PS_SOLID);
+	expect_value(PS_DASH);
+	expect_value(PS_DOT);
+	expect_value(PS_DASHDOT);
+	expect_value(PS_DASHDOTDOT);
+	expect_value(PS_NULL);
+	expect_value(PS_INSIDEFRAME);
+	expect_value(PS_USERSTYLE);
+	expect_value(PS_ALTERNATE);
+	expect_value(PS_STYLE_MASK);
+
+	expect_value(PS_ENDCAP_ROUND);
+	expect_value(PS_ENDCAP_SQUARE);
+	expect_value(PS_ENDCAP_FLAT);
+	expect_value(PS_ENDCAP_MASK);
+
+	expect_value(PS_JOIN_ROUND);
+	expect_value(PS_JOIN_BEVEL);
+	expect_value(PS_JOIN_MITER);
+
+	expect_value(PS_COSMETIC);
+	expect_value(PS_GEOMETRIC);
+	expect_value(PS_TYPE_MASK);
+
+	test_proc_comment("Binary raster ops");
+	expect_value(R2_BLACK);
+	expect_value(R2_NOTMERGEPEN);
+	expect_value(R2_MASKNOTPEN);
+	expect_value(R2_NOTCOPYPEN);
+	expect_value(R2_MASKPENNOT);
+	expect_value(R2_NOT);
+	expect_value(R2_XORPEN);
+	expect_value(R2_NOTMASKPEN);
+	expect_value(R2_MASKPEN);
+	expect_value(R2_NOTXORPEN);
+	expect_value(R2_NOP);
+	expect_value(R2_MERGENOTPEN);
+	expect_value(R2_COPYPEN);
+	expect_value(R2_MERGEPENNOT);
+	expect_value(R2_MERGEPEN);
+	expect_value(R2_WHITE);
+	test_proc_comment("Ternary raster operations");
+	expect_value(SRCCOPY);
+	expect_value(SRCPAINT);
+	expect_value(SRCAND);
+	expect_value(SRCINVERT);
+	expect_value(SRCERASE);
+	expect_value(NOTSRCCOPY);
+	expect_value(NOTSRCERASE);
+	expect_value(MERGECOPY);
+	expect_value(MERGEPAINT);
+	expect_value(PATCOPY);
+	expect_value(PATPAINT);
+	expect_value(PATINVERT);
+	expect_value(DSTINVERT);
+	expect_value(BLACKNESS);
+	expect_value(WHITENESS);
+	expect_value(NOMIRRORBITMAP);
+	expect_value(CAPTUREBLT);
+	test_proc_comment("Region Flags");
+	expect_value(ERROR);
+	expect_value(NULLREGION);
+	expect_value(SIMPLEREGION);
+	expect_value(COMPLEXREGION);
+	expect_value(RGN_ERROR);
+	test_proc_comment("CombineRgn() Styles");
+	expect_value(RGN_AND);
+	expect_value(RGN_OR);
+	expect_value(RGN_XOR);
+	expect_value(RGN_DIFF);
+	expect_value(RGN_COPY);
+	test_proc_comment("StretchBlt() Modes");
+	expect_value(BLACKONWHITE);
+	expect_value(WHITEONBLACK);
+	expect_value(COLORONCOLOR);
+	expect_value(HALFTONE);
+	//expect_value(STRETCH_ANDSCANS);
+	//expect_value(STRETCH_ORSCANS);
+	//expect_value(STRETCH_DELETESCANS);
+	//expect_value(STRETCH_HALFTONE);
+	test_proc_comment("PolyFill() Modes");
+	expect_value(ALTERNATE);
+	expect_value(WINDING);
+	test_proc_comment("Layout Orientation Options");
+	expect_value(LAYOUT_RTL);
+	expect_value(LAYOUT_BTT);
+	expect_value(LAYOUT_VBH);
+	expect_value(LAYOUT_ORIENTATIONMASK);
+	test_proc_comment("Text Alignment Options");
+	expect_value(TA_NOUPDATECP);
+	expect_value(TA_UPDATECP);
+	expect_value(TA_LEFT);
+	expect_value(TA_RIGHT);
+	expect_value(TA_CENTER);
+	expect_value(TA_TOP);
+	expect_value(TA_BOTTOM);
+	expect_value(TA_BASELINE);
+	expect_value(TA_RTLREADING);
+	expect_value(TA_MASK);
+	test_proc_end();
+}
+
+static void verify_winmm(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("timeapi.h");
+	expect_size(TIMECAPS);
+	test_proc_comment("mmsyscom.h");
+	expect_size(MMVERSION);
+	expect_size(MMTIME);
+	test_proc_comment("mmeapi.h");
+	expect_size(WAVEFORMATEX);
+	expect_size(WAVEHDR);
+	expect_size(WAVEINCAPSW);
+	expect_size(WAVEOUTCAPSW);
+	test_proc_end();
+}
+
+static void verify_advapi32(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("wincrypt.h");
+	expect_size(HCRYPTPROV);
+	test_proc_end();
+}
+
+static void verify_winnls(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winnls.h");
+	expect_value(CP_ACP);
+	expect_value(CP_OEMCP);
+	expect_value(CP_MACCP);
+	expect_value(CP_THREAD_ACP);
+	expect_value(CP_SYMBOL);
+	expect_value(CP_UTF7);
+	expect_value(CP_UTF8);
+	expect_value(MAX_DEFAULTCHAR);
+	expect_value(MAX_LEADBYTES);
+	expect_value(LOCALE_NAME_MAX_LENGTH);
+	expect_value(LOCALE_NAME_USER_DEFAULT);
+	expect_value_str(LOCALE_NAME_INVARIANT);
+	expect_value_str(LOCALE_NAME_SYSTEM_DEFAULT);
+	expect_size(LCTYPE);
+	expect_size(CPINFOEXW);
+	test_proc_end();
+}
+
+static void verify_winreg(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winreg.h");
+
+	expect_value(RRF_RT_REG_NONE);
+	expect_value(RRF_RT_REG_SZ);
+	expect_value(RRF_RT_REG_EXPAND_SZ);
+	expect_value(RRF_RT_REG_BINARY);
+	expect_value(RRF_RT_REG_DWORD);
+	expect_value(RRF_RT_REG_MULTI_SZ);
+	expect_value(RRF_RT_REG_QWORD);
+	expect_value(RRF_RT_DWORD);
+	expect_value(RRF_RT_QWORD);
+	expect_value(RRF_RT_ANY);
+	expect_value(RRF_NOEXPAND);
+	expect_value(RRF_ZEROONFAILURE);
+
+	test_proc_comment("winnt.h");
+	expect_value_32(HKEY_CLASSES_ROOT);
+	expect_value_32(HKEY_CURRENT_USER);
+	expect_value_32(HKEY_LOCAL_MACHINE);
+	expect_value_32(HKEY_USERS);
+	expect_value_32(HKEY_PERFORMANCE_DATA);
+	expect_value_32(HKEY_PERFORMANCE_TEXT);
+	expect_value_32(HKEY_PERFORMANCE_NLSTEXT);
+	expect_value_32(HKEY_CURRENT_CONFIG);
+	expect_value_32(HKEY_DYN_DATA);
+	expect_value_32(HKEY_CURRENT_USER_LOCAL_SETTINGS);
+
+	expect_value(DELETE);
+	expect_value(READ_CONTROL);
+	expect_value(WRITE_DAC);
+	expect_value(WRITE_OWNER);
+	expect_value(SYNCHRONIZE);
+
+	expect_value(KEY_QUERY_VALUE);
+	expect_value(KEY_SET_VALUE);
+	expect_value(KEY_CREATE_SUB_KEY);
+	expect_value(KEY_ENUMERATE_SUB_KEYS);
+	expect_value(KEY_NOTIFY);
+	expect_value(KEY_CREATE_LINK);
+	expect_value(KEY_WOW64_32KEY);
+	expect_value(KEY_WOW64_64KEY);
+	expect_value(KEY_WOW64_RES);
+	expect_value(KEY_READ);
+	expect_value(KEY_WRITE);
+	expect_value(KEY_EXECUTE);
+	expect_value(KEY_ALL_ACCESS);
+
+	// RegQueryInfoKey
+	test_proc_end();
+}
+
+static void verify_verrsrc(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("verrsrc.h");
+	//expect_value_64(VS_FILE_INFO);
+	expect_value(VS_VERSION_INFO);
+	expect_value(VS_USER_DEFINED);
+	expect_size(VS_FIXEDFILEINFO);
+	// expect_value(VS_FF_DEBUG);
+	// expect_value(VS_FF_PRERELEASE);
+	// expect_value(VS_FF_PATCHED);
+	expect_value(VS_FFI_SIGNATURE);
+	// VFF_DEBUG
+	// VFT_WINDOWS_DRV
+	// VFT_WINDOWS_DLL
+	test_proc_end();
+}
+
+static void verify_error_codes(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winerror.h");
+
+	expect_value(ERROR_SUCCESS);
+	expect_value(NO_ERROR);
+	expect_value(SEC_E_OK);
+	out << endl;
+	expect_value(ERROR_INVALID_FUNCTION);
+	expect_value(ERROR_FILE_NOT_FOUND);
+	expect_value(ERROR_PATH_NOT_FOUND);
+	expect_value(ERROR_ACCESS_DENIED);
+	expect_value(ERROR_INVALID_HANDLE);
+	expect_value(ERROR_NOT_ENOUGH_MEMORY);
+	expect_value(ERROR_INVALID_BLOCK);
+	expect_value(ERROR_BAD_ENVIRONMENT);
+	expect_value(ERROR_BAD_FORMAT);
+	expect_value(ERROR_INVALID_ACCESS);
+	expect_value(ERROR_INVALID_DATA);
+	expect_value(ERROR_OUTOFMEMORY);
+	expect_value(ERROR_INVALID_DRIVE);
+	expect_value(ERROR_CURRENT_DIRECTORY);
+	expect_value(ERROR_NO_MORE_FILES);
+	expect_value(ERROR_SHARING_VIOLATION);
+	expect_value(ERROR_LOCK_VIOLATION);
+	expect_value(ERROR_HANDLE_EOF);
+	expect_value(ERROR_NOT_SUPPORTED);
+	expect_value(ERROR_FILE_EXISTS);
+	expect_value(ERROR_INVALID_PARAMETER);
+	expect_value(ERROR_BROKEN_PIPE);
+	expect_value(ERROR_CALL_NOT_IMPLEMENTED);
+	expect_value(ERROR_INSUFFICIENT_BUFFER);
+	expect_value(ERROR_INVALID_NAME);
+	expect_value(ERROR_BAD_ARGUMENTS);
+	expect_value(ERROR_LOCK_FAILED);
+	expect_value(ERROR_ALREADY_EXISTS);
+	expect_value(ERROR_NO_DATA);
+	expect_value(ERROR_ENVVAR_NOT_FOUND);
+	expect_value(ERROR_OPERATION_ABORTED);
+	expect_value(ERROR_IO_PENDING);
+	expect_value(ERROR_NO_UNICODE_TRANSLATION);
+	expect_value(ERROR_TIMEOUT);
+	expect_value(ERROR_DATATYPE_MISMATCH);
+	expect_value(ERROR_UNSUPPORTED_TYPE);
+	expect_value(ERROR_NOT_SAME_OBJECT);
+	expect_value(ERROR_PIPE_CONNECTED);
+	expect_value(ERROR_PIPE_BUSY);
+	out << endl;
+	expect_value(S_OK);
+	expect_value(E_NOTIMPL);
+	expect_value(E_NOINTERFACE);
+	expect_value(E_POINTER);
+	expect_value(E_ABORT);
+	expect_value(E_FAIL);
+	expect_value(E_UNEXPECTED);
+	expect_value(E_ACCESSDENIED);
+	expect_value(E_HANDLE);
+	expect_value(E_OUTOFMEMORY);
+	expect_value(E_INVALIDARG);
+	// out << endl;
+	// expect_value(SEVERITY_SUCCESS);
+	// expect_value(SEVERITY_ERROR);
+	// out << endl;
+	// expect_value(FACILITY_NULL);
+	test_proc_end();
+}
+
+static void verify_error_helpers(ofstream& out) {
+	test_proc_begin();
+	test_proc_comment("winerror.h");
+
+	expect_value(SUCCEEDED(-1));
+	expect_value(SUCCEEDED(0));
+	expect_value(SUCCEEDED(1));
+	out << endl;
+	expect_value(FAILED(-1));
+	expect_value(FAILED(0));
+	expect_value(FAILED(1));
+	out << endl;
+	expect_value(IS_ERROR(-1));
+	expect_value(IS_ERROR(0));
+	expect_value(IS_ERROR(1));
+	out << endl;
+	expect_value(HRESULT_CODE(0xFFFFCCCC));
+	expect_value(HRESULT_FACILITY(0xFFFFCCCC));
+	expect_value(HRESULT_SEVERITY(0x12345678));
+	expect_value(HRESULT_SEVERITY(0x87654321));
+	out << endl;
+	expect_value(MAKE_HRESULT(1, 2, 3));
+
+	test_proc_end();
+}
+
+static void test_core_sys_windows(ofstream& out) {
+	out << "//+build windows" << endl
+		<< "package " << __func__
+		<< " // generated by " << path(__FILE__).filename().replace_extension("").string() << endl
+		<< endl
+		<< "import \"core:testing\"" << endl
+		<< "import win32 \"core:sys/windows\"" << endl;
+	verify_win32_type_sizes(out);
+	verify_macros(out);
+	verify_winnt(out);
+	verify_winuser(out);
+	verify_gdi32(out);
+	verify_winmm(out);
+	verify_advapi32(out);
+	verify_winnls(out);
+	verify_winreg(out);
+	verify_verrsrc(out);
+	verify_error_codes(out);
+	verify_error_helpers(out);
+}
+
+int main(int argc, char* argv[]) {
+	if (argc < 2) { cout << "Usage: " << path(argv[0]).filename().string() << " <odin-output-file>" << endl; return -1; }
+	auto filepath = path(argv[1]);
+	cout << "Writing " << filepath.string() << endl;
+	ofstream out(filepath);
+	test_core_sys_windows(out);
+	out.close();
+}

tests/core/sys/windows/win32gen/win32gen.vcxproj

@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{a31ceb6a-3f6f-4db6-82ce-8892efa48982}</ProjectGuid>
+    <RootNamespace>win32console</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="win32gen.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="build.bat" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

tests/core/sys/windows/win32gen/win32gen.vcxproj.filters

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="win32gen.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="build.bat">
+      <Filter>Source Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>