/*++ Copyright (c) Microsoft Corporation. All rights reserved. Module Name: winnls.h Abstract: Procedure declarations, constant definitions, and macros for the NLS component. --*/ #ifndef _WINNLS_ #define _WINNLS_ #ifdef __cplusplus extern "C" { #endif #ifndef NONLS #ifdef _MAC #include #endif //////////////////////////////////////////////////////////////////////////// // // Constants // // Define all constants for the NLS component here. // //////////////////////////////////////////////////////////////////////////// // // String Length Maximums. // #define MAX_LEADBYTES 12 // 5 ranges, 2 bytes ea., 0 term. #define MAX_DEFAULTCHAR 2 // single or double byte // // MBCS and Unicode Translation Flags. // #define MB_PRECOMPOSED 0x00000001 // use precomposed chars #define MB_COMPOSITE 0x00000002 // use composite chars #define MB_USEGLYPHCHARS 0x00000004 // use glyph chars, not ctrl chars #define MB_ERR_INVALID_CHARS 0x00000008 // error for invalid chars #define WC_COMPOSITECHECK 0x00000200 // convert composite to precomposed #define WC_DISCARDNS 0x00000010 // discard non-spacing chars #define WC_SEPCHARS 0x00000020 // generate separate chars #define WC_DEFAULTCHAR 0x00000040 // replace w/ default char #if(WINVER >= 0x0500) #define WC_NO_BEST_FIT_CHARS 0x00000400 // do not use best fit chars #endif /* WINVER >= 0x0500 */ // // Character Type Flags. // #define CT_CTYPE1 0x00000001 // ctype 1 information #define CT_CTYPE2 0x00000002 // ctype 2 information #define CT_CTYPE3 0x00000004 // ctype 3 information // // CType 1 Flag Bits. // #define C1_UPPER 0x0001 // upper case #define C1_LOWER 0x0002 // lower case #define C1_DIGIT 0x0004 // decimal digits #define C1_SPACE 0x0008 // spacing characters #define C1_PUNCT 0x0010 // punctuation characters #define C1_CNTRL 0x0020 // control characters #define C1_BLANK 0x0040 // blank characters #define C1_XDIGIT 0x0080 // other digits #define C1_ALPHA 0x0100 // any linguistic character #define C1_DEFINED 0x0200 // defined character // // CType 2 Flag Bits. // #define C2_LEFTTORIGHT 0x0001 // left to right #define C2_RIGHTTOLEFT 0x0002 // right to left #define C2_EUROPENUMBER 0x0003 // European number, digit #define C2_EUROPESEPARATOR 0x0004 // European numeric separator #define C2_EUROPETERMINATOR 0x0005 // European numeric terminator #define C2_ARABICNUMBER 0x0006 // Arabic number #define C2_COMMONSEPARATOR 0x0007 // common numeric separator #define C2_BLOCKSEPARATOR 0x0008 // block separator #define C2_SEGMENTSEPARATOR 0x0009 // segment separator #define C2_WHITESPACE 0x000A // white space #define C2_OTHERNEUTRAL 0x000B // other neutrals #define C2_NOTAPPLICABLE 0x0000 // no implicit directionality // // CType 3 Flag Bits. // #define C3_NONSPACING 0x0001 // nonspacing character #define C3_DIACRITIC 0x0002 // diacritic mark #define C3_VOWELMARK 0x0004 // vowel mark #define C3_SYMBOL 0x0008 // symbols #define C3_KATAKANA 0x0010 // katakana character #define C3_HIRAGANA 0x0020 // hiragana character #define C3_HALFWIDTH 0x0040 // half width character #define C3_FULLWIDTH 0x0080 // full width character #define C3_IDEOGRAPH 0x0100 // ideographic character #define C3_KASHIDA 0x0200 // Arabic kashida character #define C3_LEXICAL 0x0400 // lexical character #define C3_ALPHA 0x8000 // any linguistic char (C1_ALPHA) #define C3_NOTAPPLICABLE 0x0000 // ctype 3 is not applicable // // String Flags. // #define NORM_IGNORECASE 0x00000001 // ignore case #define NORM_IGNORENONSPACE 0x00000002 // ignore nonspacing chars #define NORM_IGNORESYMBOLS 0x00000004 // ignore symbols #define NORM_IGNOREKANATYPE 0x00010000 // ignore kanatype #define NORM_IGNOREWIDTH 0x00020000 // ignore width // // Locale Independent Mapping Flags. // #define MAP_FOLDCZONE 0x00000010 // fold compatibility zone chars #define MAP_PRECOMPOSED 0x00000020 // convert to precomposed chars #define MAP_COMPOSITE 0x00000040 // convert to composite chars #define MAP_FOLDDIGITS 0x00000080 // all digits to ASCII 0-9 #if(WINVER >= 0x0500) #define MAP_EXPAND_LIGATURES 0x00002000 // expand all ligatures #endif /* WINVER >= 0x0500 */ // // Locale Dependent Mapping Flags. // #define LCMAP_LOWERCASE 0x00000100 // lower case letters #define LCMAP_UPPERCASE 0x00000200 // upper case letters #define LCMAP_SORTKEY 0x00000400 // WC sort key (normalize) #define LCMAP_BYTEREV 0x00000800 // byte reversal #define LCMAP_HIRAGANA 0x00100000 // map katakana to hiragana #define LCMAP_KATAKANA 0x00200000 // map hiragana to katakana #define LCMAP_HALFWIDTH 0x00400000 // map double byte to single byte #define LCMAP_FULLWIDTH 0x00800000 // map single byte to double byte #define LCMAP_LINGUISTIC_CASING 0x01000000 // use linguistic rules for casing #define LCMAP_SIMPLIFIED_CHINESE 0x02000000 // map traditional chinese to simplified chinese #define LCMAP_TRADITIONAL_CHINESE 0x04000000 // map simplified chinese to traditional chinese // // Language Group Enumeration Flags. // #define LGRPID_INSTALLED 0x00000001 // installed language group ids #define LGRPID_SUPPORTED 0x00000002 // supported language group ids // // Locale Enumeration Flags. // #define LCID_INSTALLED 0x00000001 // installed locale ids #define LCID_SUPPORTED 0x00000002 // supported locale ids #define LCID_ALTERNATE_SORTS 0x00000004 // alternate sort locale ids // // Code Page Enumeration Flags. // #define CP_INSTALLED 0x00000001 // installed code page ids #define CP_SUPPORTED 0x00000002 // supported code page ids // // Sorting Flags. // // WORD Sort: culturally correct sort // hyphen and apostrophe are special cased // example: "coop" and "co-op" will sort together in a list // // co_op <------- underscore (symbol) // coat // comb // coop // co-op <------- hyphen (punctuation) // cork // went // were // we're <------- apostrophe (punctuation) // // // STRING Sort: hyphen and apostrophe will sort with all other symbols // // co-op <------- hyphen (punctuation) // co_op <------- underscore (symbol) // coat // comb // coop // cork // we're <------- apostrophe (punctuation) // went // were // #define SORT_STRINGSORT 0x00001000 // use string sort method // // Compare String Return Values. // #define CSTR_LESS_THAN 1 // string 1 less than string 2 #define CSTR_EQUAL 2 // string 1 equal to string 2 #define CSTR_GREATER_THAN 3 // string 1 greater than string 2 // // Code Page Default Values. // #define CP_ACP 0 // default to ANSI code page #define CP_OEMCP 1 // default to OEM code page #define CP_MACCP 2 // default to MAC code page #define CP_THREAD_ACP 3 // current thread's ANSI code page #define CP_SYMBOL 42 // SYMBOL translations #define CP_UTF7 65000 // UTF-7 translation #define CP_UTF8 65001 // UTF-8 translation // // Country/Region Codes. // #define CTRY_DEFAULT 0 #define CTRY_ALBANIA 355 // Albania #define CTRY_ALGERIA 213 // Algeria #define CTRY_ARGENTINA 54 // Argentina #define CTRY_ARMENIA 374 // Armenia #define CTRY_AUSTRALIA 61 // Australia #define CTRY_AUSTRIA 43 // Austria #define CTRY_AZERBAIJAN 994 // Azerbaijan #define CTRY_BAHRAIN 973 // Bahrain #define CTRY_BELARUS 375 // Belarus #define CTRY_BELGIUM 32 // Belgium #define CTRY_BELIZE 501 // Belize #define CTRY_BOLIVIA 591 // Bolivia #define CTRY_BRAZIL 55 // Brazil #define CTRY_BRUNEI_DARUSSALAM 673 // Brunei Darussalam #define CTRY_BULGARIA 359 // Bulgaria #define CTRY_CANADA 2 // Canada #define CTRY_CARIBBEAN 1 // Caribbean #define CTRY_CHILE 56 // Chile #define CTRY_COLOMBIA 57 // Colombia #define CTRY_COSTA_RICA 506 // Costa Rica #define CTRY_CROATIA 385 // Croatia #define CTRY_CZECH 420 // Czech Republic #define CTRY_DENMARK 45 // Denmark #define CTRY_DOMINICAN_REPUBLIC 1 // Dominican Republic #define CTRY_ECUADOR 593 // Ecuador #define CTRY_EGYPT 20 // Egypt #define CTRY_EL_SALVADOR 503 // El Salvador #define CTRY_ESTONIA 372 // Estonia #define CTRY_FAEROE_ISLANDS 298 // Faeroe Islands #define CTRY_FINLAND 358 // Finland #define CTRY_FRANCE 33 // France #define CTRY_GEORGIA 995 // Georgia #define CTRY_GERMANY 49 // Germany #define CTRY_GREECE 30 // Greece #define CTRY_GUATEMALA 502 // Guatemala #define CTRY_HONDURAS 504 // Honduras #define CTRY_HONG_KONG 852 // Hong Kong S.A.R., P.R.C. #define CTRY_HUNGARY 36 // Hungary #define CTRY_ICELAND 354 // Iceland #define CTRY_INDIA 91 // India #define CTRY_INDONESIA 62 // Indonesia #define CTRY_IRAN 981 // Iran #define CTRY_IRAQ 964 // Iraq #define CTRY_IRELAND 353 // Ireland #define CTRY_ISRAEL 972 // Israel #define CTRY_ITALY 39 // Italy #define CTRY_JAMAICA 1 // Jamaica #define CTRY_JAPAN 81 // Japan #define CTRY_JORDAN 962 // Jordan #define CTRY_KAZAKSTAN 7 // Kazakstan #define CTRY_KENYA 254 // Kenya #define CTRY_KUWAIT 965 // Kuwait #define CTRY_KYRGYZSTAN 996 // Kyrgyzstan #define CTRY_LATVIA 371 // Latvia #define CTRY_LEBANON 961 // Lebanon #define CTRY_LIBYA 218 // Libya #define CTRY_LIECHTENSTEIN 41 // Liechtenstein #define CTRY_LITHUANIA 370 // Lithuania #define CTRY_LUXEMBOURG 352 // Luxembourg #define CTRY_MACAU 853 // Macau S.A.R., PRC #define CTRY_MACEDONIA 389 // Former Yugoslav Republic of Macedonia #define CTRY_MALAYSIA 60 // Malaysia #define CTRY_MALDIVES 960 // Maldives #define CTRY_MEXICO 52 // Mexico #define CTRY_MONACO 33 // Principality of Monaco #define CTRY_MONGOLIA 976 // Mongolia #define CTRY_MOROCCO 212 // Morocco #define CTRY_NETHERLANDS 31 // Netherlands #define CTRY_NEW_ZEALAND 64 // New Zealand #define CTRY_NICARAGUA 505 // Nicaragua #define CTRY_NORWAY 47 // Norway #define CTRY_OMAN 968 // Oman #define CTRY_PAKISTAN 92 // Islamic Republic of Pakistan #define CTRY_PANAMA 507 // Panama #define CTRY_PARAGUAY 595 // Paraguay #define CTRY_PERU 51 // Peru #define CTRY_PHILIPPINES 63 // Republic of the Philippines #define CTRY_POLAND 48 // Poland #define CTRY_PORTUGAL 351 // Portugal #define CTRY_PRCHINA 86 // People's Republic of China #define CTRY_PUERTO_RICO 1 // Puerto Rico #define CTRY_QATAR 974 // Qatar #define CTRY_ROMANIA 40 // Romania #define CTRY_RUSSIA 7 // Russia #define CTRY_SAUDI_ARABIA 966 // Saudi Arabia #define CTRY_SERBIA 381 // Serbia #define CTRY_SINGAPORE 65 // Singapore #define CTRY_SLOVAK 421 // Slovak Republic #define CTRY_SLOVENIA 386 // Slovenia #define CTRY_SOUTH_AFRICA 27 // South Africa #define CTRY_SOUTH_KOREA 82 // Korea #define CTRY_SPAIN 34 // Spain #define CTRY_SWEDEN 46 // Sweden #define CTRY_SWITZERLAND 41 // Switzerland #define CTRY_SYRIA 963 // Syria #define CTRY_TAIWAN 886 // Taiwan #define CTRY_TATARSTAN 7 // Tatarstan #define CTRY_THAILAND 66 // Thailand #define CTRY_TRINIDAD_Y_TOBAGO 1 // Trinidad y Tobago #define CTRY_TUNISIA 216 // Tunisia #define CTRY_TURKEY 90 // Turkey #define CTRY_UAE 971 // U.A.E. #define CTRY_UKRAINE 380 // Ukraine #define CTRY_UNITED_KINGDOM 44 // United Kingdom #define CTRY_UNITED_STATES 1 // United States #define CTRY_URUGUAY 598 // Uruguay #define CTRY_UZBEKISTAN 7 // Uzbekistan #define CTRY_VENEZUELA 58 // Venezuela #define CTRY_VIET_NAM 84 // Viet Nam #define CTRY_YEMEN 967 // Yemen #define CTRY_ZIMBABWE 263 // Zimbabwe // // Locale Types. // // These types are used for the GetLocaleInfo NLS API routine. // Some of these types are also used for the SetLocaleInfo NLS API routine. // // // The following LCTypes may be used in combination with any other LCTypes. // // LOCALE_NOUSEROVERRIDE is also used in GetTimeFormat and // GetDateFormat. // // LOCALE_USE_CP_ACP is used in many of the A (Ansi) apis that need // to do string translation. // // LOCALE_RETURN_NUMBER will return the result from GetLocaleInfo as a // number instead of a string. This flag is only valid for the LCTypes // beginning with LOCALE_I. // #define LOCALE_NOUSEROVERRIDE 0x80000000 // do not use user overrides #define LOCALE_USE_CP_ACP 0x40000000 // use the system ACP #if(WINVER >= 0x0400) #define LOCALE_RETURN_NUMBER 0x20000000 // return number instead of string #endif /* WINVER >= 0x0400 */ // // The following LCTypes are mutually exclusive in that they may NOT // be used in combination with each other. // #define LOCALE_ILANGUAGE 0x00000001 // language id #define LOCALE_SLANGUAGE 0x00000002 // localized name of language #define LOCALE_SENGLANGUAGE 0x00001001 // English name of language #define LOCALE_SABBREVLANGNAME 0x00000003 // abbreviated language name #define LOCALE_SNATIVELANGNAME 0x00000004 // native name of language #define LOCALE_ICOUNTRY 0x00000005 // country code #define LOCALE_SCOUNTRY 0x00000006 // localized name of country #define LOCALE_SENGCOUNTRY 0x00001002 // English name of country #define LOCALE_SABBREVCTRYNAME 0x00000007 // abbreviated country name #define LOCALE_SNATIVECTRYNAME 0x00000008 // native name of country #define LOCALE_IDEFAULTLANGUAGE 0x00000009 // default language id #define LOCALE_IDEFAULTCOUNTRY 0x0000000A // default country code #define LOCALE_IDEFAULTCODEPAGE 0x0000000B // default oem code page #define LOCALE_IDEFAULTANSICODEPAGE 0x00001004 // default ansi code page #define LOCALE_IDEFAULTMACCODEPAGE 0x00001011 // default mac code page #define LOCALE_SLIST 0x0000000C // list item separator #define LOCALE_IMEASURE 0x0000000D // 0 = metric, 1 = US #define LOCALE_SDECIMAL 0x0000000E // decimal separator #define LOCALE_STHOUSAND 0x0000000F // thousand separator #define LOCALE_SGROUPING 0x00000010 // digit grouping #define LOCALE_IDIGITS 0x00000011 // number of fractional digits #define LOCALE_ILZERO 0x00000012 // leading zeros for decimal #define LOCALE_INEGNUMBER 0x00001010 // negative number mode #define LOCALE_SNATIVEDIGITS 0x00000013 // native ascii 0-9 #define LOCALE_SCURRENCY 0x00000014 // local monetary symbol #define LOCALE_SINTLSYMBOL 0x00000015 // intl monetary symbol #define LOCALE_SMONDECIMALSEP 0x00000016 // monetary decimal separator #define LOCALE_SMONTHOUSANDSEP 0x00000017 // monetary thousand separator #define LOCALE_SMONGROUPING 0x00000018 // monetary grouping #define LOCALE_ICURRDIGITS 0x00000019 // # local monetary digits #define LOCALE_IINTLCURRDIGITS 0x0000001A // # intl monetary digits #define LOCALE_ICURRENCY 0x0000001B // positive currency mode #define LOCALE_INEGCURR 0x0000001C // negative currency mode #define LOCALE_SDATE 0x0000001D // date separator #define LOCALE_STIME 0x0000001E // time separator #define LOCALE_SSHORTDATE 0x0000001F // short date format string #define LOCALE_SLONGDATE 0x00000020 // long date format string #define LOCALE_STIMEFORMAT 0x00001003 // time format string #define LOCALE_IDATE 0x00000021 // short date format ordering #define LOCALE_ILDATE 0x00000022 // long date format ordering #define LOCALE_ITIME 0x00000023 // time format specifier #define LOCALE_ITIMEMARKPOSN 0x00001005 // time marker position #define LOCALE_ICENTURY 0x00000024 // century format specifier (short date) #define LOCALE_ITLZERO 0x00000025 // leading zeros in time field #define LOCALE_IDAYLZERO 0x00000026 // leading zeros in day field (short date) #define LOCALE_IMONLZERO 0x00000027 // leading zeros in month field (short date) #define LOCALE_S1159 0x00000028 // AM designator #define LOCALE_S2359 0x00000029 // PM designator #define LOCALE_ICALENDARTYPE 0x00001009 // type of calendar specifier #define LOCALE_IOPTIONALCALENDAR 0x0000100B // additional calendar types specifier #define LOCALE_IFIRSTDAYOFWEEK 0x0000100C // first day of week specifier #define LOCALE_IFIRSTWEEKOFYEAR 0x0000100D // first week of year specifier #define LOCALE_SDAYNAME1 0x0000002A // long name for Monday #define LOCALE_SDAYNAME2 0x0000002B // long name for Tuesday #define LOCALE_SDAYNAME3 0x0000002C // long name for Wednesday #define LOCALE_SDAYNAME4 0x0000002D // long name for Thursday #define LOCALE_SDAYNAME5 0x0000002E // long name for Friday #define LOCALE_SDAYNAME6 0x0000002F // long name for Saturday #define LOCALE_SDAYNAME7 0x00000030 // long name for Sunday #define LOCALE_SABBREVDAYNAME1 0x00000031 // abbreviated name for Monday #define LOCALE_SABBREVDAYNAME2 0x00000032 // abbreviated name for Tuesday #define LOCALE_SABBREVDAYNAME3 0x00000033 // abbreviated name for Wednesday #define LOCALE_SABBREVDAYNAME4 0x00000034 // abbreviated name for Thursday #define LOCALE_SABBREVDAYNAME5 0x00000035 // abbreviated name for Friday #define LOCALE_SABBREVDAYNAME6 0x00000036 // abbreviated name for Saturday #define LOCALE_SABBREVDAYNAME7 0x00000037 // abbreviated name for Sunday #define LOCALE_SMONTHNAME1 0x00000038 // long name for January #define LOCALE_SMONTHNAME2 0x00000039 // long name for February #define LOCALE_SMONTHNAME3 0x0000003A // long name for March #define LOCALE_SMONTHNAME4 0x0000003B // long name for April #define LOCALE_SMONTHNAME5 0x0000003C // long name for May #define LOCALE_SMONTHNAME6 0x0000003D // long name for June #define LOCALE_SMONTHNAME7 0x0000003E // long name for July #define LOCALE_SMONTHNAME8 0x0000003F // long name for August #define LOCALE_SMONTHNAME9 0x00000040 // long name for September #define LOCALE_SMONTHNAME10 0x00000041 // long name for October #define LOCALE_SMONTHNAME11 0x00000042 // long name for November #define LOCALE_SMONTHNAME12 0x00000043 // long name for December #define LOCALE_SMONTHNAME13 0x0000100E // long name for 13th month (if exists) #define LOCALE_SABBREVMONTHNAME1 0x00000044 // abbreviated name for January #define LOCALE_SABBREVMONTHNAME2 0x00000045 // abbreviated name for February #define LOCALE_SABBREVMONTHNAME3 0x00000046 // abbreviated name for March #define LOCALE_SABBREVMONTHNAME4 0x00000047 // abbreviated name for April #define LOCALE_SABBREVMONTHNAME5 0x00000048 // abbreviated name for May #define LOCALE_SABBREVMONTHNAME6 0x00000049 // abbreviated name for June #define LOCALE_SABBREVMONTHNAME7 0x0000004A // abbreviated name for July #define LOCALE_SABBREVMONTHNAME8 0x0000004B // abbreviated name for August #define LOCALE_SABBREVMONTHNAME9 0x0000004C // abbreviated name for September #define LOCALE_SABBREVMONTHNAME10 0x0000004D // abbreviated name for October #define LOCALE_SABBREVMONTHNAME11 0x0000004E // abbreviated name for November #define LOCALE_SABBREVMONTHNAME12 0x0000004F // abbreviated name for December #define LOCALE_SABBREVMONTHNAME13 0x0000100F // abbreviated name for 13th month (if exists) #define LOCALE_SPOSITIVESIGN 0x00000050 // positive sign #define LOCALE_SNEGATIVESIGN 0x00000051 // negative sign #define LOCALE_IPOSSIGNPOSN 0x00000052 // positive sign position #define LOCALE_INEGSIGNPOSN 0x00000053 // negative sign position #define LOCALE_IPOSSYMPRECEDES 0x00000054 // mon sym precedes pos amt #define LOCALE_IPOSSEPBYSPACE 0x00000055 // mon sym sep by space from pos amt #define LOCALE_INEGSYMPRECEDES 0x00000056 // mon sym precedes neg amt #define LOCALE_INEGSEPBYSPACE 0x00000057 // mon sym sep by space from neg amt #if(WINVER >= 0x0400) #define LOCALE_FONTSIGNATURE 0x00000058 // font signature #define LOCALE_SISO639LANGNAME 0x00000059 // ISO abbreviated language name #define LOCALE_SISO3166CTRYNAME 0x0000005A // ISO abbreviated country name #endif /* WINVER >= 0x0400 */ #if(WINVER >= 0x0500) #define LOCALE_IDEFAULTEBCDICCODEPAGE 0x00001012 // default ebcdic code page #define LOCALE_IPAPERSIZE 0x0000100A // 1 = letter, 5 = legal, 8 = a3, 9 = a4 #define LOCALE_SENGCURRNAME 0x00001007 // english name of currency #define LOCALE_SNATIVECURRNAME 0x00001008 // native name of currency #define LOCALE_SYEARMONTH 0x00001006 // year month format string #define LOCALE_SSORTNAME 0x00001013 // sort name #define LOCALE_IDIGITSUBSTITUTION 0x00001014 // 0 = context, 1 = none, 2 = national #endif /* WINVER >= 0x0500 */ // // Time Flags for GetTimeFormat. // #define TIME_NOMINUTESORSECONDS 0x00000001 // do not use minutes or seconds #define TIME_NOSECONDS 0x00000002 // do not use seconds #define TIME_NOTIMEMARKER 0x00000004 // do not use time marker #define TIME_FORCE24HOURFORMAT 0x00000008 // always use 24 hour format // // Date Flags for GetDateFormat. // #define DATE_SHORTDATE 0x00000001 // use short date picture #define DATE_LONGDATE 0x00000002 // use long date picture #define DATE_USE_ALT_CALENDAR 0x00000004 // use alternate calendar (if any) #if(WINVER >= 0x0500) #define DATE_YEARMONTH 0x00000008 // use year month picture #define DATE_LTRREADING 0x00000010 // add marks for left to right reading order layout #define DATE_RTLREADING 0x00000020 // add marks for right to left reading order layout #endif /* WINVER >= 0x0500 */ // // Calendar Types. // // These types are used for the EnumCalendarInfo and GetCalendarInfo // NLS API routines. // Some of these types are also used for the SetCalendarInfo NLS API // routine. // // // The following CalTypes may be used in combination with any other CalTypes. // // CAL_NOUSEROVERRIDE // // CAL_USE_CP_ACP is used in the A (Ansi) apis that need to do string // translation. // // CAL_RETURN_NUMBER will return the result from GetCalendarInfo as a // number instead of a string. This flag is only valid for the CalTypes // beginning with CAL_I. // #if(WINVER >= 0x0500) #define CAL_NOUSEROVERRIDE LOCALE_NOUSEROVERRIDE // do not use user overrides #define CAL_USE_CP_ACP LOCALE_USE_CP_ACP // use the system ACP #define CAL_RETURN_NUMBER LOCALE_RETURN_NUMBER // return number instead of string #endif /* WINVER >= 0x0500 */ // // The following CalTypes are mutually exclusive in that they may NOT // be used in combination with each other. // #define CAL_ICALINTVALUE 0x00000001 // calendar type #define CAL_SCALNAME 0x00000002 // native name of calendar #define CAL_IYEAROFFSETRANGE 0x00000003 // starting years of eras #define CAL_SERASTRING 0x00000004 // era name for IYearOffsetRanges #define CAL_SSHORTDATE 0x00000005 // short date format string #define CAL_SLONGDATE 0x00000006 // long date format string #define CAL_SDAYNAME1 0x00000007 // native name for Monday #define CAL_SDAYNAME2 0x00000008 // native name for Tuesday #define CAL_SDAYNAME3 0x00000009 // native name for Wednesday #define CAL_SDAYNAME4 0x0000000a // native name for Thursday #define CAL_SDAYNAME5 0x0000000b // native name for Friday #define CAL_SDAYNAME6 0x0000000c // native name for Saturday #define CAL_SDAYNAME7 0x0000000d // native name for Sunday #define CAL_SABBREVDAYNAME1 0x0000000e // abbreviated name for Monday #define CAL_SABBREVDAYNAME2 0x0000000f // abbreviated name for Tuesday #define CAL_SABBREVDAYNAME3 0x00000010 // abbreviated name for Wednesday #define CAL_SABBREVDAYNAME4 0x00000011 // abbreviated name for Thursday #define CAL_SABBREVDAYNAME5 0x00000012 // abbreviated name for Friday #define CAL_SABBREVDAYNAME6 0x00000013 // abbreviated name for Saturday #define CAL_SABBREVDAYNAME7 0x00000014 // abbreviated name for Sunday #define CAL_SMONTHNAME1 0x00000015 // native name for January #define CAL_SMONTHNAME2 0x00000016 // native name for February #define CAL_SMONTHNAME3 0x00000017 // native name for March #define CAL_SMONTHNAME4 0x00000018 // native name for April #define CAL_SMONTHNAME5 0x00000019 // native name for May #define CAL_SMONTHNAME6 0x0000001a // native name for June #define CAL_SMONTHNAME7 0x0000001b // native name for July #define CAL_SMONTHNAME8 0x0000001c // native name for August #define CAL_SMONTHNAME9 0x0000001d // native name for September #define CAL_SMONTHNAME10 0x0000001e // native name for October #define CAL_SMONTHNAME11 0x0000001f // native name for November #define CAL_SMONTHNAME12 0x00000020 // native name for December #define CAL_SMONTHNAME13 0x00000021 // native name for 13th month (if any) #define CAL_SABBREVMONTHNAME1 0x00000022 // abbreviated name for January #define CAL_SABBREVMONTHNAME2 0x00000023 // abbreviated name for February #define CAL_SABBREVMONTHNAME3 0x00000024 // abbreviated name for March #define CAL_SABBREVMONTHNAME4 0x00000025 // abbreviated name for April #define CAL_SABBREVMONTHNAME5 0x00000026 // abbreviated name for May #define CAL_SABBREVMONTHNAME6 0x00000027 // abbreviated name for June #define CAL_SABBREVMONTHNAME7 0x00000028 // abbreviated name for July #define CAL_SABBREVMONTHNAME8 0x00000029 // abbreviated name for August #define CAL_SABBREVMONTHNAME9 0x0000002a // abbreviated name for September #define CAL_SABBREVMONTHNAME10 0x0000002b // abbreviated name for October #define CAL_SABBREVMONTHNAME11 0x0000002c // abbreviated name for November #define CAL_SABBREVMONTHNAME12 0x0000002d // abbreviated name for December #define CAL_SABBREVMONTHNAME13 0x0000002e // abbreviated name for 13th month (if any) #if(WINVER >= 0x0500) #define CAL_SYEARMONTH 0x0000002f // year month format string #define CAL_ITWODIGITYEARMAX 0x00000030 // two digit year max #endif /* WINVER >= 0x0500 */ // // Calendar Enumeration Value. // #define ENUM_ALL_CALENDARS 0xffffffff // enumerate all calendars // // Calendar ID Values. // #define CAL_GREGORIAN 1 // Gregorian (localized) calendar #define CAL_GREGORIAN_US 2 // Gregorian (U.S.) calendar #define CAL_JAPAN 3 // Japanese Emperor Era calendar #define CAL_TAIWAN 4 // Taiwan calendar #define CAL_KOREA 5 // Korean Tangun Era calendar #define CAL_HIJRI 6 // Hijri (Arabic Lunar) calendar #define CAL_THAI 7 // Thai calendar #define CAL_HEBREW 8 // Hebrew (Lunar) calendar #define CAL_GREGORIAN_ME_FRENCH 9 // Gregorian Middle East French calendar #define CAL_GREGORIAN_ARABIC 10 // Gregorian Arabic calendar #define CAL_GREGORIAN_XLIT_ENGLISH 11 // Gregorian Transliterated English calendar #define CAL_GREGORIAN_XLIT_FRENCH 12 // Gregorian Transliterated French calendar // // Language Group ID Values. // #define LGRPID_WESTERN_EUROPE 0x0001 // Western Europe & U.S. #define LGRPID_CENTRAL_EUROPE 0x0002 // Central Europe #define LGRPID_BALTIC 0x0003 // Baltic #define LGRPID_GREEK 0x0004 // Greek #define LGRPID_CYRILLIC 0x0005 // Cyrillic #define LGRPID_TURKISH 0x0006 // Turkish #define LGRPID_JAPANESE 0x0007 // Japanese #define LGRPID_KOREAN 0x0008 // Korean #define LGRPID_TRADITIONAL_CHINESE 0x0009 // Traditional Chinese #define LGRPID_SIMPLIFIED_CHINESE 0x000a // Simplified Chinese #define LGRPID_THAI 0x000b // Thai #define LGRPID_HEBREW 0x000c // Hebrew #define LGRPID_ARABIC 0x000d // Arabic #define LGRPID_VIETNAMESE 0x000e // Vietnamese #define LGRPID_INDIC 0x000f // Indic #define LGRPID_GEORGIAN 0x0010 // Georgian #define LGRPID_ARMENIAN 0x0011 // Armenian //////////////////////////////////////////////////////////////////////////// // // Typedefs // // Define all types for the NLS component here. // //////////////////////////////////////////////////////////////////////////// // // Language Group ID. // typedef DWORD LGRPID; // // Locale type constant. // typedef DWORD LCTYPE; // // Calendar type constant. // typedef DWORD CALTYPE; // // Calendar ID. // typedef DWORD CALID; // // CP Info. // typedef struct _cpinfo { UINT MaxCharSize; // max length (in bytes) of a char BYTE DefaultChar[MAX_DEFAULTCHAR]; // default character BYTE LeadByte[MAX_LEADBYTES]; // lead byte ranges } CPINFO, *LPCPINFO; typedef struct _cpinfoexA { UINT MaxCharSize; // max length (in bytes) of a char BYTE DefaultChar[MAX_DEFAULTCHAR]; // default character (MB) BYTE LeadByte[MAX_LEADBYTES]; // lead byte ranges WCHAR UnicodeDefaultChar; // default character (Unicode) UINT CodePage; // code page id CHAR CodePageName[MAX_PATH]; // code page name (Unicode) } CPINFOEXA, *LPCPINFOEXA; typedef struct _cpinfoexW { UINT MaxCharSize; // max length (in bytes) of a char BYTE DefaultChar[MAX_DEFAULTCHAR]; // default character (MB) BYTE LeadByte[MAX_LEADBYTES]; // lead byte ranges WCHAR UnicodeDefaultChar; // default character (Unicode) UINT CodePage; // code page id WCHAR CodePageName[MAX_PATH]; // code page name (Unicode) } CPINFOEXW, *LPCPINFOEXW; #ifdef UNICODE typedef CPINFOEXW CPINFOEX; typedef LPCPINFOEXW LPCPINFOEX; #else typedef CPINFOEXA CPINFOEX; typedef LPCPINFOEXA LPCPINFOEX; #endif // UNICODE // // Number format. // typedef struct _numberfmtA { UINT NumDigits; // number of decimal digits UINT LeadingZero; // if leading zero in decimal fields UINT Grouping; // group size left of decimal LPSTR lpDecimalSep; // ptr to decimal separator string LPSTR lpThousandSep; // ptr to thousand separator string UINT NegativeOrder; // negative number ordering } NUMBERFMTA, *LPNUMBERFMTA; typedef struct _numberfmtW { UINT NumDigits; // number of decimal digits UINT LeadingZero; // if leading zero in decimal fields UINT Grouping; // group size left of decimal LPWSTR lpDecimalSep; // ptr to decimal separator string LPWSTR lpThousandSep; // ptr to thousand separator string UINT NegativeOrder; // negative number ordering } NUMBERFMTW, *LPNUMBERFMTW; #ifdef UNICODE typedef NUMBERFMTW NUMBERFMT; typedef LPNUMBERFMTW LPNUMBERFMT; #else typedef NUMBERFMTA NUMBERFMT; typedef LPNUMBERFMTA LPNUMBERFMT; #endif // UNICODE // // Currency format. // typedef struct _currencyfmtA { UINT NumDigits; // number of decimal digits UINT LeadingZero; // if leading zero in decimal fields UINT Grouping; // group size left of decimal LPSTR lpDecimalSep; // ptr to decimal separator string LPSTR lpThousandSep; // ptr to thousand separator string UINT NegativeOrder; // negative currency ordering UINT PositiveOrder; // positive currency ordering LPSTR lpCurrencySymbol; // ptr to currency symbol string } CURRENCYFMTA, *LPCURRENCYFMTA; typedef struct _currencyfmtW { UINT NumDigits; // number of decimal digits UINT LeadingZero; // if leading zero in decimal fields UINT Grouping; // group size left of decimal LPWSTR lpDecimalSep; // ptr to decimal separator string LPWSTR lpThousandSep; // ptr to thousand separator string UINT NegativeOrder; // negative currency ordering UINT PositiveOrder; // positive currency ordering LPWSTR lpCurrencySymbol; // ptr to currency symbol string } CURRENCYFMTW, *LPCURRENCYFMTW; #ifdef UNICODE typedef CURRENCYFMTW CURRENCYFMT; typedef LPCURRENCYFMTW LPCURRENCYFMT; #else typedef CURRENCYFMTA CURRENCYFMT; typedef LPCURRENCYFMTA LPCURRENCYFMT; #endif // UNICODE // // NLS function capabilities // enum SYSNLS_FUNCTION{ COMPARE_STRING = 0x0001, }; typedef DWORD NLS_FUNCTION; // // NLS version structure. // typedef struct _nlsversioninfo{ DWORD dwNLSVersionInfoSize; DWORD dwNLSVersion; DWORD dwDefinedVersion; } NLSVERSIONINFO, *LPNLSVERSIONINFO; // // GEO defines // typedef LONG GEOID; typedef DWORD GEOTYPE; typedef DWORD GEOCLASS; #define GEOID_NOT_AVAILABLE -1 // // GEO information types for clients to query // enum SYSGEOTYPE { GEO_NATION = 0x0001, GEO_LATITUDE = 0x0002, GEO_LONGITUDE = 0x0003, GEO_ISO2 = 0x0004, GEO_ISO3 = 0x0005, GEO_RFC1766 = 0x0006, GEO_LCID = 0x0007, GEO_FRIENDLYNAME= 0x0008, GEO_OFFICIALNAME= 0x0009, GEO_TIMEZONES = 0x000A, GEO_OFFICIALLANGUAGES = 0x000B, }; // // More GEOCLASS defines will be listed here // enum SYSGEOCLASS { GEOCLASS_NATION = 16, GEOCLASS_REGION = 14, }; // // Enumeration function constants. // #ifdef STRICT typedef BOOL (CALLBACK* LANGUAGEGROUP_ENUMPROCA)(LGRPID, LPSTR, LPSTR, DWORD, LONG_PTR); typedef BOOL (CALLBACK* LANGGROUPLOCALE_ENUMPROCA)(LGRPID, LCID, LPSTR, LONG_PTR); typedef BOOL (CALLBACK* UILANGUAGE_ENUMPROCA)(LPSTR, LONG_PTR); typedef BOOL (CALLBACK* LOCALE_ENUMPROCA)(LPSTR); typedef BOOL (CALLBACK* CODEPAGE_ENUMPROCA)(LPSTR); typedef BOOL (CALLBACK* DATEFMT_ENUMPROCA)(LPSTR); typedef BOOL (CALLBACK* DATEFMT_ENUMPROCEXA)(LPSTR, CALID); typedef BOOL (CALLBACK* TIMEFMT_ENUMPROCA)(LPSTR); typedef BOOL (CALLBACK* CALINFO_ENUMPROCA)(LPSTR); typedef BOOL (CALLBACK* CALINFO_ENUMPROCEXA)(LPSTR, CALID); typedef BOOL (CALLBACK* LANGUAGEGROUP_ENUMPROCW)(LGRPID, LPWSTR, LPWSTR, DWORD, LONG_PTR); typedef BOOL (CALLBACK* LANGGROUPLOCALE_ENUMPROCW)(LGRPID, LCID, LPWSTR, LONG_PTR); typedef BOOL (CALLBACK* UILANGUAGE_ENUMPROCW)(LPWSTR, LONG_PTR); typedef BOOL (CALLBACK* LOCALE_ENUMPROCW)(LPWSTR); typedef BOOL (CALLBACK* CODEPAGE_ENUMPROCW)(LPWSTR); typedef BOOL (CALLBACK* DATEFMT_ENUMPROCW)(LPWSTR); typedef BOOL (CALLBACK* DATEFMT_ENUMPROCEXW)(LPWSTR, CALID); typedef BOOL (CALLBACK* TIMEFMT_ENUMPROCW)(LPWSTR); typedef BOOL (CALLBACK* CALINFO_ENUMPROCW)(LPWSTR); typedef BOOL (CALLBACK* CALINFO_ENUMPROCEXW)(LPWSTR, CALID); typedef BOOL (CALLBACK* GEO_ENUMPROC)(GEOID); #else // !STRICT typedef FARPROC LANGUAGEGROUP_ENUMPROCA; typedef FARPROC LANGGROUPLOCALE_ENUMPROCA; typedef FARPROC UILANGUAGE_ENUMPROCA; typedef FARPROC LOCALE_ENUMPROCA; typedef FARPROC CODEPAGE_ENUMPROCA; typedef FARPROC DATEFMT_ENUMPROCA; typedef FARPROC DATEFMT_ENUMPROCEXA; typedef FARPROC TIMEFMT_ENUMPROCA; typedef FARPROC CALINFO_ENUMPROCA; typedef FARPROC CALINFO_ENUMPROCEXA; typedef FARPROC GEO_ENUMPROC; typedef FARPROC LANGUAGEGROUP_ENUMPROCW; typedef FARPROC LANGGROUPLOCALE_ENUMPROCW; typedef FARPROC UILANGUAGE_ENUMPROCW; typedef FARPROC LOCALE_ENUMPROCW; typedef FARPROC CODEPAGE_ENUMPROCW; typedef FARPROC DATEFMT_ENUMPROCW; typedef FARPROC DATEFMT_ENUMPROCEXW; typedef FARPROC TIMEFMT_ENUMPROCW; typedef FARPROC CALINFO_ENUMPROCW; typedef FARPROC CALINFO_ENUMPROCEXW; #endif // !STRICT #ifdef UNICODE #define LANGUAGEGROUP_ENUMPROC LANGUAGEGROUP_ENUMPROCW #define LANGGROUPLOCALE_ENUMPROC LANGGROUPLOCALE_ENUMPROCW #define UILANGUAGE_ENUMPROC UILANGUAGE_ENUMPROCW #define LOCALE_ENUMPROC LOCALE_ENUMPROCW #define CODEPAGE_ENUMPROC CODEPAGE_ENUMPROCW #define DATEFMT_ENUMPROC DATEFMT_ENUMPROCW #define DATEFMT_ENUMPROCEX DATEFMT_ENUMPROCEXW #define TIMEFMT_ENUMPROC TIMEFMT_ENUMPROCW #define CALINFO_ENUMPROC CALINFO_ENUMPROCW #define CALINFO_ENUMPROCEX CALINFO_ENUMPROCEXW #else #define LANGUAGEGROUP_ENUMPROC LANGUAGEGROUP_ENUMPROCA #define LANGGROUPLOCALE_ENUMPROC LANGGROUPLOCALE_ENUMPROCA #define UILANGUAGE_ENUMPROC UILANGUAGE_ENUMPROCA #define LOCALE_ENUMPROC LOCALE_ENUMPROCA #define CODEPAGE_ENUMPROC CODEPAGE_ENUMPROCA #define DATEFMT_ENUMPROC DATEFMT_ENUMPROCA #define DATEFMT_ENUMPROCEX DATEFMT_ENUMPROCEXA #define TIMEFMT_ENUMPROC TIMEFMT_ENUMPROCA #define CALINFO_ENUMPROC CALINFO_ENUMPROCA #define CALINFO_ENUMPROCEX CALINFO_ENUMPROCEXA #endif // !UNICODE //////////////////////////////////////////////////////////////////////////// // // Macros // // Define all macros for the NLS component here. // //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// // // Function Prototypes // // Only prototypes for the NLS APIs should go here. // //////////////////////////////////////////////////////////////////////////// // // Code Page Dependent APIs. // WINBASEAPI BOOL WINAPI IsValidCodePage( IN UINT CodePage); WINBASEAPI UINT WINAPI GetACP(void); WINBASEAPI UINT WINAPI GetOEMCP(void); WINBASEAPI BOOL WINAPI GetCPInfo( IN UINT CodePage, OUT LPCPINFO lpCPInfo); WINBASEAPI BOOL WINAPI GetCPInfoExA( IN UINT CodePage, IN DWORD dwFlags, OUT LPCPINFOEXA lpCPInfoEx); WINBASEAPI BOOL WINAPI GetCPInfoExW( IN UINT CodePage, IN DWORD dwFlags, OUT LPCPINFOEXW lpCPInfoEx); #ifdef UNICODE #define GetCPInfoEx GetCPInfoExW #else #define GetCPInfoEx GetCPInfoExA #endif // !UNICODE WINBASEAPI BOOL WINAPI IsDBCSLeadByte( IN BYTE TestChar); WINBASEAPI BOOL WINAPI IsDBCSLeadByteEx( IN UINT CodePage, IN BYTE TestChar); WINBASEAPI int WINAPI MultiByteToWideChar( IN UINT CodePage, IN DWORD dwFlags, IN LPCSTR lpMultiByteStr, IN int cbMultiByte, OUT LPWSTR lpWideCharStr, IN int cchWideChar); WINBASEAPI int WINAPI WideCharToMultiByte( IN UINT CodePage, IN DWORD dwFlags, IN LPCWSTR lpWideCharStr, IN int cchWideChar, OUT LPSTR lpMultiByteStr, IN int cbMultiByte, IN LPCSTR lpDefaultChar, OUT LPBOOL lpUsedDefaultChar); // // Locale Dependent APIs. // WINBASEAPI int WINAPI CompareStringA( IN LCID Locale, IN DWORD dwCmpFlags, IN LPCSTR lpString1, IN int cchCount1, IN LPCSTR lpString2, IN int cchCount2); WINBASEAPI int WINAPI CompareStringW( IN LCID Locale, IN DWORD dwCmpFlags, IN LPCWSTR lpString1, IN int cchCount1, IN LPCWSTR lpString2, IN int cchCount2); #ifdef UNICODE #define CompareString CompareStringW #else #define CompareString CompareStringA #endif // !UNICODE WINBASEAPI int WINAPI LCMapStringA( IN LCID Locale, IN DWORD dwMapFlags, IN LPCSTR lpSrcStr, IN int cchSrc, OUT LPSTR lpDestStr, IN int cchDest); WINBASEAPI int WINAPI LCMapStringW( IN LCID Locale, IN DWORD dwMapFlags, IN LPCWSTR lpSrcStr, IN int cchSrc, OUT LPWSTR lpDestStr, IN int cchDest); #ifdef UNICODE #define LCMapString LCMapStringW #else #define LCMapString LCMapStringA #endif // !UNICODE WINBASEAPI int WINAPI GetLocaleInfoA( IN LCID Locale, IN LCTYPE LCType, OUT LPSTR lpLCData, IN int cchData); WINBASEAPI int WINAPI GetLocaleInfoW( IN LCID Locale, IN LCTYPE LCType, OUT LPWSTR lpLCData, IN int cchData); #ifdef UNICODE #define GetLocaleInfo GetLocaleInfoW #else #define GetLocaleInfo GetLocaleInfoA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetLocaleInfoA( IN LCID Locale, IN LCTYPE LCType, IN LPCSTR lpLCData); WINBASEAPI BOOL WINAPI SetLocaleInfoW( IN LCID Locale, IN LCTYPE LCType, IN LPCWSTR lpLCData); #ifdef UNICODE #define SetLocaleInfo SetLocaleInfoW #else #define SetLocaleInfo SetLocaleInfoA #endif // !UNICODE #if (WINVER >= 0x040A) WINBASEAPI int WINAPI GetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPSTR lpCalData, int cchData, LPDWORD lpValue); WINBASEAPI int WINAPI GetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPWSTR lpCalData, int cchData, LPDWORD lpValue); #ifdef UNICODE #define GetCalendarInfo GetCalendarInfoW #else #define GetCalendarInfo GetCalendarInfoA #endif // !UNICODE WINBASEAPI BOOL WINAPI SetCalendarInfoA( LCID Locale, CALID Calendar, CALTYPE CalType, LPCSTR lpCalData); WINBASEAPI BOOL WINAPI SetCalendarInfoW( LCID Locale, CALID Calendar, CALTYPE CalType, LPCWSTR lpCalData); #ifdef UNICODE #define SetCalendarInfo SetCalendarInfoW #else #define SetCalendarInfo SetCalendarInfoA #endif // !UNICODE #endif WINBASEAPI int WINAPI GetTimeFormatA( IN LCID Locale, IN DWORD dwFlags, IN CONST SYSTEMTIME *lpTime, IN LPCSTR lpFormat, OUT LPSTR lpTimeStr, IN int cchTime); WINBASEAPI int WINAPI GetTimeFormatW( IN LCID Locale, IN DWORD dwFlags, IN CONST SYSTEMTIME *lpTime, IN LPCWSTR lpFormat, OUT LPWSTR lpTimeStr, IN int cchTime); #ifdef UNICODE #define GetTimeFormat GetTimeFormatW #else #define GetTimeFormat GetTimeFormatA #endif // !UNICODE WINBASEAPI int WINAPI GetDateFormatA( IN LCID Locale, IN DWORD dwFlags, IN CONST SYSTEMTIME *lpDate, IN LPCSTR lpFormat, OUT LPSTR lpDateStr, IN int cchDate); WINBASEAPI int WINAPI GetDateFormatW( IN LCID Locale, IN DWORD dwFlags, IN CONST SYSTEMTIME *lpDate, IN LPCWSTR lpFormat, OUT LPWSTR lpDateStr, IN int cchDate); #ifdef UNICODE #define GetDateFormat GetDateFormatW #else #define GetDateFormat GetDateFormatA #endif // !UNICODE WINBASEAPI int WINAPI GetNumberFormatA( IN LCID Locale, IN DWORD dwFlags, IN LPCSTR lpValue, IN CONST NUMBERFMTA *lpFormat, OUT LPSTR lpNumberStr, IN int cchNumber); WINBASEAPI int WINAPI GetNumberFormatW( IN LCID Locale, IN DWORD dwFlags, IN LPCWSTR lpValue, IN CONST NUMBERFMTW *lpFormat, OUT LPWSTR lpNumberStr, IN int cchNumber); #ifdef UNICODE #define GetNumberFormat GetNumberFormatW #else #define GetNumberFormat GetNumberFormatA #endif // !UNICODE WINBASEAPI int WINAPI GetCurrencyFormatA( IN LCID Locale, IN DWORD dwFlags, IN LPCSTR lpValue, IN CONST CURRENCYFMTA *lpFormat, OUT LPSTR lpCurrencyStr, IN int cchCurrency); WINBASEAPI int WINAPI GetCurrencyFormatW( IN LCID Locale, IN DWORD dwFlags, IN LPCWSTR lpValue, IN CONST CURRENCYFMTW *lpFormat, OUT LPWSTR lpCurrencyStr, IN int cchCurrency); #ifdef UNICODE #define GetCurrencyFormat GetCurrencyFormatW #else #define GetCurrencyFormat GetCurrencyFormatA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumCalendarInfoA( IN CALINFO_ENUMPROCA lpCalInfoEnumProc, IN LCID Locale, IN CALID Calendar, IN CALTYPE CalType); WINBASEAPI BOOL WINAPI EnumCalendarInfoW( IN CALINFO_ENUMPROCW lpCalInfoEnumProc, IN LCID Locale, IN CALID Calendar, IN CALTYPE CalType); #ifdef UNICODE #define EnumCalendarInfo EnumCalendarInfoW #else #define EnumCalendarInfo EnumCalendarInfoA #endif // !UNICODE #if(WINVER >= 0x0500) WINBASEAPI BOOL WINAPI EnumCalendarInfoExA( IN CALINFO_ENUMPROCEXA lpCalInfoEnumProcEx, IN LCID Locale, IN CALID Calendar, IN CALTYPE CalType); WINBASEAPI BOOL WINAPI EnumCalendarInfoExW( IN CALINFO_ENUMPROCEXW lpCalInfoEnumProcEx, IN LCID Locale, IN CALID Calendar, IN CALTYPE CalType); #ifdef UNICODE #define EnumCalendarInfoEx EnumCalendarInfoExW #else #define EnumCalendarInfoEx EnumCalendarInfoExA #endif // !UNICODE #endif /* WINVER >= 0x0500 */ WINBASEAPI BOOL WINAPI EnumTimeFormatsA( IN TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, IN LCID Locale, IN DWORD dwFlags); WINBASEAPI BOOL WINAPI EnumTimeFormatsW( IN TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, IN LCID Locale, IN DWORD dwFlags); #ifdef UNICODE #define EnumTimeFormats EnumTimeFormatsW #else #define EnumTimeFormats EnumTimeFormatsA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumDateFormatsA( IN DATEFMT_ENUMPROCA lpDateFmtEnumProc, IN LCID Locale, IN DWORD dwFlags); WINBASEAPI BOOL WINAPI EnumDateFormatsW( IN DATEFMT_ENUMPROCW lpDateFmtEnumProc, IN LCID Locale, IN DWORD dwFlags); #ifdef UNICODE #define EnumDateFormats EnumDateFormatsW #else #define EnumDateFormats EnumDateFormatsA #endif // !UNICODE #if(WINVER >= 0x0500) WINBASEAPI BOOL WINAPI EnumDateFormatsExA( IN DATEFMT_ENUMPROCEXA lpDateFmtEnumProcEx, IN LCID Locale, IN DWORD dwFlags); WINBASEAPI BOOL WINAPI EnumDateFormatsExW( IN DATEFMT_ENUMPROCEXW lpDateFmtEnumProcEx, IN LCID Locale, IN DWORD dwFlags); #ifdef UNICODE #define EnumDateFormatsEx EnumDateFormatsExW #else #define EnumDateFormatsEx EnumDateFormatsExA #endif // !UNICODE #endif /* WINVER >= 0x0500 */ #if(WINVER >= 0x0500) WINBASEAPI BOOL WINAPI IsValidLanguageGroup( IN LGRPID LanguageGroup, IN DWORD dwFlags); #endif /* WINVER >= 0x0500 */ WINBASEAPI BOOL WINAPI GetNLSVersion( IN NLS_FUNCTION Function, IN LCID Locale, OUT LPNLSVERSIONINFO lpVersionInformation); WINBASEAPI BOOL WINAPI IsNLSDefinedString( IN NLS_FUNCTION Function, IN DWORD dwFlags, IN LPNLSVERSIONINFO lpVersionInformation, IN LPCWSTR lpString, IN INT cchStr); WINBASEAPI BOOL WINAPI IsValidLocale( IN LCID Locale, IN DWORD dwFlags); WINBASEAPI int WINAPI GetGeoInfoA( GEOID Location, GEOTYPE GeoType, LPSTR lpGeoData, int cchData, LANGID LangId); WINBASEAPI int WINAPI GetGeoInfoW( GEOID Location, GEOTYPE GeoType, LPWSTR lpGeoData, int cchData, LANGID LangId); #ifdef UNICODE #define GetGeoInfo GetGeoInfoW #else #define GetGeoInfo GetGeoInfoA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumSystemGeoID( GEOCLASS GeoClass, GEOID ParentGeoId, GEO_ENUMPROC lpGeoEnumProc); WINBASEAPI GEOID WINAPI GetUserGeoID( GEOCLASS GeoClass); WINBASEAPI BOOL WINAPI SetUserGeoID( GEOID GeoId); WINBASEAPI LCID WINAPI ConvertDefaultLocale( IN OUT LCID Locale); WINBASEAPI LCID WINAPI GetThreadLocale(void); WINBASEAPI BOOL WINAPI SetThreadLocale( IN LCID Locale ); #if(WINVER >= 0x0500) WINBASEAPI LANGID WINAPI GetSystemDefaultUILanguage(void); WINBASEAPI LANGID WINAPI GetUserDefaultUILanguage(void); #endif /* WINVER >= 0x0500 */ WINBASEAPI LANGID WINAPI GetSystemDefaultLangID(void); WINBASEAPI LANGID WINAPI GetUserDefaultLangID(void); WINBASEAPI LCID WINAPI GetSystemDefaultLCID(void); WINBASEAPI LCID WINAPI GetUserDefaultLCID(void); // // Locale Independent APIs. // WINBASEAPI BOOL WINAPI GetStringTypeExA( IN LCID Locale, IN DWORD dwInfoType, IN LPCSTR lpSrcStr, IN int cchSrc, OUT LPWORD lpCharType); WINBASEAPI BOOL WINAPI GetStringTypeExW( IN LCID Locale, IN DWORD dwInfoType, IN LPCWSTR lpSrcStr, IN int cchSrc, OUT LPWORD lpCharType); #ifdef UNICODE #define GetStringTypeEx GetStringTypeExW #else #define GetStringTypeEx GetStringTypeExA #endif // !UNICODE // // NOTE: The parameters for GetStringTypeA and GetStringTypeW are // NOT the same. The W version was shipped in NT 3.1. The // A version was then shipped in 16-bit OLE with the wrong // parameters (ported from Win95). To be compatible, we // must break the relationship between the A and W versions // of GetStringType. There will be NO function call for the // generic GetStringType. // // GetStringTypeEx (above) should be used instead. // WINBASEAPI BOOL WINAPI GetStringTypeA( IN LCID Locale, IN DWORD dwInfoType, IN LPCSTR lpSrcStr, IN int cchSrc, OUT LPWORD lpCharType); WINBASEAPI BOOL WINAPI GetStringTypeW( IN DWORD dwInfoType, IN LPCWSTR lpSrcStr, IN int cchSrc, OUT LPWORD lpCharType); WINBASEAPI int WINAPI FoldStringA( IN DWORD dwMapFlags, IN LPCSTR lpSrcStr, IN int cchSrc, OUT LPSTR lpDestStr, IN int cchDest); WINBASEAPI int WINAPI FoldStringW( IN DWORD dwMapFlags, IN LPCWSTR lpSrcStr, IN int cchSrc, OUT LPWSTR lpDestStr, IN int cchDest); #ifdef UNICODE #define FoldString FoldStringW #else #define FoldString FoldStringA #endif // !UNICODE #if(WINVER >= 0x0500) WINBASEAPI BOOL WINAPI EnumSystemLanguageGroupsA( IN LANGUAGEGROUP_ENUMPROCA lpLanguageGroupEnumProc, IN DWORD dwFlags, IN LONG_PTR lParam); WINBASEAPI BOOL WINAPI EnumSystemLanguageGroupsW( IN LANGUAGEGROUP_ENUMPROCW lpLanguageGroupEnumProc, IN DWORD dwFlags, IN LONG_PTR lParam); #ifdef UNICODE #define EnumSystemLanguageGroups EnumSystemLanguageGroupsW #else #define EnumSystemLanguageGroups EnumSystemLanguageGroupsA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumLanguageGroupLocalesA( IN LANGGROUPLOCALE_ENUMPROCA lpLangGroupLocaleEnumProc, IN LGRPID LanguageGroup, IN DWORD dwFlags, IN LONG_PTR lParam); WINBASEAPI BOOL WINAPI EnumLanguageGroupLocalesW( IN LANGGROUPLOCALE_ENUMPROCW lpLangGroupLocaleEnumProc, IN LGRPID LanguageGroup, IN DWORD dwFlags, IN LONG_PTR lParam); #ifdef UNICODE #define EnumLanguageGroupLocales EnumLanguageGroupLocalesW #else #define EnumLanguageGroupLocales EnumLanguageGroupLocalesA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumUILanguagesA( IN UILANGUAGE_ENUMPROCA lpUILanguageEnumProc, IN DWORD dwFlags, IN LONG_PTR lParam); WINBASEAPI BOOL WINAPI EnumUILanguagesW( IN UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, IN DWORD dwFlags, IN LONG_PTR lParam); #ifdef UNICODE #define EnumUILanguages EnumUILanguagesW #else #define EnumUILanguages EnumUILanguagesA #endif // !UNICODE #endif /* WINVER >= 0x0500 */ WINBASEAPI BOOL WINAPI EnumSystemLocalesA( IN LOCALE_ENUMPROCA lpLocaleEnumProc, IN DWORD dwFlags); WINBASEAPI BOOL WINAPI EnumSystemLocalesW( IN LOCALE_ENUMPROCW lpLocaleEnumProc, IN DWORD dwFlags); #ifdef UNICODE #define EnumSystemLocales EnumSystemLocalesW #else #define EnumSystemLocales EnumSystemLocalesA #endif // !UNICODE WINBASEAPI BOOL WINAPI EnumSystemCodePagesA( IN CODEPAGE_ENUMPROCA lpCodePageEnumProc, IN DWORD dwFlags); WINBASEAPI BOOL WINAPI EnumSystemCodePagesW( IN CODEPAGE_ENUMPROCW lpCodePageEnumProc, IN DWORD dwFlags); #ifdef UNICODE #define EnumSystemCodePages EnumSystemCodePagesW #else #define EnumSystemCodePages EnumSystemCodePagesA #endif // !UNICODE #endif // NONLS #ifdef __cplusplus } #endif #endif // _WINNLS_