package core:sys/windows

Source

ACCEL :: struct {
	// Also called the flags field 
	fVirt: BYTE,
	key:   u16,
	cmd:   u16,
}

ACCESS_MASK :: u32

ACL :: struct {
	AclRevision: BYTE,
	Sbz1:        BYTE,
	AclSize:     u16,
	AceCount:    u16,
	Sbz2:        u16,
}

ACTCTXW :: struct {
	Size:                  u32,
	Flags:                 u32,
	Source:                cstring16,
	ProcessorArchitecture: u16,
	LangId:                u16,
	AssemblyDirectory:     cstring16,
	ResourceName:          cstring16,
	ApplicationName:       cstring16,
	Module:                HMODULE,
}

AC_Line_Status :: enum BYTE {
	Offline = 0, 
	Online  = 1, 
	Unknown = 255, 
}

ADDRESS_FAMILY :: u16

ADDRESS_MODE :: enum i32 {
	AddrMode1616, 
	AddrMode1632, 
	AddrModeReal, 
	AddrModeFlat, 
}

ADDRINFOA :: struct {
	ai_flags:     i32,
	ai_family:    i32,
	ai_socktype:  i32,
	ai_protocol:  i32,
	ai_addrlen:   uint,
	ai_canonname: [^]u8 `fmt:"q,ai_addrlen"`,
	ai_addr:      ^SOCKADDR,
	ai_next:      ^ADDRINFOA,
}

ADDRINFOEXW :: struct {
	ai_flags:     i32,
	ai_family:    i32,
	ai_socktype:  i32,
	ai_protocol:  i32,
	ai_addrlen:   uint,
	ai_canonname: cstring16,
	ai_addr:      ^sockaddr,
	ai_blob:      rawptr,
	ai_bloblen:   uint,
	ai_provider:  ^GUID,
	ai_next:      ^ADDRINFOEXW,
}

APPBARDATA :: struct {
	cbSize:           u32,
	hWnd:             HWND,
	uCallbackMessage: u32,
	uEdge:            u32,
	rc:               RECT,
	lParam:           int,
}

ASSOCCLASS :: enum i32 {
	SHELL_KEY        = 0, 
	PROGID_KEY, 
	PROGID_STR, 
	CLSID_KEY, 
	CLSID_STR, 
	APP_KEY, 
	APP_STR, 
	SYSTEM_STR, 
	FOLDER, 
	STAR, 
	FIXED_PROGID_STR, 
	PROTOCOL_STR, 
}

ASSOCDATA :: enum i32 {
	MSIDESCRIPTOR     = 1, 
	NOACTIVATEHANDLER, 
	UNUSED1, 
	HASPERUSERASSOC, 
	EDITFLAGS, 
	VALUE, 
	MAX, 
}

ASSOCENUM :: enum i32 {
	NONE, 
}

ASSOCF :: bit_set[ASSOCF_Bits; i32]

ASSOCF_Bits :: enum i32 {
	INIT_NOREMAPCLSID    = 0, 
	INIT_BYEXENAME       = 1, 
	OPEN_BYEXENAME       = 1, 
	INIT_DEFAULTTOSTAR   = 2, 
	INIT_DEFAULTTOFOLDER = 3, 
	NOUSERSETTINGS       = 4, 
	NOTRUNCATE           = 5, 
	VERIFY               = 6, 
	REMAPRUNDLL          = 7, 
	NOFIXUPS             = 8, 
	IGNOREBASECLASS      = 9, 
	INIT_IGNOREUNKNOWN   = 10, 
	INIT_FIXED_PROGID    = 11, 
	IS_PROTOCOL          = 12, 
	INIT_FOR_FILE        = 13, 
	IS_FULL_URI          = 14, 
	PER_MACHINE_ONLY     = 15, 
	APP_TO_APP           = 16, 
}

ASSOCIATIONELEMENT :: struct {
	ac:       ASSOCCLASS,
	hkClass:  HKEY,
	pszClass: cstring16,
}

ASSOCKEY :: enum i32 {
	SHELLEXECCLASS = 1, 
	APP, 
	CLASS, 
	BASECLASS, 
	MAX, 
}

