winapi_ui_automation/um/
winnls.rs

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.
7use ctypes::c_int;
8use shared::basetsd::LONG_PTR;
9use shared::guiddef::GUID;
10use shared::minwindef::{
11    BOOL, BYTE, DWORD, INT, LPARAM, LPDWORD, LPINT, LPVOID, LPWORD, MAX_PATH, PDWORD, PULONG,
12    UINT,
13};
14use um::minwinbase::SYSTEMTIME;
15use um::winnt::{
16    CHAR, LANGID, LCID, LONG, LPCSTR, LPCWCH, LPCWSTR, LPSTR, LPWSTR, PCNZCH, PCNZWCH, PCWSTR,
17    PCZZWSTR, PULONGLONG, PWSTR, PZZWSTR, ULONGLONG, WCHAR,
18};
19pub const MAX_LEADBYTES: usize = 12;
20pub const MAX_DEFAULTCHAR: usize = 2;
21pub const MB_PRECOMPOSED: DWORD = 0x00000001;
22pub const MB_COMPOSITE: DWORD = 0x00000002;
23pub const MB_USEGLYPHCHARS: DWORD = 0x00000004;
24pub const MB_ERR_INVALID_CHARS: DWORD = 0x00000008;
25pub const WC_COMPOSITECHECK: DWORD = 0x00000200;
26pub const WC_DISCARDNS: DWORD = 0x00000010;
27pub const WC_SEPCHARS: DWORD = 0x00000020;
28pub const WC_DEFAULTCHAR: DWORD = 0x00000040;
29pub const WC_ERR_INVALID_CHARS: DWORD = 0x00000080;
30pub const WC_NO_BEST_FIT_CHARS: DWORD = 0x00000400;
31pub const CP_ACP: DWORD = 0;
32pub const CP_OEMCP: DWORD = 1;
33pub const CP_MACCP: DWORD = 2;
34pub const CP_THREAD_ACP: DWORD = 3;
35pub const CP_SYMBOL: DWORD = 42;
36pub const CP_UTF7: DWORD = 65000;
37pub const CP_UTF8: DWORD = 65001;
38pub type LGRPID = DWORD;
39pub type LCTYPE = DWORD;
40pub type CALTYPE = DWORD;
41pub type CALID = DWORD;
42STRUCT!{struct CPINFO {
43    MaxCharSize: UINT,
44    DefaultChar: [BYTE; MAX_DEFAULTCHAR],
45    LeadByte: [BYTE; MAX_LEADBYTES],
46}}
47pub type LPCPINFO = *mut CPINFO;
48STRUCT!{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}}
56pub type LPCPINFOEXA = *mut CPINFOEXA;
57STRUCT!{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}}
65pub type LPCPINFOEXW = *mut CPINFOEXW;
66STRUCT!{struct NUMBERFMTA {
67    NumDigits: UINT,
68    LeadingZero: UINT,
69    Grouping: UINT,
70    lpDecimalSep: LPSTR,
71    lpThousandSep: LPSTR,
72    NegativeOrder: UINT,
73}}
74pub type LPNUMBERFMTA = *mut NUMBERFMTA;
75STRUCT!{struct NUMBERFMTW {
76    NumDigits: UINT,
77    LeadingZero: UINT,
78    Grouping: UINT,
79    lpDecimalSep: LPWSTR,
80    lpThousandSep: LPWSTR,
81    NegativeOrder: UINT,
82}}
83pub type LPNUMBERFMTW = *mut NUMBERFMTW;
84STRUCT!{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}}
94pub type LPCURRENCYFMTA = *mut CURRENCYFMTA;
95STRUCT!{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}}
105pub type LPCURRENCYFMTW = *mut CURRENCYFMTW;
106pub type NLS_FUNCTION = DWORD;
107STRUCT!{struct NLSVERSIONINFO {
108    dwNLSVersionInfoSize: DWORD,
109    dwNLSVersion: DWORD,
110    dwDefinedVersion: DWORD,
111    dwEffectiveId: DWORD,
112    guidCustomVersion: GUID,
113}}
114pub type LPNLSVERSIONINFO = *mut NLSVERSIONINFO;
115STRUCT!{struct NLSVERSIONINFOEX {
116    dwNLSVersionInfoSize: DWORD,
117    dwNLSVersion: DWORD,
118    dwDefinedVersion: DWORD,
119    dwEffectiveId: DWORD,
120    guidCustomVersion: GUID,
121}}
122pub type LPNLSVERSIONINFOEX = *mut NLSVERSIONINFOEX;
123pub type GEOID = LONG;
124pub type GEOTYPE = DWORD;
125pub type GEOCLASS = DWORD;
126ENUM!{enum NORM_FORM {
127    NormalizationOther = 0,
128    NormalizationC = 0x1,
129    NormalizationD = 0x2,
130    NormalizationKC = 0x5,
131    NormalizationKD = 0x6,
132}}
133FN!{stdcall LANGUAGEGROUP_ENUMPROCA(
134    LGRPID,
135    LPSTR,
136    LPSTR,
137    DWORD,
138    LONG_PTR,
139) -> BOOL}
140FN!{stdcall LANGGROUPLOCALE_ENUMPROCA(
141    LGRPID,
142    LCID,
143    LPSTR,
144    LONG_PTR,
145) -> BOOL}
146FN!{stdcall UILANGUAGE_ENUMPROCA(
147    LPSTR,
148    LONG_PTR,
149) -> BOOL}
150FN!{stdcall CODEPAGE_ENUMPROCA(
151    LPSTR,
152) -> BOOL}
153FN!{stdcall DATEFMT_ENUMPROCA(
154    LPSTR,
155) -> BOOL}
156FN!{stdcall DATEFMT_ENUMPROCEXA(
157    LPSTR,
158    CALID,
159) -> BOOL}
160FN!{stdcall TIMEFMT_ENUMPROCA(
161    LPSTR,
162) -> BOOL}
163FN!{stdcall CALINFO_ENUMPROCA(
164    LPSTR,
165) -> BOOL}
166FN!{stdcall CALINFO_ENUMPROCEXA(
167    LPSTR,
168    CALID,
169) -> BOOL}
170FN!{stdcall LOCALE_ENUMPROCA(
171    LPSTR,
172) -> BOOL}
173FN!{stdcall LOCALE_ENUMPROCW(
174    LPWSTR,
175) -> BOOL}
176FN!{stdcall LANGUAGEGROUP_ENUMPROCW(
177    LGRPID,
178    LPWSTR,
179    LPWSTR,
180    DWORD,
181    LONG_PTR,
182) -> BOOL}
183FN!{stdcall LANGGROUPLOCALE_ENUMPROCW(
184    LGRPID,
185    LCID,
186    LPWSTR,
187    LONG_PTR,
188) -> BOOL}
189FN!{stdcall UILANGUAGE_ENUMPROCW(
190    LPWSTR,
191    LONG_PTR,
192) -> BOOL}
193FN!{stdcall CODEPAGE_ENUMPROCW(
194    LPWSTR,
195) -> BOOL}
196FN!{stdcall DATEFMT_ENUMPROCW(
197    LPWSTR,
198) -> BOOL}
199FN!{stdcall DATEFMT_ENUMPROCEXW(
200    LPWSTR,
201    CALID,
202) -> BOOL}
203FN!{stdcall TIMEFMT_ENUMPROCW(
204    LPWSTR,
205) -> BOOL}
206FN!{stdcall CALINFO_ENUMPROCW(
207    LPWSTR,
208) -> BOOL}
209FN!{stdcall CALINFO_ENUMPROCEXW(
210    LPWSTR,
211    CALID,
212) -> BOOL}
213FN!{stdcall GEO_ENUMPROC(
214    GEOID,
215) -> BOOL}
216STRUCT!{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}}
231pub type PFILEMUIINFO = *mut FILEMUIINFO;
232FN!{stdcall CALINFO_ENUMPROCEXEX(
233    LPWSTR,
234    CALID,
235    LPWSTR,
236    LPARAM,
237) -> BOOL}
238FN!{stdcall DATEFMT_ENUMPROCEXEX(
239    LPWSTR,
240    CALID,
241    LPARAM,
242) -> BOOL}
243FN!{stdcall TIMEFMT_ENUMPROCEX(
244    LPWSTR,
245    LPARAM,
246) -> BOOL}
247FN!{stdcall LOCALE_ENUMPROCEX(
248    LPWSTR,
249    DWORD,
250    LPARAM,
251) -> BOOL}
252extern "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}