1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! Procedure declarations, constant definitions, and macros for the NLS component.
7 use ctypes::c_int;
8 use shared::basetsd::LONG_PTR;
9 use shared::guiddef::GUID;
10 use shared::minwindef::{
11     BOOL, BYTE, DWORD, INT, LPARAM, LPDWORD, LPINT, LPVOID, LPWORD, MAX_PATH, PDWORD, PULONG,
12     UINT,
13 };
14 use um::minwinbase::SYSTEMTIME;
15 use um::winnt::{
16     CHAR, LANGID, LCID, LONG, LPCSTR, LPCWCH, LPCWSTR, LPSTR, LPWSTR, PCNZCH, PCNZWCH, PCWSTR,
17     PCZZWSTR, PULONGLONG, PWSTR, PZZWSTR, ULONGLONG, WCHAR,
18 };
19 pub const MAX_LEADBYTES: usize = 12;
20 pub const MAX_DEFAULTCHAR: usize = 2;
21 pub const MB_PRECOMPOSED: DWORD = 0x00000001;
22 pub const MB_COMPOSITE: DWORD = 0x00000002;
23 pub const MB_USEGLYPHCHARS: DWORD = 0x00000004;
24 pub const MB_ERR_INVALID_CHARS: DWORD = 0x00000008;
25 pub const WC_COMPOSITECHECK: DWORD = 0x00000200;
26 pub const WC_DISCARDNS: DWORD = 0x00000010;
27 pub const WC_SEPCHARS: DWORD = 0x00000020;
28 pub const WC_DEFAULTCHAR: DWORD = 0x00000040;
29 pub const WC_ERR_INVALID_CHARS: DWORD = 0x00000080;
30 pub const WC_NO_BEST_FIT_CHARS: DWORD = 0x00000400;
31 pub const CP_ACP: DWORD = 0;
32 pub const CP_OEMCP: DWORD = 1;
33 pub const CP_MACCP: DWORD = 2;
34 pub const CP_THREAD_ACP: DWORD = 3;
35 pub const CP_SYMBOL: DWORD = 42;
36 pub const CP_UTF7: DWORD = 65000;
37 pub const CP_UTF8: DWORD = 65001;
38 pub type LGRPID = DWORD;
39 pub type LCTYPE = DWORD;
40 pub type CALTYPE = DWORD;
41 pub type CALID = DWORD;
42 STRUCT!{struct CPINFO {
43     MaxCharSize: UINT,
44     DefaultChar: [BYTE; MAX_DEFAULTCHAR],
45     LeadByte: [BYTE; MAX_LEADBYTES],
46 }}
47 pub type LPCPINFO = *mut CPINFO;
48 STRUCT!{struct CPINFOEXA {
49     MaxCharSize: UINT,
50     DefaultChar: [BYTE; MAX_DEFAULTCHAR],
51     LeadByte: [BYTE; MAX_LEADBYTES],
52     UnicodeDefaultChar: WCHAR,
53     CodePage: UINT,
54     CodePageName: [CHAR; MAX_PATH],
55 }}
56 pub type LPCPINFOEXA = *mut CPINFOEXA;
57 STRUCT!{struct CPINFOEXW {
58     MaxCharSize: UINT,
59     DefaultChar: [BYTE; MAX_DEFAULTCHAR],
60     LeadByte: [BYTE; MAX_LEADBYTES],
61     UnicodeDefaultChar: WCHAR,
62     CodePage: UINT,
63     CodePageName: [WCHAR; MAX_PATH],
64 }}
65 pub type LPCPINFOEXW = *mut CPINFOEXW;
66 STRUCT!{struct NUMBERFMTA {
67     NumDigits: UINT,
68     LeadingZero: UINT,
69     Grouping: UINT,
70     lpDecimalSep: LPSTR,
71     lpThousandSep: LPSTR,
72     NegativeOrder: UINT,
73 }}
74 pub type LPNUMBERFMTA = *mut NUMBERFMTA;
75 STRUCT!{struct NUMBERFMTW {
76     NumDigits: UINT,
77     LeadingZero: UINT,
78     Grouping: UINT,
79     lpDecimalSep: LPWSTR,
80     lpThousandSep: LPWSTR,
81     NegativeOrder: UINT,
82 }}
83 pub type LPNUMBERFMTW = *mut NUMBERFMTW;
84 STRUCT!{struct CURRENCYFMTA {
85     NumDigits: UINT,
86     LeadingZero: UINT,
87     Grouping: UINT,
88     lpDecimalSep: LPSTR,
89     lpThousandSep: LPSTR,
90     NegativeOrder: UINT,
91     PositiveOrder: UINT,
92     lpCurrencySymbol: LPSTR,
93 }}
94 pub type LPCURRENCYFMTA = *mut CURRENCYFMTA;
95 STRUCT!{struct CURRENCYFMTW {
96     NumDigits: UINT,
97     LeadingZero: UINT,
98     Grouping: UINT,
99     lpDecimalSep: LPWSTR,
100     lpThousandSep: LPWSTR,
101     NegativeOrder: UINT,
102     PositiveOrder: UINT,
103     lpCurrencySymbol: LPWSTR,
104 }}
105 pub type LPCURRENCYFMTW = *mut CURRENCYFMTW;
106 pub type NLS_FUNCTION = DWORD;
107 STRUCT!{struct NLSVERSIONINFO {
108     dwNLSVersionInfoSize: DWORD,
109     dwNLSVersion: DWORD,
110     dwDefinedVersion: DWORD,
111     dwEffectiveId: DWORD,
112     guidCustomVersion: GUID,
113 }}
114 pub type LPNLSVERSIONINFO = *mut NLSVERSIONINFO;
115 STRUCT!{struct NLSVERSIONINFOEX {
116     dwNLSVersionInfoSize: DWORD,
117     dwNLSVersion: DWORD,
118     dwDefinedVersion: DWORD,
119     dwEffectiveId: DWORD,
120     guidCustomVersion: GUID,
121 }}
122 pub type LPNLSVERSIONINFOEX = *mut NLSVERSIONINFOEX;
123 pub type GEOID = LONG;
124 pub type GEOTYPE = DWORD;
125 pub type GEOCLASS = DWORD;
126 ENUM!{enum NORM_FORM {
127     NormalizationOther = 0,
128     NormalizationC = 0x1,
129     NormalizationD = 0x2,
130     NormalizationKC = 0x5,
131     NormalizationKD = 0x6,
132 }}
133 FN!{stdcall LANGUAGEGROUP_ENUMPROCA(
134     LGRPID,
135     LPSTR,
136     LPSTR,
137     DWORD,
138     LONG_PTR,
139 ) -> BOOL}
140 FN!{stdcall LANGGROUPLOCALE_ENUMPROCA(
141     LGRPID,
142     LCID,
143     LPSTR,
144     LONG_PTR,
145 ) -> BOOL}
146 FN!{stdcall UILANGUAGE_ENUMPROCA(
147     LPSTR,
148     LONG_PTR,
149 ) -> BOOL}
150 FN!{stdcall CODEPAGE_ENUMPROCA(
151     LPSTR,
152 ) -> BOOL}
153 FN!{stdcall DATEFMT_ENUMPROCA(
154     LPSTR,
155 ) -> BOOL}
156 FN!{stdcall DATEFMT_ENUMPROCEXA(
157     LPSTR,
158     CALID,
159 ) -> BOOL}
160 FN!{stdcall TIMEFMT_ENUMPROCA(
161     LPSTR,
162 ) -> BOOL}
163 FN!{stdcall CALINFO_ENUMPROCA(
164     LPSTR,
165 ) -> BOOL}
166 FN!{stdcall CALINFO_ENUMPROCEXA(
167     LPSTR,
168     CALID,
169 ) -> BOOL}
170 FN!{stdcall LOCALE_ENUMPROCA(
171     LPSTR,
172 ) -> BOOL}
173 FN!{stdcall LOCALE_ENUMPROCW(
174     LPWSTR,
175 ) -> BOOL}
176 FN!{stdcall LANGUAGEGROUP_ENUMPROCW(
177     LGRPID,
178     LPWSTR,
179     LPWSTR,
180     DWORD,
181     LONG_PTR,
182 ) -> BOOL}
183 FN!{stdcall LANGGROUPLOCALE_ENUMPROCW(
184     LGRPID,
185     LCID,
186     LPWSTR,
187     LONG_PTR,
188 ) -> BOOL}
189 FN!{stdcall UILANGUAGE_ENUMPROCW(
190     LPWSTR,
191     LONG_PTR,
192 ) -> BOOL}
193 FN!{stdcall CODEPAGE_ENUMPROCW(
194     LPWSTR,
195 ) -> BOOL}
196 FN!{stdcall DATEFMT_ENUMPROCW(
197     LPWSTR,
198 ) -> BOOL}
199 FN!{stdcall DATEFMT_ENUMPROCEXW(
200     LPWSTR,
201     CALID,
202 ) -> BOOL}
203 FN!{stdcall TIMEFMT_ENUMPROCW(
204     LPWSTR,
205 ) -> BOOL}
206 FN!{stdcall CALINFO_ENUMPROCW(
207     LPWSTR,
208 ) -> BOOL}
209 FN!{stdcall CALINFO_ENUMPROCEXW(
210     LPWSTR,
211     CALID,
212 ) -> BOOL}
213 FN!{stdcall GEO_ENUMPROC(
214     GEOID,
215 ) -> BOOL}
216 STRUCT!{struct FILEMUIINFO {
217     dwSize: DWORD,
218     dwVersion: DWORD,
219     dwFileType: DWORD,
220     pChecksum: [BYTE; 16],
221     pServiceChecksum: [BYTE; 16],
222     dwLanguageNameOffset: DWORD,
223     dwTypeIDMainSize: DWORD,
224     dwTypeIDMainOffset: DWORD,
225     dwTypeNameMainOffset: DWORD,
226     dwTypeIDMUISize: DWORD,
227     dwTypeIDMUIOffset: DWORD,
228     dwTypeNameMUIOffset: DWORD,
229     abBuffer: [BYTE; 8],
230 }}
231 pub type PFILEMUIINFO = *mut FILEMUIINFO;
232 FN!{stdcall CALINFO_ENUMPROCEXEX(
233     LPWSTR,
234     CALID,
235     LPWSTR,
236     LPARAM,
237 ) -> BOOL}
238 FN!{stdcall DATEFMT_ENUMPROCEXEX(
239     LPWSTR,
240     CALID,
241     LPARAM,
242 ) -> BOOL}
243 FN!{stdcall TIMEFMT_ENUMPROCEX(
244     LPWSTR,
245     LPARAM,
246 ) -> BOOL}
247 FN!{stdcall LOCALE_ENUMPROCEX(
248     LPWSTR,
249     DWORD,
250     LPARAM,
251 ) -> BOOL}
252 extern "system" {
253     pub fn CompareStringA(
254         Locale: LCID,
255         dwCmpFlags: DWORD,
256         lpString1: PCNZCH,
257         cchCount1: c_int,
258         lpString2: PCNZCH,
259         cchCount2: c_int,
260     ) -> c_int;
261     pub fn CompareStringEx(
262         lpLocaleName: LPCWSTR,
263         dwCmpFlags: DWORD,
264         lpString1: LPCWCH,
265         cchCount1: c_int,
266         lpString2: LPCWCH,
267         cchCount2: c_int,
268         lpVersionInformation: LPNLSVERSIONINFO,
269         lpReserved: LPVOID,
270         lParam: LPARAM,
271     ) -> c_int;
272     pub fn CompareStringW(
273         Locale: LCID,
274         dwCmpFlags: DWORD,
275         lpString1: PCNZWCH,
276         cchCount1: c_int,
277         lpString2: PCNZWCH,
278         cchCount2: c_int,
279     ) -> c_int;
280     pub fn ConvertDefaultLocale(Locale: LCID) -> LCID;
281     pub fn EnumCalendarInfoA(
282         lpCalInfoEnumProc: CALINFO_ENUMPROCA,
283         Locale: LCID,
284         Calendar: CALID,
285         CalType: CALTYPE,
286     ) -> BOOL;
287     pub fn EnumCalendarInfoExA(
288         lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA,
289         Locale: LCID,
290         Calendar: CALID,
291         CalType: CALTYPE,
292     ) -> BOOL;
293     pub fn EnumCalendarInfoExEx(
294         pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX,
295         lpLocaleName: LPCWSTR,
296         Calendar: CALID,
297         lpReserved: LPCWSTR,
298         CalType: CALTYPE,
299         lParam: LPARAM,
300     ) -> BOOL;
301     pub fn EnumCalendarInfoExW(
302         lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW,
303         Locale: LCID,
304         Calendar: CALID,
305         CalType: CALTYPE,
306     ) -> BOOL;
307     pub fn EnumCalendarInfoW(
308         lpCalInfoEnumProc: CALINFO_ENUMPROCW,
309         Locale: LCID,
310         Calendar: CALID,
311         CalType: CALTYPE,
312     ) -> BOOL;
313     pub fn EnumDateFormatsA(
314         lpDateFmtEnumProc: DATEFMT_ENUMPROCA,
315         Locale: LCID,
316         dwFlags: DWORD,
317     ) -> BOOL;
318     pub fn EnumDateFormatsExA(
319         lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA,
320         Locale: LCID,
321         dwFlags: DWORD,
322     ) -> BOOL;
323     pub fn EnumDateFormatsExEx(
324         lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX,
325         lpLocaleName: LPCWSTR,
326         dwFlags: DWORD,
327         lParam: LPARAM,
328     ) -> BOOL;
329     pub fn EnumDateFormatsExW(
330         lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW,
331         Locale: LCID,
332         dwFlags: DWORD,
333     ) -> BOOL;
334     pub fn EnumDateFormatsW(
335         lpDateFmtEnumProc: DATEFMT_ENUMPROCW,
336         Locale: LCID,
337         dwFlags: DWORD,
338     ) -> BOOL;
339     pub fn EnumLanguageGroupLocalesA(
340         lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA,
341         LanguageGroup: LGRPID,
342         dwFlags: DWORD,
343         lParam: LONG_PTR,
344     ) -> BOOL;
345     pub fn EnumLanguageGroupLocalesW(
346         lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW,
347         LanguageGroup: LGRPID,
348         dwFlags: DWORD,
349         lParam: LONG_PTR,
350     ) -> BOOL;
351     pub fn EnumSystemCodePagesA(
352         lpCodePageEnumProc: CODEPAGE_ENUMPROCA,
353         dwFlags: DWORD,
354     ) -> BOOL;
355     pub fn EnumSystemCodePagesW(
356         lpCodePageEnumProc: CODEPAGE_ENUMPROCW,
357         dwFlags: DWORD,
358     ) -> BOOL;
359     pub fn EnumSystemGeoID(
360         GeoClass: GEOCLASS,
361         ParentGeoId: GEOID,
362         lpGeoEnumProc: GEO_ENUMPROC,
363     ) -> BOOL;
364     pub fn EnumSystemLanguageGroupsA(
365         lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA,
366         dwFlags: DWORD,
367         lParam: LONG_PTR,
368     ) -> BOOL;
369     pub fn EnumSystemLanguageGroupsW(
370         lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW,
371         dwFlags: DWORD,
372         lParam: LONG_PTR,
373     ) -> BOOL;
374     pub fn EnumSystemLocalesA(
375         lpLocaleEnumProc: LOCALE_ENUMPROCA,
376         dwFlags: DWORD,
377     ) -> BOOL;
378     pub fn EnumSystemLocalesEx(
379         lpLocaleEnumProcEx: LOCALE_ENUMPROCEX,
380         dwFlags: DWORD,
381         lParam: LPARAM,
382         lpReserved: LPVOID,
383     ) -> BOOL;
384     pub fn EnumSystemLocalesW(
385         lpLocaleEnumProc: LOCALE_ENUMPROCW,
386         dwFlags: DWORD,
387     ) -> BOOL;
388     pub fn EnumTimeFormatsA(
389         lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA,
390         Locale: LCID,
391         dwFlags: DWORD,
392     ) -> BOOL;
393     pub fn EnumTimeFormatsEx(
394         lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX,
395         lpLocaleName: LPCWSTR,
396         dwFlags: DWORD,
397         lParam: LPARAM,
398     ) -> BOOL;
399     pub fn EnumTimeFormatsW(
400         lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW,
401         Locale: LCID,
402         dwFlags: DWORD,
403     ) -> BOOL;
404     pub fn EnumUILanguagesA(
405         lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA,
406         dwFlags: DWORD,
407         lParam: LONG_PTR,
408     ) -> BOOL;
409     pub fn EnumUILanguagesW(
410         lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW,
411         dwFlags: DWORD,
412         lParam: LONG_PTR,
413     ) -> BOOL;
414     pub fn FindNLSString(
415         Locale: LCID,
416         dwFindNLSStringFlags: DWORD,
417         lpStringSource: LPCWSTR,
418         cchSource: c_int,
419         lpStringValue: LPCWSTR,
420         cchValue: c_int,
421         pcchFound: LPINT,
422     ) -> c_int;
423     pub fn FindNLSStringEx(
424         lpLocaleName: LPCWSTR,
425         dwFindNLSStringFlags: DWORD,
426         lpStringSource: LPCWSTR,
427         cchSource: c_int,
428         lpStringValue: LPCWSTR,
429         cchValue: c_int,
430         pcchFound: LPINT,
431         lpVersionInformation: LPNLSVERSIONINFO,
432         lpReserved: LPVOID,
433         sortHandle: LPARAM,
434     ) -> c_int;
435     pub fn FoldStringA(
436         dwMapFlags: DWORD,
437         lpSrcStr: LPCSTR,
438         cchSrc: c_int,
439         lpDestStr: LPSTR,
440         cchDest: c_int,
441     ) -> c_int;
442     pub fn GetACP() -> UINT;
443     pub fn GetCPInfo(
444         CodePage: UINT,
445         lpCPInfo: LPCPINFO,
446     ) -> BOOL;
447     pub fn GetCPInfoExA(
448         CodePage: UINT,
449         dwFlags: DWORD,
450         lpCPInfoEx: LPCPINFOEXA,
451     ) -> BOOL;
452     pub fn GetCPInfoExW(
453         CodePage: UINT,
454         dwFlags: DWORD,
455         lpCPInfoEx: LPCPINFOEXW,
456     ) -> BOOL;
457     pub fn GetCalendarInfoA(
458         Locale: LCID,
459         Calendar: CALID,
460         CalType: CALTYPE,
461         lpCalData: LPSTR,
462         cchData: c_int,
463         lpValue: LPDWORD,
464     ) -> c_int;
465     pub fn GetCalendarInfoEx(
466         lpLocaleName: LPCWSTR,
467         Calendar: CALID,
468         lpReserved: LPCWSTR,
469         CalType: CALTYPE,
470         lpCalData: LPWSTR,
471         cchData: c_int,
472         lpValue: LPDWORD,
473     ) -> c_int;
474     pub fn GetCalendarInfoW(
475         Locale: LCID,
476         Calendar: CALID,
477         CalType: CALTYPE,
478         lpCalData: LPWSTR,
479         cchData: c_int,
480         lpValue: LPDWORD,
481     ) -> c_int;
482     pub fn GetCurrencyFormatA(
483         Locale: LCID,
484         dwFlags: DWORD,
485         lpValue: LPCSTR,
486         lpFormat: *const CURRENCYFMTA,
487         lpCurrencyStr: LPSTR,
488         cchCurrency: c_int,
489     ) -> c_int;
490     pub fn GetCurrencyFormatEx(
491         lpLocaleName: LPCWSTR,
492         dwFlags: DWORD,
493         lpValue: LPCWSTR,
494         lpFormat: *const CURRENCYFMTW,
495         lpCurrencyStr: LPWSTR,
496         cchCurrency: c_int,
497     ) -> c_int;
498     pub fn GetCurrencyFormatW(
499         Locale: LCID,
500         dwFlags: DWORD,
501         lpValue: LPCWSTR,
502         lpFormat: *const CURRENCYFMTW,
503         lpCurrencyStr: LPWSTR,
504         cchCurrency: c_int,
505     ) -> c_int;
506     pub fn GetDurationFormat(
507         Locale: LCID,
508         dwFlags: DWORD,
509         lpDuration: *const SYSTEMTIME,
510         ullDuration: ULONGLONG,
511         lpFormat: LPCWSTR,
512         lpDurationStr: LPWSTR,
513         cchDuration: c_int,
514     ) -> c_int;
515     pub fn GetDurationFormatEx(
516         lpLocaleName: LPCWSTR,
517         dwFlags: DWORD,
518         lpDuration: *const SYSTEMTIME,
519         ullDuration: ULONGLONG,
520         lpFormat: LPCWSTR,
521         lpDurationStr: LPWSTR,
522         cchDuration: c_int,
523     ) -> c_int;
524     pub fn GetFileMUIInfo(
525         dwFlags: DWORD,
526         pcwszFilePath: PCWSTR,
527         pFileMUIInfo: PFILEMUIINFO,
528         pcbFileMUIInfo: *mut DWORD,
529     ) -> BOOL;
530     pub fn GetFileMUIPath(
531         dwFlags: DWORD,
532         pcwszFilePath: PCWSTR,
533         pwszLanguage: PWSTR,
534         pcchLanguage: PULONG,
535         pwszFileMUIPath: PWSTR,
536         pcchFileMUIPath: PULONG,
537         pululEnumerator: PULONGLONG,
538     ) -> BOOL;
539     pub fn GetGeoInfoA(
540         Location: GEOID,
541         GeoType: GEOTYPE,
542         lpGeoData: LPSTR,
543         cchData: c_int,
544         LangId: LANGID,
545     ) -> c_int;
546     pub fn GetGeoInfoW(
547         Location: GEOID,
548         GeoType: GEOTYPE,
549         lpGeoData: LPWSTR,
550         cchData: c_int,
551         LangId: LANGID,
552     ) -> c_int;
553     pub fn GetLocaleInfoA(
554         Locale: LCID,
555         LCType: LCTYPE,
556         lpLCData: LPSTR,
557         cchData: c_int,
558     ) -> c_int;
559     pub fn GetLocaleInfoEx(
560         lpLocaleName: LPCWSTR,
561         LCType: LCTYPE,
562         lpLCData: LPWSTR,
563         cchData: c_int,
564     ) -> c_int;
565     pub fn GetLocaleInfoW(
566         Locale: LCID,
567         LCType: LCTYPE,
568         lpLCData: LPWSTR,
569         cchData: c_int,
570     ) -> c_int;
571     pub fn GetNLSVersion(
572         Function: NLS_FUNCTION,
573         Locale: LCID,
574         lpVersionInformation: LPNLSVERSIONINFO,
575     ) -> BOOL;
576     pub fn GetNLSVersionEx(
577         function: NLS_FUNCTION,
578         lpLocaleName: LPCWSTR,
579         lpVersionInformation: LPNLSVERSIONINFOEX,
580     ) -> BOOL;
581     pub fn GetNumberFormatA(
582         Locale: LCID,
583         dwFlags: DWORD,
584         lpValue: LPCSTR,
585         lpFormat: *const NUMBERFMTA,
586         lpNumberStr: LPSTR,
587         cchNumber: c_int,
588     ) -> c_int;
589     pub fn GetNumberFormatEx(
590         lpLocaleName: LPCWSTR,
591         dwFlags: DWORD,
592         lpValue: LPCWSTR,
593         lpFormat: *const NUMBERFMTW,
594         lpNumberStr: LPWSTR,
595         cchNumber: c_int,
596     ) -> c_int;
597     pub fn GetNumberFormatW(
598         Locale: LCID,
599         dwFlags: DWORD,
600         lpValue: LPCWSTR,
601         lpFormat: *const NUMBERFMTW,
602         lpNumberStr: LPWSTR,
603         cchNumber: c_int,
604     ) -> c_int;
605     pub fn GetOEMCP() -> UINT;
606     pub fn GetProcessPreferredUILanguages(
607         dwFlags: DWORD,
608         pulNumLanguages: PULONG,
609         pwszLanguagesBuffer: PZZWSTR,
610         pcchLanguagesBuffer: PULONG,
611     ) -> BOOL;
612     pub fn GetStringScripts(
613         dwFlags: DWORD,
614         lpString: LPCWSTR,
615         cchString: c_int,
616         lpScripts: LPWSTR,
617         cchScripts: c_int,
618     ) -> c_int;
619     pub fn GetStringTypeA(
620         Locale: LCID,
621         dwInfoType: DWORD,
622         lpSrcStr: LPCSTR,
623         cchSrc: c_int,
624         lpCharType: LPWORD,
625     ) -> BOOL;
626     pub fn GetStringTypeExA(
627         Locale: LCID,
628         dwInfoType: DWORD,
629         lpSrcStr: LPCSTR,
630         cchSrc: c_int,
631         lpCharType: LPWORD,
632     ) -> BOOL;
633     pub fn GetStringTypeW(
634         dwInfoType: DWORD,
635         lpSrcStr: LPCWCH,
636         cchSrc: c_int,
637         lpCharType: LPWORD,
638     ) -> BOOL;
639     pub fn GetSystemDefaultLCID() -> LCID;
640     pub fn GetSystemDefaultLangID() -> LANGID;
641     pub fn GetSystemDefaultLocaleName(
642         lpLocaleName: LPWSTR,
643         cchLocaleName: c_int,
644     ) -> c_int;
645     pub fn GetSystemDefaultUILanguage() -> LANGID;
646     pub fn GetSystemPreferredUILanguages(
647         dwFlags: DWORD,
648         pulNumLanguages: PULONG,
649         pwszLanguagesBuffer: PZZWSTR,
650         pcchLanguagesBuffer: PULONG,
651     ) -> BOOL;
652     pub fn GetThreadLocale() -> LCID;
653     pub fn GetThreadPreferredUILanguages(
654         dwFlags: DWORD,
655         pulNumLanguages: PULONG,
656         pwszLanguagesBuffer: PZZWSTR,
657         pcchLanguagesBuffer: PULONG,
658     ) -> BOOL;
659     pub fn GetThreadUILanguage() -> LANGID;
660     pub fn GetUILanguageInfo(
661         dwFlags: DWORD,
662         pwmszLanguage: PCZZWSTR,
663         pwszFallbackLanguages: PZZWSTR,
664         pcchFallbackLanguages: PDWORD,
665         pAttributes: PDWORD,
666     ) -> BOOL;
667     pub fn GetUserDefaultLCID() -> LCID;
668     pub fn GetUserDefaultLangID() -> LANGID;
669     pub fn GetUserDefaultLocaleName(
670         lpLocaleName: LPWSTR,
671         cchLocaleName: c_int,
672     ) -> c_int;
673     pub fn GetUserDefaultUILanguage() -> LANGID;
674     pub fn GetUserGeoID(GeoClass: GEOCLASS) -> GEOID;
675     pub fn GetUserPreferredUILanguages(
676         dwFlags: DWORD,
677         pulNumLanguages: PULONG,
678         pwszLanguagesBuffer: PZZWSTR,
679         pcchLanguagesBuffer: PULONG,
680     ) -> BOOL;
681     pub fn IsDBCSLeadByte(
682         TestChar: BYTE,
683     ) -> BOOL;
684     pub fn IsDBCSLeadByteEx(
685         CodePage: UINT,
686         TestChar: BYTE,
687     ) -> BOOL;
688     pub fn IsNLSDefinedString(
689         Function: NLS_FUNCTION,
690         dwFlags: DWORD,
691         lpVersionInformation: LPNLSVERSIONINFO,
692         lpString: LPCWSTR,
693         cchStr: INT,
694     ) -> BOOL;
695     pub fn IsNormalizedString(
696         NormForm: NORM_FORM,
697         lpString: LPCWSTR,
698         cwLength: c_int,
699     ) -> BOOL;
700     pub fn IsValidCodePage(
701         CodePage: UINT,
702     ) -> BOOL;
703     pub fn IsValidLanguageGroup(
704         LanguageGroup: LGRPID,
705         dwFlags: DWORD,
706     ) -> BOOL;
707     pub fn IsValidLocale(
708         Locale: LCID,
709         dwFlags: DWORD,
710     ) -> BOOL;
711     pub fn IsValidLocaleName(
712         lpLocaleName: LPCWSTR,
713     ) -> BOOL;
714     pub fn IsValidNLSVersion(
715         function: NLS_FUNCTION,
716         lpLocaleName: LPCWSTR,
717         lpVersionInformation: LPNLSVERSIONINFOEX,
718     ) -> BOOL;
719     pub fn LCIDToLocaleName(
720         Locale: LCID,
721         lpName: LPWSTR,
722         cchName: c_int,
723         dwFlags: DWORD,
724     ) -> c_int;
725     pub fn LCMapStringA(
726         Locale: LCID,
727         dwMapFlags: DWORD,
728         lpSrcStr: LPCSTR,
729         cchSrc: c_int,
730         lpDestStr: LPSTR,
731         cchDest: c_int,
732     ) -> c_int;
733     pub fn LCMapStringEx(
734         lpLocaleName: LPCWSTR,
735         dwMapFlags: DWORD,
736         lpSrcStr: LPCWSTR,
737         cchSrc: c_int,
738         lpDestStr: LPWSTR,
739         cchDest: c_int,
740         lpVersionInformation: LPNLSVERSIONINFO,
741         lpReserved: LPVOID,
742         sortHandle: LPARAM,
743     ) -> c_int;
744     pub fn LCMapStringW(
745         Locale: LCID,
746         dwMapFlags: DWORD,
747         lpSrcStr: LPCWSTR,
748         cchSrc: c_int,
749         lpDestStr: LPWSTR,
750         cchDest: c_int,
751     ) -> c_int;
752     pub fn LocaleNameToLCID(
753         lpName: LPCWSTR,
754         dwFlags: DWORD,
755     ) -> LCID;
756     pub fn NormalizeString(
757         NormForm: NORM_FORM,
758         lpSrcString: LPCWSTR,
759         cwSrcLength: c_int,
760         lpDstString: LPWSTR,
761         cwDstLength: c_int,
762     ) -> c_int;
763     pub fn NotifyUILanguageChange(
764         dwFlags: DWORD,
765         pcwstrNewLanguage: PCWSTR,
766         pcwstrPreviousLanguage: PCWSTR,
767         dwReserved: DWORD,
768         pdwStatusRtrn: PDWORD,
769     ) -> BOOL;
770     pub fn ResolveLocaleName(
771         lpNameToResolve: LPCWSTR,
772         lpLocaleName: LPWSTR,
773         cchLocaleName: c_int,
774     ) -> c_int;
775     pub fn SetCalendarInfoA(
776         Locale: LCID,
777         Calendar: CALID,
778         CalType: CALTYPE,
779         lpCalData: LPCSTR,
780     ) -> BOOL;
781     pub fn SetCalendarInfoW(
782         Locale: LCID,
783         Calendar: CALID,
784         CalType: CALTYPE,
785         lpCalData: LPCWSTR,
786     ) -> BOOL;
787     pub fn SetLocaleInfoA(
788         Locale: LCID,
789         LCType: LCTYPE,
790         lpLCData: LPCSTR,
791     ) -> BOOL;
792     pub fn SetLocaleInfoW(
793         Locale: LCID,
794         LCType: LCTYPE,
795         lpLCData: LPCWSTR,
796     ) -> BOOL;
797     pub fn SetProcessPreferredUILanguages(
798         dwFlags: DWORD,
799         pwszLanguagesBuffer: PCZZWSTR,
800         pulNumLanguages: PULONG,
801     ) -> BOOL;
802     pub fn SetThreadLocale(Locale: LCID) -> BOOL;
803     pub fn SetThreadPreferredUILanguages(
804         dwFlags: DWORD,
805         pwszLanguagesBuffer: PCZZWSTR,
806         pulNumLanguages: PULONG,
807     ) -> BOOL;
808     pub fn SetThreadUILanguage(LangId: LANGID) -> LANGID;
809     pub fn SetUserGeoID(GeoId: GEOID) -> BOOL;
810     pub fn VerifyScripts(
811         dwFlags: DWORD,
812         lpLocaleScripts: LPCWSTR,
813         cchLocaleScripts: c_int,
814         lpTestScripts: LPCWSTR,
815         cchTestScripts: c_int,
816     ) -> BOOL;
817 }
818