ASSOCSTR :: enum i32 {
	COMMAND                 = 1, 
	EXECUTABLE, 
	FRIENDLYDOCNAME, 
	FRIENDLYAPPNAME, 
	NOOPEN, 
	SHELLNEWVALUE, 
	DDECOMMAND, 
	DDEIFEXEC, 
	DDEAPPLICATION, 
	DDETOPIC, 
	INFOTIP, 
	QUICKTIP, 
	TILEINFO, 
	CONTENTTYPE, 
	DEFAULTICON, 
	SHELLEXTENSION, 
	DROPTARGET, 
	DELEGATEEXECUTE, 
	SUPPORTED_URI_PROTOCOLS, 
	PROGID, 
	APPID, 
	APPPUBLISHER, 
	APPICONREFERENCE, 
	MAX, 
}

ATOM :: distinct u16

Address_Family :: enum u32 {
	Unspecified = 0,  // Return both IPv4 and IPv6 addresses associated with adapters with them enabled.
	IPv4        = 2,  // Return only IPv4 addresses associated with adapters with it enabled.
	IPv6        = 23, // Return only IPv6 addresses associated with adapters with it enabled.
}

BATTERY_DEVTYPE :: enum BYTE {
	GAMEPAD = 0x00, 
	HEADSET = 0x01, 
}

BATTERY_LEVEL :: enum BYTE {
	EMPTY  = 0x00, 
	LOW    = 0x01, 
	MEDIUM = 0x02, 
	FULL   = 0x03, 
}

BATTERY_TYPE :: enum BYTE {
	DISCONNECTED = 0x00, // This device is not connected
	WIRED        = 0x01, // Wired device, no battery
	ALKALINE     = 0x02, // Alkaline battery source
	NIMH         = 0x03, // Nickel Metal Hydride battery source
	UNKNOWN      = 0xFF, // Cannot determine the battery type
}

BIND_OPTS :: struct {
	cbStruct:            u32,
	grfFlags:            u32,
	grfMode:             u32,
	dwTickCountDeadline: u32,
}

BITMAP :: struct {
	bmType:       i32,
	bmWidth:      i32,
	bmHeight:     i32,
	bmWidthBytes: i32,
	bmPlanes:     u16,
	bmBitsPixel:  u16,
	bmBits:       rawptr,
}

BITMAPINFO :: struct {
	bmiHeader: BITMAPINFOHEADER,
	bmiColors: [1]RGBQUAD,
}

BITMAPINFOHEADER :: struct {
	biSize:          u32,
	biWidth:         i32,
	biHeight:        i32,
	biPlanes:        u16,
	biBitCount:      u16,
	biCompression:   u32,
	biSizeImage:     u32,
	biXPelsPerMeter: i32,
	biYPelsPerMeter: i32,
	biClrUsed:       u32,
	biClrImportant:  u32,
}

BITMAPV5HEADER :: struct {
	bV5Size:          u32,
	bV5Width:         i32,
	bV5Height:        i32,
	bV5Planes:        u16,
	bV5BitCount:      u16,
	bV5Compression:   u32,
	bV5SizeImage:     u32,
	bV5XPelsPerMeter: i32,
	bV5YPelsPerMeter: i32,
	bV5ClrUsed:       u32,
	bV5ClrImportant:  u32,
	bV5RedMask:       u32,
	bV5GreenMask:     u32,
	bV5BlueMask:      u32,
	bV5AlphaMask:     u32,
	bV5CSType:        u32,
	bV5Endpoints:     CIEXYZTRIPLE,
	bV5GammaRed:      u32,
	bV5GammaGreen:    u32,
	bV5GammaBlue:     u32,
	bV5Intent:        u32,
	bV5ProfileData:   u32,
	bV5ProfileSize:   u32,
	bV5Reserved:      u32,
}

BKMODE :: enum int {
	TRANSPARENT = 1, 
	OPAQUE      = 2, 
}

BLENDFUNCTION :: struct {
	BlendOp:             BYTE,
	BlendFlags:          BYTE,
	SourceConstantAlpha: BYTE,
	AlphaFormat:         BYTE,
}

BLUETOOTH_ADDRESS :: struct #raw_union {
	addr: u64,
	val:  [6]u8,
}

