From 465ac74020850bb88300d9d89d3cea91307fdd30 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Tue, 11 Jun 2024 18:19:16 +0200 Subject: [PATCH 01/10] more windows stuff --- core/sys/windows/advapi32.odin | 37 ++++ core/sys/windows/codepage.odin | 298 +++++++++++++++++++++++++++ core/sys/windows/gdi32.odin | 363 ++++++++++++++++++++++++++------- core/sys/windows/kernel32.odin | 49 ++++- core/sys/windows/ole32.odin | 16 +- core/sys/windows/shcore.odin | 25 +++ core/sys/windows/shell32.odin | 2 + core/sys/windows/types.odin | 120 ++++++++++- core/sys/windows/user32.odin | 269 ++++++++++++++++++------ core/sys/windows/util.odin | 61 +++++- core/sys/windows/winerror.odin | 230 ++++++++++++++++++++- core/sys/windows/winmm.odin | 17 +- core/sys/windows/winnls.odin | 31 +++ core/sys/windows/winver.odin | 92 +++++++++ 14 files changed, 1457 insertions(+), 153 deletions(-) create mode 100644 core/sys/windows/codepage.odin create mode 100644 core/sys/windows/shcore.odin create mode 100644 core/sys/windows/winnls.odin create mode 100644 core/sys/windows/winver.odin diff --git a/core/sys/windows/advapi32.odin b/core/sys/windows/advapi32.odin index 163bf2a5e..1e8060b3f 100644 --- a/core/sys/windows/advapi32.odin +++ b/core/sys/windows/advapi32.odin @@ -134,6 +134,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, diff --git a/core/sys/windows/codepage.odin b/core/sys/windows/codepage.odin new file mode 100644 index 000000000..90040f1ee --- /dev/null +++ b/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*/ +} diff --git a/core/sys/windows/gdi32.odin b/core/sys/windows/gdi32.odin index 6d53845de..6c7eda03d 100644 --- a/core/sys/windows/gdi32.odin +++ b/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: INT, yDest: INT, DestWidth: INT, DestHeight: INT, xSrc: INT, ySrc: INT, SrcWidth: INT, SrcHeight: INT, lpBits: VOID, lpbmi: ^BITMAPINFO, iUsage: UINT, rop: DWORD) -> INT --- + StretchBlt :: proc(hdcDest: HDC, xDest: INT, yDest: INT, wDest: INT, hDest: INT, hdcSrc: HDC, xSrc: INT, ySrc: INT, wSrc: INT, 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 --- + 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: 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 --- + 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" (r, g, b: u8) -> COLORREF { - return transmute(COLORREF)[4]u8{r, g, b, 0} +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) +} + +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 diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin index 16b6fa244..eb1fec2df 100644 --- a/core/sys/windows/kernel32.odin +++ b/core/sys/windows/kernel32.odin @@ -46,8 +46,11 @@ foreign kernel32 { dwCursorPosition: COORD) -> BOOL --- SetConsoleTextAttribute :: proc(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL --- - SetConsoleOutputCP :: proc(wCodePageID: UINT) -> BOOL --- - + GetConsoleCP :: proc() -> CODEPAGE --- + SetConsoleCP :: proc(wCodePageID: CODEPAGE) -> BOOL --- + GetConsoleOutputCP :: proc() -> CODEPAGE --- + SetConsoleOutputCP :: proc(wCodePageID: CODEPAGE) -> BOOL --- + GetFileInformationByHandle :: proc(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) -> BOOL --- SetHandleInformation :: proc(hObject: HANDLE, dwMask: DWORD, @@ -224,6 +227,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, @@ -408,11 +412,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: LOAD_LIBRARY_FLAGS) -> HMODULE --- FreeLibrary :: proc(h: HMODULE) -> BOOL --- GetProcAddress :: proc(h: HMODULE, c_str: LPCSTR) -> rawptr --- + 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 --- @@ -1228,3 +1255,19 @@ GMEM_INVALID_HANDLE :: 0x8000 GHND :: (GMEM_MOVEABLE | GMEM_ZEROINIT) GPTR :: (GMEM_FIXED | GMEM_ZEROINIT) + +LOAD_LIBRARY_FLAGS :: enum DWORD { + DONT_RESOLVE_DLL_REFERENCES = 0x00000001, + LOAD_LIBRARY_AS_DATAFILE = 0x00000002, + // reserved for internal LOAD_PACKAGED_LIBRARY = 0x00000004, + LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008, + LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x00000010, + LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020, + LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 0x00000040, + LOAD_LIBRARY_REQUIRE_SIGNED_TARGET = 0x00000080, + LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100, + LOAD_LIBRARY_SEARCH_APPLICATION_DIR = 0x00000200, + LOAD_LIBRARY_SEARCH_USER_DIRS = 0x00000400, + LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800, + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000, +} diff --git a/core/sys/windows/ole32.odin b/core/sys/windows/ole32.odin index d344db5f0..78b4b7226 100644 --- a/core/sys/windows/ole32.odin +++ b/core/sys/windows/ole32.odin @@ -38,7 +38,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( @@ -50,4 +51,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 --- } diff --git a/core/sys/windows/shcore.odin b/core/sys/windows/shcore.odin new file mode 100644 index 000000000..54f67989e --- /dev/null +++ b/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, +} diff --git a/core/sys/windows/shell32.odin b/core/sys/windows/shell32.odin index 4108d54d8..214a0f501 100644 --- a/core/sys/windows/shell32.odin +++ b/core/sys/windows/shell32.odin @@ -30,6 +30,8 @@ foreign shell32 { SHGetKnownFolderIDList :: proc(rfid: REFKNOWNFOLDERID, dwFlags: /* KNOWN_FOLDER_FLAG */ DWORD, hToken: HANDLE, ppidl: rawptr) -> HRESULT --- 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 --- } APPBARDATA :: struct { diff --git a/core/sys/windows/types.odin b/core/sys/windows/types.odin index 11d2774d6..35fc68abf 100644 --- a/core/sys/windows/types.odin +++ b/core/sys/windows/types.odin @@ -30,14 +30,19 @@ 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 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 @@ -137,11 +142,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 @@ -697,6 +705,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 @@ -922,6 +1016,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 @@ -2179,6 +2283,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 @@ -2393,8 +2505,10 @@ REFIID :: ^GUID REFGUID :: GUID IID :: GUID +LPIID :: ^IID CLSID :: GUID REFCLSID :: ^CLSID +LPCLSID :: ^CLSID CLSCTX_INPROC_SERVER :: 0x1 CLSCTX_INPROC_HANDLER :: 0x2 @@ -4165,7 +4279,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, @@ -4208,3 +4322,7 @@ SOCKADDR :: struct { sa_family: ADDRESS_FAMILY, 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 diff --git a/core/sys/windows/user32.odin b/core/sys/windows/user32.odin index 1fc0116f5..1463b3906 100644 --- a/core/sys/windows/user32.odin +++ b/core/sys/windows/user32.odin @@ -6,16 +6,16 @@ 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 --- RegisterClassW :: proc(lpWndClass: ^WNDCLASSW) -> ATOM --- RegisterClassExW :: proc(^WNDCLASSEXW) -> ATOM --- @@ -26,10 +26,10 @@ foreign user32 { lpClassName: LPCWSTR, lpWindowName: LPCWSTR, 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, @@ -38,24 +38,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 --- @@ -68,7 +77,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 --- @@ -82,33 +91,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 --- @@ -118,18 +120,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 --- @@ -142,34 +162,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 --- @@ -179,6 +200,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 --- @@ -213,14 +237,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 --- @@ -233,12 +257,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 --- @@ -249,19 +281,30 @@ foreign user32 { 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, @@ -286,11 +329,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 @@ -300,8 +343,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 { @@ -500,8 +543,8 @@ WINDOWPLACEMENT :: struct { flags: UINT, showCmd: UINT, ptMinPosition: POINT, - ptMaxPosition: POINT, - rcNormalPosition: RECT, + ptMaxPosition: POINT, + rcNormalPosition: RECT, } WINDOWINFO :: struct { @@ -519,10 +562,10 @@ WINDOWINFO :: struct { PWINDOWINFO :: ^WINDOWINFO DRAWTEXTPARAMS :: struct { - cbSize: UINT, - iTabLength: int, - iLeftMargin: int, - iRightMargin: int, + cbSize : UINT, + iTabLength: INT, + iLeftMargin: INT, + iRightMargin: INT, uiLengthDrawn: UINT, } PDRAWTEXTPARAMS :: ^DRAWTEXTPARAMS @@ -568,3 +611,95 @@ RedrawWindowFlags :: enum UINT { RDW_FRAME = 0x0400, 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 diff --git a/core/sys/windows/util.odin b/core/sys/windows/util.odin index c68d58de0..3b76de1da 100644 --- a/core/sys/windows/util.odin +++ b/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 } diff --git a/core/sys/windows/winerror.odin b/core/sys/windows/winerror.odin index 118327ffa..f99a90d4f 100644 --- a/core/sys/windows/winerror.odin +++ b/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 -SUCCEEDED :: #force_inline proc(#any_int result: int) -> bool { return result >= 0 } +// 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(#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 } +// 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, diff --git a/core/sys/windows/winmm.odin b/core/sys/windows/winmm.odin index 8ddef29c0..a1786c27a 100644 --- a/core/sys/windows/winmm.odin +++ b/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 diff --git a/core/sys/windows/winnls.odin b/core/sys/windows/winnls.odin new file mode 100644 index 000000000..292d2fad2 --- /dev/null +++ b/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 diff --git a/core/sys/windows/winver.odin b/core/sys/windows/winver.odin new file mode 100644 index 000000000..091d53d3a --- /dev/null +++ b/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, +} From 32dcb3caef2b1b060086a9d677e9b9e4fbfe6c84 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Tue, 11 Jun 2024 18:19:29 +0200 Subject: [PATCH 02/10] windows bindings test --- tests/core/sys/windows/test_kernel32.odin | 22 + tests/core/sys/windows/test_ole32.odin | 67 ++ tests/core/sys/windows/test_windows.odin | 112 +++ .../sys/windows/test_windows_generated.odin | 698 ++++++++++++++++++ tests/core/sys/windows/test_winerror.odin | 34 + 5 files changed, 933 insertions(+) create mode 100644 tests/core/sys/windows/test_kernel32.odin create mode 100644 tests/core/sys/windows/test_ole32.odin create mode 100644 tests/core/sys/windows/test_windows.odin create mode 100644 tests/core/sys/windows/test_windows_generated.odin create mode 100644 tests/core/sys/windows/test_winerror.odin diff --git a/tests/core/sys/windows/test_kernel32.odin b/tests/core/sys/windows/test_kernel32.odin new file mode 100644 index 000000000..7edc38853 --- /dev/null +++ b/tests/core/sys/windows/test_kernel32.odin @@ -0,0 +1,22 @@ +//+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, 0x02) + 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-GB" + testing.expectf(t, str == exp, "%v (should be: %v)", str, exp) + + cc2 := win32.LocaleNameToLCID(L("en-GB"), 0) + testing.expectf(t, cc2 == 0x809, "%#x (should be: %#x)", u32(cc2), 0x809) +} diff --git a/tests/core/sys/windows/test_ole32.odin b/tests/core/sys/windows/test_ole32.odin new file mode 100644 index 000000000..eb01c4489 --- /dev/null +++ b/tests/core/sys/windows/test_ole32.odin @@ -0,0 +1,67 @@ +//+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) +} + +// hr := CoInitializeEx(nil, .MULTITHREADED); +// testing.expectf(t, hr == 0, "%x (should be: %v)", u32(hr), 0) +// assert(SUCCEEDED(hr)) +// defer CoUninitialize() diff --git a/tests/core/sys/windows/test_windows.odin b/tests/core/sys/windows/test_windows.odin new file mode 100644 index 000000000..168618144 --- /dev/null +++ b/tests/core/sys/windows/test_windows.odin @@ -0,0 +1,112 @@ +//+build windows +package test_core_sys_windows + +import "core:fmt" +import "base:intrinsics" +import "core:os" +import "base:runtime" +import win32 "core:sys/windows" +import "core:testing" + +L :: intrinsics.constant_utf16_cstring + +TEST_count := 0 +TEST_fail := 0 + +t := &testing.T{} + +when ODIN_TEST { + expect :: testing.expect + expectf :: testing.expectf + log :: testing.log + fmt :: fmt +} else { + expect :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) { + TEST_count += 1 + if !condition { + TEST_fail += 1 + fmt.printf("[%v] %v\n", loc, message) + return + } + } + expectf :: proc( + t: ^testing.T, condition: bool, format: string, args: ..any, loc := #caller_location) { + TEST_count += 1 + if !condition { + TEST_fail += 1 + fmt.printf(format, ..args) + return + } + } + log :: proc(t: ^testing.T, v: any, loc := #caller_location) { + fmt.printf("[%v] ", loc) + fmt.printf("log: %v\n", v) + } +} + +@(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) +} + +main :: proc() { + verify_win32_type_sizes(t) + verify_macros(t) + verify_winnt(t) + verify_winuser(t) + verify_gdi32(t) + verify_winmm(t) + verify_advapi32(t) + verify_winnls(t) + verify_winreg(t) + verify_verrsrc(t) + verify_error_codes(t) + verify_error_helpers(t) + + lcid_to_local(t) + + string_from_clsid(t) + clsid_from_string(t) + string_from_iid(t) + iid_from_string(t) + verify_coinit(t) + + make_hresult(t) + decode_hresult(t) + + fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count) + if TEST_fail > 0 { + os.exit(1) + } +} diff --git a/tests/core/sys/windows/test_windows_generated.odin b/tests/core/sys/windows/test_windows_generated.odin new file mode 100644 index 000000000..5c1c74a96 --- /dev/null +++ b/tests/core/sys/windows/test_windows_generated.odin @@ -0,0 +1,698 @@ +//+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(0x1111, 0x2222), 0x00889911) + 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.RAWINPUTHEADER, 24) + expect_size(t, win32.RAWHID, 12) + 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_size(t, win32.WINDOWINFO, 60) + 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) +} diff --git a/tests/core/sys/windows/test_winerror.odin b/tests/core/sys/windows/test_winerror.odin new file mode 100644 index 000000000..adbdb7ce1 --- /dev/null +++ b/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) +} From 8403952fd20f2f2b8d7add7468e08920861fc4e2 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Tue, 11 Jun 2024 18:30:41 +0200 Subject: [PATCH 03/10] win32gen --- tests/core/sys/windows/test_kernel32.odin | 10 +- .../sys/windows/test_windows_generated.odin | 7 +- tests/core/sys/windows/win32gen/build.bat | 70 ++ tests/core/sys/windows/win32gen/win32gen.cpp | 932 ++++++++++++++++++ .../sys/windows/win32gen/win32gen.vcxproj | 142 +++ .../windows/win32gen/win32gen.vcxproj.filters | 27 + 6 files changed, 1181 insertions(+), 7 deletions(-) create mode 100644 tests/core/sys/windows/win32gen/build.bat create mode 100644 tests/core/sys/windows/win32gen/win32gen.cpp create mode 100644 tests/core/sys/windows/win32gen/win32gen.vcxproj create mode 100644 tests/core/sys/windows/win32gen/win32gen.vcxproj.filters diff --git a/tests/core/sys/windows/test_kernel32.odin b/tests/core/sys/windows/test_kernel32.odin index 7edc38853..81331fc9f 100644 --- a/tests/core/sys/windows/test_kernel32.odin +++ b/tests/core/sys/windows/test_kernel32.odin @@ -7,16 +7,18 @@ import "core:testing" @(test) lcid_to_local :: proc(t: ^testing.T) { - lcid: win32.LCID = win32.MAKELANGID(0x09, 0x02) + 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-GB" + exp :: "en-US" testing.expectf(t, str == exp, "%v (should be: %v)", str, exp) - cc2 := win32.LocaleNameToLCID(L("en-GB"), 0) - testing.expectf(t, cc2 == 0x809, "%#x (should be: %#x)", u32(cc2), 0x809) + cc2 := win32.LocaleNameToLCID(L(exp), 0) + testing.expectf(t, cc2 == 0x0409, "%#x (should be: %#x)", u32(cc2), 0x0409) + + //fmt.printfln("%0X", lcid) } diff --git a/tests/core/sys/windows/test_windows_generated.odin b/tests/core/sys/windows/test_windows_generated.odin index 5c1c74a96..13d09f4e1 100644 --- a/tests/core/sys/windows/test_windows_generated.odin +++ b/tests/core/sys/windows/test_windows_generated.odin @@ -107,7 +107,7 @@ verify_macros :: proc(t: ^testing.T) { 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(0x1111, 0x2222), 0x00889911) + expect_value(t, win32.MAKELANGID(0x111, 0x222), 0x00088911) expect_value(t, win32.LANGIDFROMLCID(0x12345678), 0x00005678) } @@ -156,8 +156,9 @@ verify_winuser :: proc(t: ^testing.T) { 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.RAWHID, 12) expect_size(t, win32.RAWMOUSE, 24) expect_size(t, win32.RAWKEYBOARD, 16) expect_size(t, win32.RAWINPUT, 48) @@ -167,7 +168,7 @@ verify_winuser :: proc(t: ^testing.T) { 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_size(t, win32.WINDOWINFO, 60) + 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) diff --git a/tests/core/sys/windows/win32gen/build.bat b/tests/core/sys/windows/win32gen/build.bat new file mode 100644 index 000000000..83b2da4a2 --- /dev/null +++ b/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. diff --git a/tests/core/sys/windows/win32gen/win32gen.cpp b/tests/core/sys/windows/win32gen/win32gen.cpp new file mode 100644 index 000000000..731173aa6 --- /dev/null +++ b/tests/core/sys/windows/win32gen/win32gen.cpp @@ -0,0 +1,932 @@ +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +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() << " " << endl; return -1; } + auto filepath = path(argv[1]); + cout << "Writing " << filepath.string() << endl; + ofstream out(filepath); + test_core_sys_windows(out); + out.close(); +} diff --git a/tests/core/sys/windows/win32gen/win32gen.vcxproj b/tests/core/sys/windows/win32gen/win32gen.vcxproj new file mode 100644 index 000000000..33c44c989 --- /dev/null +++ b/tests/core/sys/windows/win32gen/win32gen.vcxproj @@ -0,0 +1,142 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 17.0 + Win32Proj + {a31ceb6a-3f6f-4db6-82ce-8892efa48982} + win32console + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + true + true + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/core/sys/windows/win32gen/win32gen.vcxproj.filters b/tests/core/sys/windows/win32gen/win32gen.vcxproj.filters new file mode 100644 index 000000000..30cdcd8c6 --- /dev/null +++ b/tests/core/sys/windows/win32gen/win32gen.vcxproj.filters @@ -0,0 +1,27 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Source Files + + + \ No newline at end of file From 3291c59728f298a725c815118311e385a9d1e059 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Thu, 11 Jul 2024 21:37:37 +0200 Subject: [PATCH 04/10] post rebase --- core/sys/windows/kernel32.odin | 30 +++++------------------------- core/sys/windows/user32.odin | 5 +---- 2 files changed, 6 insertions(+), 29 deletions(-) diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin index c2f97fff9..bb4cf2619 100755 --- a/core/sys/windows/kernel32.odin +++ b/core/sys/windows/kernel32.odin @@ -51,14 +51,10 @@ 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 --- + 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 --- @@ -446,7 +442,7 @@ foreign kernel32 { AddDllDirectory :: proc(NewDirectory: PCWSTR) -> rawptr --- RemoveDllDirectory :: proc(Cookie: rawptr) -> BOOL --- LoadLibraryW :: proc(c_str: LPCWSTR) -> HMODULE --- - LoadLibraryExW :: proc(c_str: LPCWSTR, hFile: HANDLE, dwFlags: LOAD_LIBRARY_FLAGS) -> 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 --- @@ -1163,20 +1159,4 @@ GMEM_INVALID_HANDLE :: 0x8000 GHND :: (GMEM_MOVEABLE | GMEM_ZEROINIT) GPTR :: (GMEM_FIXED | GMEM_ZEROINIT) -LOAD_LIBRARY_FLAGS :: enum DWORD { - DONT_RESOLVE_DLL_REFERENCES = 0x00000001, - LOAD_LIBRARY_AS_DATAFILE = 0x00000002, - // reserved for internal LOAD_PACKAGED_LIBRARY = 0x00000004, - LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008, - LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x00000010, - LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020, - LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 0x00000040, - LOAD_LIBRARY_REQUIRE_SIGNED_TARGET = 0x00000080, - LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100, - LOAD_LIBRARY_SEARCH_APPLICATION_DIR = 0x00000200, - LOAD_LIBRARY_SEARCH_USER_DIRS = 0x00000400, - LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800, - LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000, -} - LPTOP_LEVEL_EXCEPTION_FILTER :: PVECTORED_EXCEPTION_HANDLER diff --git a/core/sys/windows/user32.odin b/core/sys/windows/user32.odin index 0ad479dd8..96ccb7dda 100644 --- a/core/sys/windows/user32.odin +++ b/core/sys/windows/user32.odin @@ -37,10 +37,7 @@ foreign user32 { lpClassName: LPCWSTR, lpWindowName: LPCWSTR, dwStyle: DWORD, - X: INT, - Y: INT, - nWidth: INT, - nHeight: INT, + X, Y, nWidth, nHeight: INT, hWndParent: HWND, hMenu: HMENU, hInstance: HINSTANCE, From fe4754a77c9aa36e2b705b22e89bb1952fb05565 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Thu, 25 Jul 2024 10:27:49 +0200 Subject: [PATCH 05/10] format --- core/sys/windows/gdi32.odin | 4 ++-- core/sys/windows/user32.odin | 38 ++++++++++++++++++------------------ 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/core/sys/windows/gdi32.odin b/core/sys/windows/gdi32.odin index 6c7eda03d..6788ed2ea 100644 --- a/core/sys/windows/gdi32.odin +++ b/core/sys/windows/gdi32.odin @@ -23,8 +23,8 @@ foreign gdi32 { 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: INT, yDest: INT, DestWidth: INT, DestHeight: INT, xSrc: INT, ySrc: INT, SrcWidth: INT, SrcHeight: INT, lpBits: VOID, lpbmi: ^BITMAPINFO, iUsage: UINT, rop: DWORD) -> INT --- - StretchBlt :: proc(hdcDest: HDC, xDest: INT, yDest: INT, wDest: INT, hDest: INT, hdcSrc: HDC, xSrc: INT, ySrc: INT, wSrc: INT, hSrc: INT, rop: DWORD) -> BOOL --- + 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 --- SetPixelFormat :: proc(hdc: HDC, format: INT, ppfd: ^PIXELFORMATDESCRIPTOR) -> BOOL --- ChoosePixelFormat :: proc(hdc: HDC, ppfd: ^PIXELFORMATDESCRIPTOR) -> INT --- diff --git a/core/sys/windows/user32.odin b/core/sys/windows/user32.odin index 96ccb7dda..656da86ed 100644 --- a/core/sys/windows/user32.odin +++ b/core/sys/windows/user32.odin @@ -570,7 +570,7 @@ WINDOWINFO :: struct { PWINDOWINFO :: ^WINDOWINFO DRAWTEXTPARAMS :: struct { - cbSize : UINT, + cbSize: UINT, iTabLength: INT, iLeftMargin: INT, iRightMargin: INT, @@ -631,9 +631,9 @@ GetUserObjectInformationFlags :: enum INT { } USEROBJECTFLAGS :: struct { - fInherit: BOOL, - fReserved: BOOL, - dwFlags: DWORD, + fInherit: BOOL, + fReserved: BOOL, + dwFlags: DWORD, } PROPENUMPROCW :: #type proc(unnamedParam1: HWND, unnamedParam2: LPCWSTR, unnamedParam3: HANDLE) -> BOOL @@ -688,18 +688,18 @@ 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 + 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 { @@ -716,7 +716,7 @@ PDISPLAY_DEVICEW :: ^DISPLAY_DEVICEW WinEventFlags :: bit_set[WinEventFlag; DWORD] WinEventFlag :: enum DWORD { - SKIPOWNTHREAD = 0, - SKIPOWNPROCESS = 1, - INCONTEXT = 2, + SKIPOWNTHREAD = 0, + SKIPOWNPROCESS = 1, + INCONTEXT = 2, } From 58ab6e5f94f8aa6f0b8186e4b15b0e711921c1d8 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Fri, 26 Jul 2024 10:07:20 +0200 Subject: [PATCH 06/10] missign cursorinfo --- core/sys/windows/user32.odin | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/core/sys/windows/user32.odin b/core/sys/windows/user32.odin index 656da86ed..02cf0a54d 100644 --- a/core/sys/windows/user32.odin +++ b/core/sys/windows/user32.odin @@ -287,6 +287,8 @@ 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 --- @@ -371,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)) } @@ -569,6 +575,15 @@ WINDOWINFO :: struct { } PWINDOWINFO :: ^WINDOWINFO +CURSORINFO :: struct { + cbSize: DWORD, + flags: DWORD, + hCursor: HCURSOR, + ptScreenPos: POINT, +} +PCURSORINFO :: ^CURSORINFO + + DRAWTEXTPARAMS :: struct { cbSize: UINT, iTabLength: INT, From 6e6f2a1f6b3e1e24d3ecc471e86bde798878fad4 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Fri, 26 Jul 2024 10:14:13 +0200 Subject: [PATCH 07/10] removed obsolete fiels on WIN32_FIND_DATAW to match the size from the winsdk headers --- core/sys/windows/types.odin | 3 --- 1 file changed, 3 deletions(-) diff --git a/core/sys/windows/types.odin b/core/sys/windows/types.odin index 591041aed..e10e53cf9 100644 --- a/core/sys/windows/types.odin +++ b/core/sys/windows/types.odin @@ -1141,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 { From 03f3ea5a9e40b4636238ee840845b66a585ad5e4 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Fri, 26 Jul 2024 10:43:26 +0200 Subject: [PATCH 08/10] removed old test stuff --- tests/core/sys/windows/test_windows.odin | 68 +----------------------- 1 file changed, 1 insertion(+), 67 deletions(-) diff --git a/tests/core/sys/windows/test_windows.odin b/tests/core/sys/windows/test_windows.odin index 168618144..724b1b7af 100644 --- a/tests/core/sys/windows/test_windows.odin +++ b/tests/core/sys/windows/test_windows.odin @@ -1,48 +1,13 @@ //+build windows package test_core_sys_windows -import "core:fmt" import "base:intrinsics" -import "core:os" import "base:runtime" import win32 "core:sys/windows" import "core:testing" L :: intrinsics.constant_utf16_cstring - -TEST_count := 0 -TEST_fail := 0 - -t := &testing.T{} - -when ODIN_TEST { - expect :: testing.expect - expectf :: testing.expectf - log :: testing.log - fmt :: fmt -} else { - expect :: proc(t: ^testing.T, condition: bool, message: string, loc := #caller_location) { - TEST_count += 1 - if !condition { - TEST_fail += 1 - fmt.printf("[%v] %v\n", loc, message) - return - } - } - expectf :: proc( - t: ^testing.T, condition: bool, format: string, args: ..any, loc := #caller_location) { - TEST_count += 1 - if !condition { - TEST_fail += 1 - fmt.printf(format, ..args) - return - } - } - log :: proc(t: ^testing.T, v: any, loc := #caller_location) { - fmt.printf("[%v] ", loc) - fmt.printf("log: %v\n", v) - } -} +expectf :: testing.expectf @(private) expect_size :: proc(t: ^testing.T, $act: typeid, exp: int, loc := #caller_location) { @@ -79,34 +44,3 @@ expect_value_str :: proc(t: ^testing.T, wact, wexp: win32.wstring, loc := #calle 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) } - -main :: proc() { - verify_win32_type_sizes(t) - verify_macros(t) - verify_winnt(t) - verify_winuser(t) - verify_gdi32(t) - verify_winmm(t) - verify_advapi32(t) - verify_winnls(t) - verify_winreg(t) - verify_verrsrc(t) - verify_error_codes(t) - verify_error_helpers(t) - - lcid_to_local(t) - - string_from_clsid(t) - clsid_from_string(t) - string_from_iid(t) - iid_from_string(t) - verify_coinit(t) - - make_hresult(t) - decode_hresult(t) - - fmt.printf("%v/%v tests successful.\n", TEST_count - TEST_fail, TEST_count) - if TEST_fail > 0 { - os.exit(1) - } -} From fe587ee79a891bb2ae9a0ae43aef4351a1f1aafa Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Fri, 26 Jul 2024 11:04:13 +0200 Subject: [PATCH 09/10] try to add sys/windows to the normal core tests --- tests/core/normal.odin | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/core/normal.odin b/tests/core/normal.odin index 065090be3..7d5795273 100644 --- a/tests/core/normal.odin +++ b/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" From 271ec643ed986f1d3e5c7c6915b90488c6912d20 Mon Sep 17 00:00:00 2001 From: Thomas la Cour Date: Fri, 26 Jul 2024 11:30:48 +0200 Subject: [PATCH 10/10] removed some comments --- tests/core/sys/windows/test_ole32.odin | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/core/sys/windows/test_ole32.odin b/tests/core/sys/windows/test_ole32.odin index eb01c4489..30bf5bc80 100644 --- a/tests/core/sys/windows/test_ole32.odin +++ b/tests/core/sys/windows/test_ole32.odin @@ -60,8 +60,3 @@ verify_coinit :: proc(t: ^testing.T) { expect_value(t, win32.COINIT.DISABLE_OLE1DDE, 0x00000004) expect_value(t, win32.COINIT.SPEED_OVER_MEMORY, 0x00000008) } - -// hr := CoInitializeEx(nil, .MULTITHREADED); -// testing.expectf(t, hr == 0, "%x (should be: %v)", u32(hr), 0) -// assert(SUCCEEDED(hr)) -// defer CoUninitialize()