BLUETOOTH_DEVICE_INFO :: struct {
	dw_size:       u32,
	//  Size in bytes of this structure - must be the size_of(BLUETOOTH_DEVICE_INFO)
	address:       BLUETOOTH_ADDRESS,
	//  Bluetooth address
	device_class:  u32,
	//  Bluetooth "Class of Device". See: https://btprodspecificationrefs.blob.core.windows.net/assigned-numbers/Assigned%20Number%20Types/Baseband.pdf
	connected:     BOOL,
	//  Device connected/in use
	remembered:    BOOL,
	//  Device remembered
	authenticated: BOOL,
	//  Device authenticated/paired/bonded
	last_seen:     SYSTEMTIME,
	//  Last time the device was seen
	last_used:     SYSTEMTIME,
	//  Last time the device was used for other than RNR, inquiry, or SDP
	name:          [248]u16,
}

BLUETOOTH_DEVICE_SEARCH_PARAMS :: struct {
	dw_size:              u32,
	// Size of this structure
	return_authenticated: BOOL,
	// Return authenticated devices
	return_remembered:    BOOL,
	// Return remembered devices
	return_unknown:       BOOL,
	// Return unknown devices
	return_connected:     BOOL,
	// Return connected devices
	issue_inquiry:        BOOL,
	// Issue a new inquiry
	timeout_multiplier:   BYTE,
	// Timeout for the inquiry, expressed in increments of 1.28 seconds
	radio:                HANDLE,
}

BLUETOOTH_FIND_RADIO_PARAMS :: struct {
	dw_size: u32,
}

BLUETOOTH_RADIO_INFO :: struct {
	dw_size:           u32,
	// Size of this structure
	address:           BLUETOOTH_ADDRESS,
	// Address of radio
	name:              [248]u16,
	// Name of the radio
	device_class:      u32,
	// Bluetooth "Class of Device". See: https://btprodspecificationrefs.blob.core.windows.net/assigned-numbers/Assigned%20Number%20Types/Baseband.pdf
	lmp_minor_version: u16,
	// This member contains data specific to individual Bluetooth device manufacturers.
	manufacturer:      u16,
}

BOOL :: distinct b32

BOOLEAN :: distinct b8

BP_ANIMATIONPARAMS :: struct {
	cbSize:     u32,
	dwFlags:    u32,
	style:      BP_ANIMATIONSTYLE,
	dwDuration: u32,
}

BP_ANIMATIONSTYLE :: enum i32 {
	BPAS_NONE, 
	BPAS_LINEAR, 
	BPAS_CUBIC, 
	BPAS_SINE, 
}

BP_BUFFERFORMAT :: enum i32 {
	BPBF_COMPATIBLEBITMAP, 
	BPBF_DIB, 
	BPBF_TOPDOWNDIB, 
	BPBF_TOPDOWNMONODIB, 
}

BP_PAINTPARAMS :: struct {
	cbSize:         u32,
	dwFlags:        u32,
	prcExclude:     ^RECT,
	pBlendFunction: ^BLENDFUNCTION,
}

BSMINFO :: struct {
	cbSize: u32,
	hdesk:  HDESK,
	hwnd:   HWND,
	luid:   LUID,
}

BSTR :: ^u16

BUTTON_IMAGELIST :: struct {
	himl:   ^IUnknown,
	margin: RECT,
	uAlign: u32,
}

BUTTON_SPLITINFO :: struct {
	mask:        u32,
	himlGlyph:   ^IUnknown,
	uSplitStyle: u32,
	size:        SIZE,
}

BYTE :: distinct u8

BY_HANDLE_FILE_INFORMATION :: struct {
	dwFileAttributes:     u32,
	ftCreationTime:       FILETIME,
	ftLastAccessTime:     FILETIME,
	ftLastWriteTime:      FILETIME,
	dwVolumeSerialNumber: u32,
	nFileSizeHigh:        u32,
	nFileSizeLow:         u32,
	nNumberOfLinks:       u32,
	nFileIndexHigh:       u32,
	nFileIndexLow:        u32,
}

Battery_Flag :: enum BYTE {
	High       = 0, 
	Low        = 1, 
	Critical   = 2, 
	Charging   = 3, 
	No_Battery = 7, 
}

Battery_Flags :: bit_set[Battery_Flag; BYTE]

CACHE_DESCRIPTOR :: struct {
	Level:         BYTE,
	Associativity: BYTE,
	LineSize:      u16,
	Size:          u32,
	Type:          PROCESSOR_CACHE_TYPE,
}

CERT_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CERT_CONTEXT :: struct {
	dwCertEncodingType: u32,
	pbCertEncoded:      [^]u8,
	cbCertEncoded:      u32,
	pCertInfo:          ^CERT_INFO,
	hCertStore:         HCERTSTORE,
}

CERT_EXTENSION :: struct {
	pszObjId:  ^u8,
	fCritical: BOOL,
	Value:     CRYPT_OBJID_BLOB,
}

CERT_INFO :: struct {
	dwVersion:            u32,
	SerialNumber:         CRYPT_INTEGER_BLOB,
	SignatureAlgorithm:   CRYPT_ALGORITHM_IDENTIFIER,
	Issuer:               CERT_NAME_BLOB,
	NotBefore:            FILETIME,
	NotAfter:             FILETIME,
	Subject:              CERT_NAME_BLOB,
	SubjectPublicKeyInfo: CERT_PUBLIC_KEY_INFO,
	IssuerUniqueId:       CRYPT_BIT_BLOB,
	SubjectUniqueId:      CRYPT_BIT_BLOB,
	cExtension:           u32,
	rgExtension:          ^CERT_EXTENSION,
}

CERT_NAME_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CERT_PUBLIC_KEY_INFO :: struct {
	Algorithm: CRYPT_ALGORITHM_IDENTIFIER,
	PublicKey: CRYPT_BIT_BLOB,
}

CERT_RDN_VALUE_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CHAR :: u8

CHOOSECOLORW :: struct {
	lStructSize:    u32,
	hwndOwner:      HWND,
	hInstance:      HWND,
	rgbResult:      u32,
	lpCustColors:   ^u32,
	Flags:          u32,
	lCustData:      int,
	lpfnHook:       LPCCHOOKPROC,
	lpTemplateName: cstring16,
}

CHOOSEFONTW :: struct {
	lStructSize:            u32,
	hwndOwner:              HWND,
	// caller's window handle
	hDC:                    HDC,
	// printer DC/IC or NULL
	lpLogFont:              ^LOGFONTW,
	// ptr. to a LOGFONT struct
	iPointSize:             i32,
	// 10 * size in points of selected font
	Flags:                  u32,
	// enum. type flags
	rgbColors:              u32,
	// returned text color
	lCustData:              int,
	// data passed to hook fn.
	lpfnHook:               LPCFHOOKPROC,
	// ptr. to hook function
	lpTemplateName:         cstring16,
	// custom template name
	hInstance:              HANDLE,
	// instance handle of.EXE that contains cust. dlg. template
	lpszStyle:              ^u16,
	// must be LF_FACESIZE or bigger
	nFontType:              u16,
	// same value reported to the EnumFonts call back with the extra FONTTYPE_ bits added
	___MISSING_ALIGNMENT__: u16,
	nSizeMin:               i32,
	// minimum pt size allowed &
	nSizeMax:               i32,
}

CIEXYZ :: struct {
	ciexyzX: FXPT2DOT30,
	ciexyzY: FXPT2DOT30,
	ciexyzZ: FXPT2DOT30,
}

CIEXYZTRIPLE :: struct {
	ciexyzRed:   CIEXYZ,
	ciexyzGreen: CIEXYZ,
	ciexyzBlue:  CIEXYZ,
}

CLSID :: GUID

CODEPAGE :: enum u32 {
	// 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
}

COINIT :: enum u32 {
	APARTMENTTHREADED = 0x2, 
	MULTITHREADED     = 0, 
	DISABLE_OLE1DDE   = 0x4, 
	SPEED_OVER_MEMORY = 0x8, 
}

COLOR16 :: u16

COLORMAP :: struct {
	from: u32,
	to:   u32,
}

COLORREF :: u32

COLORSCHEME :: struct {
	dwSize:          u32,
	clrBtnHighlight: u32,
	clrBtnShadow:    u32,
}

COMBOBOXEXITEMW :: struct {
	mask:           u32,
	iItem:          int,
	pszText:        ^u16,
	cchTextMax:     i32,
	iImage:         i32,
	iSelectedImage: i32,
	iOverlay:       i32,
	iIndent:        i32,
	lParam:         int,
}

COMDLG_FILTERSPEC :: struct {
	pszName: cstring16,
	pszSpec: cstring16,
}

COMMTIMEOUTS :: struct {
	ReadIntervalTimeout:         u32,
	ReadTotalTimeoutMultiplier:  u32,
	ReadTotalTimeoutConstant:    u32,
	WriteTotalTimeoutMultiplier: u32,
	WriteTotalTimeoutConstant:   u32,
}

COMSTAT :: struct {
	using _:  bit_field u32 {
		fCtsHold:  BOOL | 1,
		fDsrHold:  BOOL | 1,
		fRlsdHol:  BOOL | 1,
		fXoffHol:  BOOL | 1,
		fXoffSen:  BOOL | 1,
		fEof:      BOOL | 1,
		fTxim:     BOOL | 1,
		fReserved: u32 | 25,
	},
	cbInQue:  u32,
	cbOutQue: u32,
}

CONDITION_VARIABLE :: struct {
	ptr: rawptr,
}

CONSOLE_CURSOR_INFO :: struct {
	dwSize:   u32,
	bVisible: BOOL,
}

CONSOLE_READCONSOLE_CONTROL :: struct {
	nLength:           u32,
	nInitialChars:     u32,
	dwCtrlWakeupMask:  u32,
	dwControlKeyState: u32,
}

CONSOLE_SCREEN_BUFFER_INFO :: struct {
	dwSize:              COORD,
	dwCursorPosition:    COORD,
	wAttributes:         u16,
	srWindow:            SMALL_RECT,
	dwMaximumWindowSize: COORD,
}

CONSOLE_SCREEN_BUFFER_INFOEX :: struct {
	cbSize:               u32,
	dwSize:               COORD,
	dwCursorPosition:     COORD,
	wAttributes:          u16,
	srWindow:             SMALL_RECT,
	dwMaximumWindowSize:  COORD,
	wPopupAttributes:     u16,
	bFullscreenSupported: BOOL,
	ColorTable:           [16]u32,
}

CONTEXT :: struct {
	P1Home:               u64,
	P2Home:               u64,
	P3Home:               u64,
	P4Home:               u64,
	P5Home:               u64,
	P6Home:               u64,
	ContextFlags:         u32,
	MxCsr:                u32,
	SegCs:                u16,
	SegDs:                u16,
	SegEs:                u16,
	SegFs:                u16,
	SegGs:                u16,
	SegSs:                u16,
	EFlags:               u32,
	Dr0:                  u64,
	Dr1:                  u64,
	Dr2:                  u64,
	Dr3:                  u64,
	Dr6:                  u64,
	Dr7:                  u64,
	Rax:                  u64,
	Rcx:                  u64,
	Rdx:                  u64,
	Rbx:                  u64,
	Rsp:                  u64,
	Rbp:                  u64,
	Rsi:                  u64,
	Rdi:                  u64,
	R8:                   u64,
	R9:                   u64,
	R10:                  u64,
	R11:                  u64,
	R12:                  u64,
	R13:                  u64,
	R14:                  u64,
	R15:                  u64,
	Rip:                  u64,
	using _:              struct #raw_union {
		FltSave: XSAVE_FORMAT,
		Q:       [16]NEON128,
		D:       [32]u64,
		using _: struct {
			Header: [2]M128A,
			Legacy: [8]M128A,
			Xmm0:   M128A,
			Xmm1:   M128A,
			Xmm2:   M128A,
			Xmm3:   M128A,
			Xmm4:   M128A,
			Xmm5:   M128A,
			Xmm6:   M128A,
			Xmm7:   M128A,
			Xmm8:   M128A,
			Xmm9:   M128A,
			Xmm10:  M128A,
			Xmm11:  M128A,
			Xmm12:  M128A,
			Xmm13:  M128A,
			Xmm14:  M128A,
			Xmm15:  M128A,
		},
		S:       [32]u32,
	},
	VectorRegister:       [26]M128A,
	VectorControl:        u64,
	DebugControl:         u64,
	LastBranchToRip:      u64,
	LastBranchFromRip:    u64,
	LastExceptionToRip:   u64,
	LastExceptionFromRip: u64,
}

COORD :: struct {
	X: i16,
	Y: i16,
}

COPYDATASTRUCT :: struct {
	dwData: uint,
	cbData: u32,
	lpData: rawptr,
}

CPINFOEXW :: struct {
	// Maximum length, in bytes, of a character in the code page.
	MaxCharSize:        u32,
	// The default is usually the "?" character for the code page.
	DefaultChar:        [2]BYTE,
	// A fixed-length array of lead byte ranges, for which the number of lead byte ranges is variable.
	LeadByte:           [12]BYTE,
	// The default is usually the "?" character or the katakana middle dot character.
	UnicodeDefaultChar: u16,
	// Code page value. This value reflects the code page passed to the GetCPInfoEx function.
	CodePage:           CODEPAGE,
	// Full name of the code page.
	CodePageName:       [260]u16,
}

CREATESTRUCTA :: struct {
	lpCreateParams: rawptr,
	hInstance:      HANDLE,
	hMenu:          HMENU,
	hwndParent:     HWND,
	cy:             i32,
	cx:             i32,
	y:              i32,
	x:              i32,
	style:          i32,
	lpszName:       cstring,
	lpszClass:      cstring,
	dwExStyle:      u32,
}

CREATESTRUCTW :: struct {
	lpCreateParams: rawptr,
	hInstance:      HANDLE,
	hMenu:          HMENU,
	hwndParent:     HWND,
	cy:             i32,
	cx:             i32,
	y:              i32,
	x:              i32,
	style:          i32,
	lpszName:       cstring16,
	lpszClass:      cstring16,
	dwExStyle:      u32,
}

CRITICAL_SECTION :: struct {
	CriticalSectionDebug: rawptr,
	LockCount:            i32,
	RecursionCount:       i32,
	OwningThread:         HANDLE,
	LockSemaphore:        HANDLE,
	SpinCount:            uint,
}

CRL_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPTOAPI_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_ALGORITHM_IDENTIFIER :: struct {
	pszObjId:   ^u8,
	Parameters: CRYPT_OBJID_BLOB,
}

CRYPT_ATTR_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_BIT_BLOB :: struct {
	cbData:      u32,
	pbData:      [^]u8,
	cUnusedBits: u32,
}

CRYPT_DATA_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_DER_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_DIGEST_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_HASH_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_INTEGER_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_OBJID_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CRYPT_UINT_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

CURSORINFO :: struct {
	cbSize:      u32,
	flags:       u32,
	hCursor:     HCURSOR,
	ptScreenPos: POINT,
}

CWPRETSTRUCT :: struct {
	lResult: int,
	lParam:  int,
	wParam:  uintptr,
	message: u32,
	hwnd:    HWND,
}

ChoosePixelFormatARBType :: proc "c" (hdc: HDC, attribIList: [^]i32, attribFList: [^]f32, maxFormats: u32, formats: [^]i32, numFormats: [^]u32) -> BOOL

Com_Error :: distinct bit_set[Com_Error_Bits; u32]

Com_Error_Bits :: enum u32 {
	RXOVER, 
	OVERRUN, 
	RXPARITY, 
	FRAME, 
	BREAK, 
}

Control_Key_State :: bit_set[Control_Key_State_Bits; u32]

Control_Key_State_Bits :: enum int {
	RIGHT_ALT_PRESSED, 
	LEFT_ALT_PRESSED, 
	RIGHT_CTRL_PRESSED, 
	LEFT_CTRL_PRESSED, 
	SHIFT_PRESSED, 
	NUMLOCK_ON, 
	SCROLLLOCK_ON, 
	CAPSLOCK_ON, 
	ENHANCED_KEY, 
}

CreateContextAttribsARBType :: proc "c" (hdc: HDC, hShareContext: rawptr, attribList: [^]i32) -> HGLRC

DATA_BLOB :: struct {
	cbData: u32,
	pbData: [^]u8 `fmt:s,cbData`,
}

DCB :: struct {
	DCBlength:  u32,
	BaudRate:   u32,
	using _:    bit_field u32 {
		fBinary:           bool | 1,
		fParity:           bool | 1,
		fOutxCtsFlow:      bool | 1,
		fOutxDsrFlow:      bool | 1,
		fDtrControl:       DTR_Control | 2,
		fDsrSensitivity:   bool | 1,
		fTXContinueOnXoff: bool | 1,
		fOutX:             bool | 1,
		fInX:              bool | 1,
		fErrorChar:        bool | 1,
		fNull:             bool | 1,
		fRtsControl:       RTS_Control | 2,
		fAbortOnError:     bool | 1,
	},
	wReserved:  u16,
	XOnLim:     u16,
	XOffLim:    u16,
	ByteSize:   BYTE,
	Parity:     Parity,
	StopBits:   Stop_Bits,
	XonChar:    u8,
	XoffChar:   u8,
	ErrorChar:  u8,
	EofChar:    u8,
	EvtChar:    u8,
	wReserved1: u16,
}

DECIMAL :: struct {
	wReserved: u16,
	using _:   struct #raw_union {
		using _:   struct {
			scale: BYTE,
			sign:  BYTE,
		},
		signscale: u16,
	},
	Hi32:      u32,
	using _:   struct #raw_union {
		using _: struct {
			Lo32:  u32,
			Mid32: u32,
		},
		Lo64: u64,
	},
}

DESIGNVECTOR :: struct {
	dvReserved: u32,
	dvNumAxes:  u32,
	dvValues:   [16]i32,
}

DEVMODEW :: struct {
	dmDeviceName:       [32]u16,
	dmSpecVersion:      u16,
	dmDriverVersion:    u16,
	dmSize:             u16,
	dmDriverExtra:      u16,
	dmFields:           u32,
	using _:            struct #raw_union {
		// Printer only fields.
		using _: struct {
			dmOrientation:   i16,
			dmPaperSize:     i16,
			dmPaperLength:   i16,
			dmPaperWidth:    i16,
			dmScale:         i16,
			dmCopies:        i16,
			dmDefaultSource: i16,
			dmPrintQuality:  i16,
		},
		// Display only fields.
		using _: struct {
			dmPosition:           POINT,
			dmDisplayOrientation: u32,
			dmDisplayFixedOutput: u32,
		},
	},
	dmColor:            i16,
	dmDuplex:           i16,
	dmYResolution:      i16,
	dmTTOption:         i16,
	dmCollate:          i16,
	dmFormName:         [32]u16,
	dmLogPixels:        u16,
	dmBitsPerPel:       u32,
	dmPelsWidth:        u32,
	dmPelsHeight:       u32,
	using _:            struct #raw_union {
		dmDisplayFlags: u32,
		dmNup:          u32,
	},
	dmDisplayFrequency: u32,
	dmICMMethod:        u32,
	dmICMIntent:        u32,
	dmMediaType:        u32,
	dmDitherType:       u32,
	dmReserved1:        u32,
	dmReserved2:        u32,
	dmPanningWidth:     u32,
	dmPanningHeight:    u32,
}

DEVNAMES :: struct {
	wDriverOffset: u16,
	wDeviceOffset: u16,
	wOutputOffset: u16,
	wDefault:      u16,
}

DISPLAY_DEVICEW :: struct {
	cb:           u32,
	DeviceName:   [32]u16,
	DeviceString: [128]u16,
	StateFlags:   u32,
	DeviceID:     [128]u16,
	DeviceKey:    [128]u16,
}

DNS_MX_DATAA :: struct {
	pNameExchange: cstring,
	// the hostname
	wPreference:   u16,
	// lower values preferred
	_:             u16,
}

DNS_PTR_DATAA :: cstring

DNS_QUERY_OPTION :: enum u32 {
	ACCEPT_TRUNCATED_RESPONSE = 0, 
	DNS_QUERY_USE_TCP_ONLY    = 1, 
	NO_RECURSION              = 2, 
	BYPASS_CACHE              = 3, 
	NO_WIRE_QUERY             = 4, 
	NO_LOCAL_NAME             = 5, 
	NO_HOSTS_FILE             = 6, 
	NO_NETBT                  = 7, 
	WIRE_ONLY                 = 8, 
	RETURN_MESSAGE            = 9, 
	MULTICAST_ONLY            = 10, 
	NO_MULTICAST              = 11, 
	TREAT_AS_FQDN             = 12, 
	ADDRCONFIG                = 13, 
	DUAL_ADDR                 = 14, 
	MULTICAST_WAIT            = 17, 
	MULTICAST_VERIFY          = 18, 
	DONT_RESET_TTL_VALUES     = 20, 
	DISABLE_IDN_ENCODING      = 21, 
	APPEND_MULTILABEL         = 23, 
}

DNS_QUERY_OPTIONS :: bit_set[DNS_QUERY_OPTION; u32]

DNS_RECORD :: struct {
	// aka DNS_RECORDA
	pNext:       ^DNS_RECORD,
	pName:       cstring,
	wType:       u16,
	wDataLength: u16,
	Flags:       u32,
	dwTtl:       u32,
	_:           u32,
	Data:        struct #raw_union #align (4) {
		CNAME: cstring,
		A:     u32be,
		// Ipv4 Address
		AAAA:  u128be,
		// Ipv6 Address
		TXT:   DNS_TXT_DATAA,
		NS:    cstring,
		MX:    DNS_MX_DATAA,
		SRV:   DNS_SRV_DATAA,
	},
}

DNS_SRV_DATAA :: struct {
	pNameTarget: cstring,
	wPriority:   u16,
	wWeight:     u16,
	wPort:       u16,
	_:           u16,
}

DNS_STATUS :: distinct u32

DNS_TXT_DATAA :: struct {
	dwStringCount: u32,
	pStringArray:  cstring,
}

DPI_AWARENESS_CONTEXT :: distinct rawptr

DRAWTEXTPARAMS :: struct {
	cbSize:        u32,
	iTabLength:    i32,
	iLeftMargin:   i32,
	iRightMargin:  i32,
	uiLengthDrawn: u32,
}

DTR_Control :: enum u8 {
	Disable   = 0, 
	Enable    = 1, 
	Handshake = 2, 
}

DWMNCRENDERINGPOLICY :: enum int {
	DWMNCRP_USEWINDOWSTYLE, 
	DWMNCRP_DISABLED, 
	DWMNCRP_ENABLED, 
	DWMNCRP_LAST, 
}

DWMWINDOWATTRIBUTE :: enum int {
	DWMWA_NCRENDERING_ENABLED            = 1, 
	DWMWA_NCRENDERING_POLICY, 
	DWMWA_TRANSITIONS_FORCEDISABLED, 
	DWMWA_ALLOW_NCPAINT, 
	DWMWA_CAPTION_BUTTON_BOUNDS, 
	DWMWA_NONCLIENT_RTL_LAYOUT, 
	DWMWA_FORCE_ICONIC_REPRESENTATION, 
	DWMWA_FLIP3D_POLICY, 
	DWMWA_EXTENDED_FRAME_BOUNDS, 
	DWMWA_HAS_ICONIC_BITMAP, 
	DWMWA_DISALLOW_PEEK, 
	DWMWA_EXCLUDED_FROM_PEEK, 
	DWMWA_CLOAK, 
	DWMWA_CLOAKED, 
	DWMWA_FREEZE_REPRESENTATION, 
	DWMWA_PASSIVE_UPDATE_MODE, 
	DWMWA_USE_HOSTBACKDROPBRUSH, 
	DWMWA_USE_IMMERSIVE_DARK_MODE        = 20, 
	DWMWA_WINDOW_CORNER_PREFERENCE       = 33, 
	DWMWA_BORDER_COLOR, 
	DWMWA_CAPTION_COLOR, 
	DWMWA_TEXT_COLOR, 
	DWMWA_VISIBLE_FRAME_BORDER_THICKNESS, 
	DWMWA_SYSTEMBACKDROP_TYPE, 
	DWMWA_LAST, 
}

DWM_WINDOW_CORNER_PREFERENCE :: enum i32 {
	DEFAULT, 
	DONOTROUND, 
	ROUND, 
	ROUNDSMALL, 
}

DWORD :: u32