Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / ComponentModel / CultureInfoConverter.cs / 1305376 / CultureInfoConverter.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.ComponentModel {
using Microsoft.Win32;
using System.Collections;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.Threading;
using System.Security.Permissions;
///
/// Provides a type converter to convert
///
[HostProtection(SharedState = true)]
public class CultureInfoConverter : TypeConverter
{
private StandardValuesCollection values;
///
/// Retrieves the "default" name for our culture.
///
private string DefaultCultureString {
get {
return SR.GetString(SR.CultureInfoConverterDefaultCultureString);
}
}
///
/// Retrieves the Name for a input CultureInfo.
///
protected virtual string GetCultureName(CultureInfo culture) {
return culture.Name;
}
///
///
/// Gets a value indicating whether this converter can
/// convert an object in the given source type to a System.Globalization.CultureInfo
/// object using
/// the specified context.
///
///
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) {
if (sourceType == typeof(string)) {
return true;
}
return base.CanConvertFrom(context, sourceType);
}
///
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
///
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
if (destinationType == typeof(InstanceDescriptor)) {
return true;
}
return base.CanConvertTo(context, destinationType);
}
///
///
/// Converts the specified value object to a
///
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
if (value is string) {
// Hack, Only when GetCultureName returns culture.Name, we use CultureInfoMapper
// (Since CultureInfoMapper will transfer Culture.DisplayName to Culture.Name).
// Otherwise, we just keep the value unchange.
string text = (string)value;
if (GetCultureName(CultureInfo.InvariantCulture).Equals(""))
{
text = CultureInfoMapper.GetCultureInfoName((string)value);
}
CultureInfo retVal = null;
CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
if (culture != null && culture.Equals(CultureInfo.InvariantCulture)) {
Thread.CurrentThread.CurrentUICulture = culture;
}
try {
// Look for the default culture info.
//
if (text == null || text.Length == 0 || string.Compare(text, DefaultCultureString, StringComparison.Ordinal) == 0) {
retVal = CultureInfo.InvariantCulture;
}
// Now look in our set of installed cultures.
//
if (retVal == null) {
ICollection values = GetStandardValues(context);
IEnumerator e = values.GetEnumerator();
while (e.MoveNext()) {
CultureInfo info = (CultureInfo)e.Current;
if (info != null && string.Compare(GetCultureName(info), text, StringComparison.Ordinal) == 0) {
retVal = info;
break;
}
}
}
// Now try to create a new culture info from this value
//
if (retVal == null) {
try {
retVal = new CultureInfo(text);
}
catch {}
}
// Finally, try to find a partial match
//
if (retVal == null) {
text = text.ToLower(CultureInfo.CurrentCulture);
IEnumerator e = values.GetEnumerator();
while (e.MoveNext()) {
CultureInfo info = (CultureInfo)e.Current;
if (info != null && GetCultureName(info).ToLower(CultureInfo.CurrentCulture).StartsWith(text)) {
retVal = info;
break;
}
}
}
}
finally {
Thread.CurrentThread.CurrentUICulture = currentUICulture;
}
// No good. We can't support it.
//
if (retVal == null) {
throw new ArgumentException(SR.GetString(SR.CultureInfoConverterInvalidCulture, (string)value));
}
return retVal;
}
return base.ConvertFrom(context, culture, value);
}
///
///
/// Converts the given
/// value object to the
/// specified destination type.
///
///
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
if (destinationType == null) {
throw new ArgumentNullException("destinationType");
}
if (destinationType == typeof(string)) {
string retVal;
CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
if (culture != null && culture.Equals(CultureInfo.InvariantCulture)) {
Thread.CurrentThread.CurrentUICulture = culture;
}
try {
if (value == null || value == CultureInfo.InvariantCulture) {
retVal = DefaultCultureString;
}
else {
retVal = GetCultureName(((CultureInfo)value));
}
}
finally {
Thread.CurrentThread.CurrentUICulture = currentUICulture;
}
return retVal;
}
if (destinationType == typeof(InstanceDescriptor) && value is CultureInfo) {
CultureInfo c = (CultureInfo) value;
ConstructorInfo ctor = typeof(CultureInfo).GetConstructor(new Type[] {typeof(string)});
if (ctor != null) {
return new InstanceDescriptor(ctor, new object[] {c.Name});
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
///
///
/// Gets a collection of standard values collection for a System.Globalization.CultureInfo
/// object using the specified context.
///
///
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
if (values == null) {
CultureInfo[] installedCultures = CultureInfo.GetCultures(CultureTypes.SpecificCultures | CultureTypes.NeutralCultures);
int invariantIndex = Array.IndexOf(installedCultures, CultureInfo.InvariantCulture);
CultureInfo[] array;
if (invariantIndex != -1) {
Debug.Assert(invariantIndex >= 0 && invariantIndex < installedCultures.Length);
installedCultures[invariantIndex] = null;
array = new CultureInfo[installedCultures.Length];
}
else {
array = new CultureInfo[installedCultures.Length + 1];
}
Array.Copy(installedCultures, array, installedCultures.Length);
Array.Sort(array, new CultureComparer(this));
Debug.Assert(array[0] == null);
if (array[0] == null) {
//we replace null with the real default culture because there are code paths
// where the propgrid will send values from this returned array directly -- instead
// of converting it to a string and then back to a value (which this relied on).
array[0] = CultureInfo.InvariantCulture; //null isn't the value here -- invariantculture is.
}
values = new StandardValuesCollection(array);
}
return values;
}
///
///
/// Gets a value indicating whether the list of standard values returned from
/// System.ComponentModel.CultureInfoConverter.GetStandardValues is an exclusive list.
///
///
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) {
return false;
}
///
///
/// Gets a value indicating whether this object supports a
/// standard set of values that can be picked from a list using the specified
/// context.
///
///
public override bool GetStandardValuesSupported(ITypeDescriptorContext context) {
return true;
}
///
/// IComparer object used for sorting CultureInfos
/// WARNING: If you change where null is positioned, then you must fix CultureConverter.GetStandardValues!
///
private class CultureComparer : IComparer {
private CultureInfoConverter converter;
public CultureComparer(CultureInfoConverter cultureConverter) {
Debug.Assert(cultureConverter != null);
converter = cultureConverter;
}
public int Compare(object item1, object item2) {
if (item1 == null) {
// If both are null, then they are equal
//
if (item2 == null) {
return 0;
}
// Otherwise, item1 is null, but item2 is valid (greater)
//
return -1;
}
if (item2 == null) {
// item2 is null, so item 1 is greater
//
return 1;
}
String itemName1 = converter.GetCultureName(((CultureInfo)item1));
String itemName2 = converter.GetCultureName(((CultureInfo)item2));
CompareInfo compInfo = (CultureInfo.CurrentCulture).CompareInfo;
return compInfo.Compare(itemName1, itemName2, CompareOptions.StringSort);
}
}
private static class CultureInfoMapper {
/// Dictionary of CultureInfo.DisplayName, CultureInfo.Name for cultures that have changed DisplayName over releases.
/// This is to workaround an issue with CultureInfoConverter that serializes DisplayName (fixing it would introduce breaking changes).
private static System.Collections.Generic.Dictionary cultureInfoNameMap;
public static string GetCultureInfoName(string cultureInfoDisplayName) {
if (cultureInfoNameMap == null) {
InitializeCultureInfoMap();
}
if (cultureInfoNameMap.ContainsKey(cultureInfoDisplayName)) {
return cultureInfoNameMap[cultureInfoDisplayName];
}
return cultureInfoDisplayName;
}
private static void InitializeCultureInfoMap() {
cultureInfoNameMap = new System.Collections.Generic.Dictionary() {
{"Afrikaans", "af"},
{"Afrikaans (South Africa)", "af-ZA"},
{"Albanian", "sq"},
{"Albanian (Albania)", "sq-AL"},
{"Alsatian (France)", "gsw-FR"},
{"Amharic (Ethiopia)", "am-ET"},
{"Arabic", "ar"},
{"Arabic (Algeria)", "ar-DZ"},
{"Arabic (Bahrain)", "ar-BH"},
{"Arabic (Egypt)", "ar-EG"},
{"Arabic (Iraq)", "ar-IQ"},
{"Arabic (Jordan)", "ar-JO"},
{"Arabic (Kuwait)", "ar-KW"},
{"Arabic (Lebanon)", "ar-LB"},
{"Arabic (Libya)", "ar-LY"},
{"Arabic (Morocco)", "ar-MA"},
{"Arabic (Oman)", "ar-OM"},
{"Arabic (Qatar)", "ar-QA"},
{"Arabic (Saudi Arabia)", "ar-SA"},
{"Arabic (Syria)", "ar-SY"},
{"Arabic (Tunisia)", "ar-TN"},
{"Arabic (U.A.E.)", "ar-AE"},
{"Arabic (Yemen)", "ar-YE"},
{"Armenian", "hy"},
{"Armenian (Armenia)", "hy-AM"},
{"Assamese (India)", "as-IN"},
{"Azeri", "az"},
{"Azeri (Cyrillic, Azerbaijan)", "az-Cyrl-AZ"},
{"Azeri (Latin, Azerbaijan)", "az-Latn-AZ"},
{"Bashkir (Russia)", "ba-RU"},
{"Basque", "eu"},
{"Basque (Basque)", "eu-ES"},
{"Belarusian", "be"},
{"Belarusian (Belarus)", "be-BY"},
{"Bengali (Bangladesh)", "bn-BD"},
{"Bengali (India)", "bn-IN"},
{"Bosnian (Cyrillic, Bosnia and Herzegovina)", "bs-Cyrl-BA"},
{"Bosnian (Latin, Bosnia and Herzegovina)", "bs-Latn-BA"},
{"Breton (France)", "br-FR"},
{"Bulgarian", "bg"},
{"Bulgarian (Bulgaria)", "bg-BG"},
{"Catalan", "ca"},
{"Catalan (Catalan)", "ca-ES"},
{"Chinese (Hong Kong S.A.R.)", "zh-HK"},
{"Chinese (Macao S.A.R.)", "zh-MO"},
{"Chinese (People's Republic of China)", "zh-CN"},
{"Chinese (Simplified)", "zh-CHS"},
{"Chinese (Singapore)", "zh-SG"},
{"Chinese (----)", "zh-TW"},
{"Chinese (Traditional)", "zh-CHT"},
{"Corsican (France)", "co-FR"},
{"Croatian", "hr"},
{"Croatian (Croatia)", "hr-HR"},
{"Croatian (Latin, Bosnia and Herzegovina)", "hr-BA"},
{"Czech", "cs"},
{"Czech (Czech Republic)", "cs-CZ"},
{"Danish", "da"},
{"Danish (Denmark)", "da-DK"},
{"Dari (Afghanistan)", "prs-AF"},
{"Divehi", "dv"},
{"Divehi (Maldives)", "dv-MV"},
{"Dutch", "nl"},
{"Dutch (Belgium)", "nl-BE"},
{"Dutch (Netherlands)", "nl-NL"},
{"English", "en"},
{"English (Australia)", "en-AU"},
{"English (Belize)", "en-BZ"},
{"English (Canada)", "en-CA"},
{"English (Caribbean)", "en-029"},
{"English (India)", "en-IN"},
{"English (Ireland)", "en-IE"},
{"English (Jamaica)", "en-JM"},
{"English (Malaysia)", "en-MY"},
{"English (New Zealand)", "en-NZ"},
{"English (Republic of the Philippines)", "en-PH"},
{"English (Singapore)", "en-SG"},
{"English (South Africa)", "en-ZA"},
{"English (Trinidad and Tobago)", "en-TT"},
{"English (United Kingdom)", "en-GB"},
{"English (United States)", "en-US"},
{"English (Zimbabwe)", "en-ZW"},
{"Estonian", "et"},
{"Estonian (Estonia)", "et-EE"},
{"Faroese", "fo"},
{"Faroese (Faroe Islands)", "fo-FO"},
{"Filipino (Philippines)", "fil-PH"},
{"Finnish", "fi"},
{"Finnish (Finland)", "fi-FI"},
{"French", "fr"},
{"French (Belgium)", "fr-BE"},
{"French (Canada)", "fr-CA"},
{"French (France)", "fr-FR"},
{"French (Luxembourg)", "fr-LU"},
{"French (Principality of Monaco)", "fr-MC"},
{"French (Switzerland)", "fr-CH"},
{"Frisian (Netherlands)", "fy-NL"},
{"Galician", "gl"},
{"Galician (Galician)", "gl-ES"},
{"Georgian", "ka"},
{"Georgian (Georgia)", "ka-GE"},
{"German", "de"},
{"German (Austria)", "de-AT"},
{"German (Germany)", "de-DE"},
{"German (Liechtenstein)", "de-LI"},
{"German (Luxembourg)", "de-LU"},
{"German (Switzerland)", "de-CH"},
{"Greek", "el"},
{"Greek (Greece)", "el-GR"},
{"Greenlandic (Greenland)", "kl-GL"},
{"Gujarati", "gu"},
{"Gujarati (India)", "gu-IN"},
{"Hausa (Latin, Nigeria)", "ha-Latn-NG"},
{"Hebrew", "he"},
{"Hebrew (Israel)", "he-IL"},
{"Hindi", "hi"},
{"Hindi (India)", "hi-IN"},
{"Hungarian", "hu"},
{"Hungarian (Hungary)", "hu-HU"},
{"Icelandic", "is"},
{"Icelandic (Iceland)", "is-IS"},
{"Igbo (Nigeria)", "ig-NG"},
{"Indonesian", "id"},
{"Indonesian (Indonesia)", "id-ID"},
{"Inuktitut (Latin, Canada)", "iu-Latn-CA"},
{"Inuktitut (Syllabics, Canada)", "iu-Cans-CA"},
{"Invariant Language (Invariant ----)", ""},
{"Irish (Ireland)", "ga-IE"},
{"isiXhosa (South Africa)", "xh-ZA"},
{"isiZulu (South Africa)", "zu-ZA"},
{"Italian", "it"},
{"Italian (Italy)", "it-IT"},
{"Italian (Switzerland)", "it-CH"},
{"Japanese", "ja"},
{"Japanese (Japan)", "ja-JP"},
{"K'iche (Guatemala)", "qut-GT"},
{"Kannada", "kn"},
{"Kannada (India)", "kn-IN"},
{"Kazakh", "kk"},
{"Kazakh (Kazakhstan)", "kk-KZ"},
{"Khmer (Cambodia)", "km-KH"},
{"Kinyarwanda (Rwanda)", "rw-RW"},
{"Kiswahili", "sw"},
{"Kiswahili (Kenya)", "sw-KE"},
{"Konkani", "kok"},
{"Konkani (India)", "kok-IN"},
{"Korean", "ko"},
{"Korean (Korea)", "ko-KR"},
{"Kyrgyz", "ky"},
{"Kyrgyz (Kyrgyzstan)", "ky-KG"},
{"Lao (Lao P.D.R.)", "lo-LA"},
{"Latvian", "lv"},
{"Latvian (Latvia)", "lv-LV"},
{"Lithuanian", "lt"},
{"Lithuanian (Lithuania)", "lt-LT"},
{"Lower Sorbian (Germany)", "dsb-DE"},
{"Luxembourgish (Luxembourg)", "lb-LU"},
{"----n", "mk"},
{"----n (Former Yugoslav Republic of ----)", "mk-MK"},
{"Malay", "ms"},
{"Malay (Brunei Darussalam)", "ms-BN"},
{"Malay (Malaysia)", "ms-MY"},
{"Malayalam (India)", "ml-IN"},
{"Maltese (Malta)", "mt-MT"},
{"Maori (New Zealand)", "mi-NZ"},
{"Mapudungun (Chile)", "arn-CL"},
{"Marathi", "mr"},
{"Marathi (India)", "mr-IN"},
{"Mohawk (Mohawk)", "moh-CA"},
{"Mongolian", "mn"},
{"Mongolian (Cyrillic, Mongolia)", "mn-MN"},
{"Mongolian (Traditional Mongolian, PRC)", "mn-Mong-CN"},
{"Nepali (Nepal)", "ne-NP"},
{"Norwegian", "no"},
{"Norwegian, Bokmål (Norway)", "nb-NO"},
{"Norwegian, Nynorsk (Norway)", "nn-NO"},
{"Occitan (France)", "oc-FR"},
{"Oriya (India)", "or-IN"},
{"Pashto (Afghanistan)", "ps-AF"},
{"Persian", "fa"},
{"Persian (Iran)", "fa-IR"},
{"Polish", "pl"},
{"Polish (Poland)", "pl-PL"},
{"Portuguese", "pt"},
{"Portuguese (Brazil)", "pt-BR"},
{"Portuguese (Portugal)", "pt-PT"},
{"Punjabi", "pa"},
{"Punjabi (India)", "pa-IN"},
{"Quechua (Bolivia)", "quz-BO"},
{"Quechua (Ecuador)", "quz-EC"},
{"Quechua (Peru)", "quz-PE"},
{"Romanian", "ro"},
{"Romanian (Romania)", "ro-RO"},
{"Romansh (Switzerland)", "rm-CH"},
{"Russian", "ru"},
{"Russian (Russia)", "ru-RU"},
{"Sami, Inari (Finland)", "smn-FI"},
{"Sami, Lule (Norway)", "smj-NO"},
{"Sami, Lule (Sweden)", "smj-SE"},
{"Sami, Northern (Finland)", "se-FI"},
{"Sami, Northern (Norway)", "se-NO"},
{"Sami, Northern (Sweden)", "se-SE"},
{"Sami, Skolt (Finland)", "sms-FI"},
{"Sami, Southern (Norway)", "sma-NO"},
{"Sami, Southern (Sweden)", "sma-SE"},
{"Sanskrit", "sa"},
{"Sanskrit (India)", "sa-IN"},
{"Serbian", "sr"},
{"Serbian (Cyrillic, Bosnia and Herzegovina)", "sr-Cyrl-BA"},
{"Serbian (Cyrillic, Serbia)", "sr-Cyrl-CS"},
{"Serbian (Latin, Bosnia and Herzegovina)", "sr-Latn-BA"},
{"Serbian (Latin, Serbia)", "sr-Latn-CS"},
{"Sesotho sa Leboa (South Africa)", "nso-ZA"},
{"Setswana (South Africa)", "tn-ZA"},
{"Sinhala (Sri Lanka)", "si-LK"},
{"Slovak", "sk"},
{"Slovak (Slovakia)", "sk-SK"},
{"Slovenian", "sl"},
{"Slovenian (Slovenia)", "sl-SI"},
{"Spanish", "es"},
{"Spanish (Argentina)", "es-AR"},
{"Spanish (Bolivia)", "es-BO"},
{"Spanish (Chile)", "es-CL"},
{"Spanish (Colombia)", "es-CO"},
{"Spanish (Costa Rica)", "es-CR"},
{"Spanish (Dominican Republic)", "es-DO"},
{"Spanish (Ecuador)", "es-EC"},
{"Spanish (El Salvador)", "es-SV"},
{"Spanish (Guatemala)", "es-GT"},
{"Spanish (Honduras)", "es-HN"},
{"Spanish (Mexico)", "es-MX"},
{"Spanish (Nicaragua)", "es-NI"},
{"Spanish (Panama)", "es-PA"},
{"Spanish (Paraguay)", "es-PY"},
{"Spanish (Peru)", "es-PE"},
{"Spanish (Puerto Rico)", "es-PR"},
{"Spanish (Spain)", "es-ES"},
{"Spanish (United States)", "es-US"},
{"Spanish (Uruguay)", "es-UY"},
{"Spanish (Venezuela)", "es-VE"},
{"Swedish", "sv"},
{"Swedish (Finland)", "sv-FI"},
{"Swedish (Sweden)", "sv-SE"},
{"Syriac", "syr"},
{"Syriac (Syria)", "syr-SY"},
{"Tajik (Cyrillic, Tajikistan)", "tg-Cyrl-TJ"},
{"Tamazight (Latin, Algeria)", "tzm-Latn-DZ"},
{"Tamil", "ta"},
{"Tamil (India)", "ta-IN"},
{"Tatar", "tt"},
{"Tatar (Russia)", "tt-RU"},
{"Telugu", "te"},
{"Telugu (India)", "te-IN"},
{"Thai", "th"},
{"Thai (Thailand)", "th-TH"},
{"Tibetan (PRC)", "bo-CN"},
{"Turkish", "tr"},
{"Turkish (Turkey)", "tr-TR"},
{"Turkmen (Turkmenistan)", "tk-TM"},
{"Uighur (PRC)", "ug-CN"},
{"Ukrainian", "uk"},
{"Ukrainian (Ukraine)", "uk-UA"},
{"Upper Sorbian (Germany)", "hsb-DE"},
{"Urdu", "ur"},
{"Urdu (Islamic Republic of Pakistan)", "ur-PK"},
{"Uzbek", "uz"},
{"Uzbek (Cyrillic, Uzbekistan)", "uz-Cyrl-UZ"},
{"Uzbek (Latin, Uzbekistan)", "uz-Latn-UZ"},
{"Vietnamese", "vi"},
{"Vietnamese (Vietnam)", "vi-VN"},
{"Welsh (United Kingdom)", "cy-GB"},
{"Wolof (Senegal)", "wo-SN"},
{"Yakut (Russia)", "sah-RU"},
{"Yi (PRC)", "ii-CN"},
{"Yoruba (Nigeria)", "yo-NG"}
};
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.ComponentModel {
using Microsoft.Win32;
using System.Collections;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.Threading;
using System.Security.Permissions;
///
/// Provides a type converter to convert
///
[HostProtection(SharedState = true)]
public class CultureInfoConverter : TypeConverter
{
private StandardValuesCollection values;
///
/// Retrieves the "default" name for our culture.
///
private string DefaultCultureString {
get {
return SR.GetString(SR.CultureInfoConverterDefaultCultureString);
}
}
///
/// Retrieves the Name for a input CultureInfo.
///
protected virtual string GetCultureName(CultureInfo culture) {
return culture.Name;
}
///
///
/// Gets a value indicating whether this converter can
/// convert an object in the given source type to a System.Globalization.CultureInfo
/// object using
/// the specified context.
///
///
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) {
if (sourceType == typeof(string)) {
return true;
}
return base.CanConvertFrom(context, sourceType);
}
///
/// Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.
///
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
if (destinationType == typeof(InstanceDescriptor)) {
return true;
}
return base.CanConvertTo(context, destinationType);
}
///
///
/// Converts the specified value object to a
///
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
if (value is string) {
// Hack, Only when GetCultureName returns culture.Name, we use CultureInfoMapper
// (Since CultureInfoMapper will transfer Culture.DisplayName to Culture.Name).
// Otherwise, we just keep the value unchange.
string text = (string)value;
if (GetCultureName(CultureInfo.InvariantCulture).Equals(""))
{
text = CultureInfoMapper.GetCultureInfoName((string)value);
}
CultureInfo retVal = null;
CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
if (culture != null && culture.Equals(CultureInfo.InvariantCulture)) {
Thread.CurrentThread.CurrentUICulture = culture;
}
try {
// Look for the default culture info.
//
if (text == null || text.Length == 0 || string.Compare(text, DefaultCultureString, StringComparison.Ordinal) == 0) {
retVal = CultureInfo.InvariantCulture;
}
// Now look in our set of installed cultures.
//
if (retVal == null) {
ICollection values = GetStandardValues(context);
IEnumerator e = values.GetEnumerator();
while (e.MoveNext()) {
CultureInfo info = (CultureInfo)e.Current;
if (info != null && string.Compare(GetCultureName(info), text, StringComparison.Ordinal) == 0) {
retVal = info;
break;
}
}
}
// Now try to create a new culture info from this value
//
if (retVal == null) {
try {
retVal = new CultureInfo(text);
}
catch {}
}
// Finally, try to find a partial match
//
if (retVal == null) {
text = text.ToLower(CultureInfo.CurrentCulture);
IEnumerator e = values.GetEnumerator();
while (e.MoveNext()) {
CultureInfo info = (CultureInfo)e.Current;
if (info != null && GetCultureName(info).ToLower(CultureInfo.CurrentCulture).StartsWith(text)) {
retVal = info;
break;
}
}
}
}
finally {
Thread.CurrentThread.CurrentUICulture = currentUICulture;
}
// No good. We can't support it.
//
if (retVal == null) {
throw new ArgumentException(SR.GetString(SR.CultureInfoConverterInvalidCulture, (string)value));
}
return retVal;
}
return base.ConvertFrom(context, culture, value);
}
///
///
/// Converts the given
/// value object to the
/// specified destination type.
///
///
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
if (destinationType == null) {
throw new ArgumentNullException("destinationType");
}
if (destinationType == typeof(string)) {
string retVal;
CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
if (culture != null && culture.Equals(CultureInfo.InvariantCulture)) {
Thread.CurrentThread.CurrentUICulture = culture;
}
try {
if (value == null || value == CultureInfo.InvariantCulture) {
retVal = DefaultCultureString;
}
else {
retVal = GetCultureName(((CultureInfo)value));
}
}
finally {
Thread.CurrentThread.CurrentUICulture = currentUICulture;
}
return retVal;
}
if (destinationType == typeof(InstanceDescriptor) && value is CultureInfo) {
CultureInfo c = (CultureInfo) value;
ConstructorInfo ctor = typeof(CultureInfo).GetConstructor(new Type[] {typeof(string)});
if (ctor != null) {
return new InstanceDescriptor(ctor, new object[] {c.Name});
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
///
///
/// Gets a collection of standard values collection for a System.Globalization.CultureInfo
/// object using the specified context.
///
///
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
if (values == null) {
CultureInfo[] installedCultures = CultureInfo.GetCultures(CultureTypes.SpecificCultures | CultureTypes.NeutralCultures);
int invariantIndex = Array.IndexOf(installedCultures, CultureInfo.InvariantCulture);
CultureInfo[] array;
if (invariantIndex != -1) {
Debug.Assert(invariantIndex >= 0 && invariantIndex < installedCultures.Length);
installedCultures[invariantIndex] = null;
array = new CultureInfo[installedCultures.Length];
}
else {
array = new CultureInfo[installedCultures.Length + 1];
}
Array.Copy(installedCultures, array, installedCultures.Length);
Array.Sort(array, new CultureComparer(this));
Debug.Assert(array[0] == null);
if (array[0] == null) {
//we replace null with the real default culture because there are code paths
// where the propgrid will send values from this returned array directly -- instead
// of converting it to a string and then back to a value (which this relied on).
array[0] = CultureInfo.InvariantCulture; //null isn't the value here -- invariantculture is.
}
values = new StandardValuesCollection(array);
}
return values;
}
///
///
/// Gets a value indicating whether the list of standard values returned from
/// System.ComponentModel.CultureInfoConverter.GetStandardValues is an exclusive list.
///
///
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) {
return false;
}
///
///
/// Gets a value indicating whether this object supports a
/// standard set of values that can be picked from a list using the specified
/// context.
///
///
public override bool GetStandardValuesSupported(ITypeDescriptorContext context) {
return true;
}
///
/// IComparer object used for sorting CultureInfos
/// WARNING: If you change where null is positioned, then you must fix CultureConverter.GetStandardValues!
///
private class CultureComparer : IComparer {
private CultureInfoConverter converter;
public CultureComparer(CultureInfoConverter cultureConverter) {
Debug.Assert(cultureConverter != null);
converter = cultureConverter;
}
public int Compare(object item1, object item2) {
if (item1 == null) {
// If both are null, then they are equal
//
if (item2 == null) {
return 0;
}
// Otherwise, item1 is null, but item2 is valid (greater)
//
return -1;
}
if (item2 == null) {
// item2 is null, so item 1 is greater
//
return 1;
}
String itemName1 = converter.GetCultureName(((CultureInfo)item1));
String itemName2 = converter.GetCultureName(((CultureInfo)item2));
CompareInfo compInfo = (CultureInfo.CurrentCulture).CompareInfo;
return compInfo.Compare(itemName1, itemName2, CompareOptions.StringSort);
}
}
private static class CultureInfoMapper {
/// Dictionary of CultureInfo.DisplayName, CultureInfo.Name for cultures that have changed DisplayName over releases.
/// This is to workaround an issue with CultureInfoConverter that serializes DisplayName (fixing it would introduce breaking changes).
private static System.Collections.Generic.Dictionary cultureInfoNameMap;
public static string GetCultureInfoName(string cultureInfoDisplayName) {
if (cultureInfoNameMap == null) {
InitializeCultureInfoMap();
}
if (cultureInfoNameMap.ContainsKey(cultureInfoDisplayName)) {
return cultureInfoNameMap[cultureInfoDisplayName];
}
return cultureInfoDisplayName;
}
private static void InitializeCultureInfoMap() {
cultureInfoNameMap = new System.Collections.Generic.Dictionary() {
{"Afrikaans", "af"},
{"Afrikaans (South Africa)", "af-ZA"},
{"Albanian", "sq"},
{"Albanian (Albania)", "sq-AL"},
{"Alsatian (France)", "gsw-FR"},
{"Amharic (Ethiopia)", "am-ET"},
{"Arabic", "ar"},
{"Arabic (Algeria)", "ar-DZ"},
{"Arabic (Bahrain)", "ar-BH"},
{"Arabic (Egypt)", "ar-EG"},
{"Arabic (Iraq)", "ar-IQ"},
{"Arabic (Jordan)", "ar-JO"},
{"Arabic (Kuwait)", "ar-KW"},
{"Arabic (Lebanon)", "ar-LB"},
{"Arabic (Libya)", "ar-LY"},
{"Arabic (Morocco)", "ar-MA"},
{"Arabic (Oman)", "ar-OM"},
{"Arabic (Qatar)", "ar-QA"},
{"Arabic (Saudi Arabia)", "ar-SA"},
{"Arabic (Syria)", "ar-SY"},
{"Arabic (Tunisia)", "ar-TN"},
{"Arabic (U.A.E.)", "ar-AE"},
{"Arabic (Yemen)", "ar-YE"},
{"Armenian", "hy"},
{"Armenian (Armenia)", "hy-AM"},
{"Assamese (India)", "as-IN"},
{"Azeri", "az"},
{"Azeri (Cyrillic, Azerbaijan)", "az-Cyrl-AZ"},
{"Azeri (Latin, Azerbaijan)", "az-Latn-AZ"},
{"Bashkir (Russia)", "ba-RU"},
{"Basque", "eu"},
{"Basque (Basque)", "eu-ES"},
{"Belarusian", "be"},
{"Belarusian (Belarus)", "be-BY"},
{"Bengali (Bangladesh)", "bn-BD"},
{"Bengali (India)", "bn-IN"},
{"Bosnian (Cyrillic, Bosnia and Herzegovina)", "bs-Cyrl-BA"},
{"Bosnian (Latin, Bosnia and Herzegovina)", "bs-Latn-BA"},
{"Breton (France)", "br-FR"},
{"Bulgarian", "bg"},
{"Bulgarian (Bulgaria)", "bg-BG"},
{"Catalan", "ca"},
{"Catalan (Catalan)", "ca-ES"},
{"Chinese (Hong Kong S.A.R.)", "zh-HK"},
{"Chinese (Macao S.A.R.)", "zh-MO"},
{"Chinese (People's Republic of China)", "zh-CN"},
{"Chinese (Simplified)", "zh-CHS"},
{"Chinese (Singapore)", "zh-SG"},
{"Chinese (----)", "zh-TW"},
{"Chinese (Traditional)", "zh-CHT"},
{"Corsican (France)", "co-FR"},
{"Croatian", "hr"},
{"Croatian (Croatia)", "hr-HR"},
{"Croatian (Latin, Bosnia and Herzegovina)", "hr-BA"},
{"Czech", "cs"},
{"Czech (Czech Republic)", "cs-CZ"},
{"Danish", "da"},
{"Danish (Denmark)", "da-DK"},
{"Dari (Afghanistan)", "prs-AF"},
{"Divehi", "dv"},
{"Divehi (Maldives)", "dv-MV"},
{"Dutch", "nl"},
{"Dutch (Belgium)", "nl-BE"},
{"Dutch (Netherlands)", "nl-NL"},
{"English", "en"},
{"English (Australia)", "en-AU"},
{"English (Belize)", "en-BZ"},
{"English (Canada)", "en-CA"},
{"English (Caribbean)", "en-029"},
{"English (India)", "en-IN"},
{"English (Ireland)", "en-IE"},
{"English (Jamaica)", "en-JM"},
{"English (Malaysia)", "en-MY"},
{"English (New Zealand)", "en-NZ"},
{"English (Republic of the Philippines)", "en-PH"},
{"English (Singapore)", "en-SG"},
{"English (South Africa)", "en-ZA"},
{"English (Trinidad and Tobago)", "en-TT"},
{"English (United Kingdom)", "en-GB"},
{"English (United States)", "en-US"},
{"English (Zimbabwe)", "en-ZW"},
{"Estonian", "et"},
{"Estonian (Estonia)", "et-EE"},
{"Faroese", "fo"},
{"Faroese (Faroe Islands)", "fo-FO"},
{"Filipino (Philippines)", "fil-PH"},
{"Finnish", "fi"},
{"Finnish (Finland)", "fi-FI"},
{"French", "fr"},
{"French (Belgium)", "fr-BE"},
{"French (Canada)", "fr-CA"},
{"French (France)", "fr-FR"},
{"French (Luxembourg)", "fr-LU"},
{"French (Principality of Monaco)", "fr-MC"},
{"French (Switzerland)", "fr-CH"},
{"Frisian (Netherlands)", "fy-NL"},
{"Galician", "gl"},
{"Galician (Galician)", "gl-ES"},
{"Georgian", "ka"},
{"Georgian (Georgia)", "ka-GE"},
{"German", "de"},
{"German (Austria)", "de-AT"},
{"German (Germany)", "de-DE"},
{"German (Liechtenstein)", "de-LI"},
{"German (Luxembourg)", "de-LU"},
{"German (Switzerland)", "de-CH"},
{"Greek", "el"},
{"Greek (Greece)", "el-GR"},
{"Greenlandic (Greenland)", "kl-GL"},
{"Gujarati", "gu"},
{"Gujarati (India)", "gu-IN"},
{"Hausa (Latin, Nigeria)", "ha-Latn-NG"},
{"Hebrew", "he"},
{"Hebrew (Israel)", "he-IL"},
{"Hindi", "hi"},
{"Hindi (India)", "hi-IN"},
{"Hungarian", "hu"},
{"Hungarian (Hungary)", "hu-HU"},
{"Icelandic", "is"},
{"Icelandic (Iceland)", "is-IS"},
{"Igbo (Nigeria)", "ig-NG"},
{"Indonesian", "id"},
{"Indonesian (Indonesia)", "id-ID"},
{"Inuktitut (Latin, Canada)", "iu-Latn-CA"},
{"Inuktitut (Syllabics, Canada)", "iu-Cans-CA"},
{"Invariant Language (Invariant ----)", ""},
{"Irish (Ireland)", "ga-IE"},
{"isiXhosa (South Africa)", "xh-ZA"},
{"isiZulu (South Africa)", "zu-ZA"},
{"Italian", "it"},
{"Italian (Italy)", "it-IT"},
{"Italian (Switzerland)", "it-CH"},
{"Japanese", "ja"},
{"Japanese (Japan)", "ja-JP"},
{"K'iche (Guatemala)", "qut-GT"},
{"Kannada", "kn"},
{"Kannada (India)", "kn-IN"},
{"Kazakh", "kk"},
{"Kazakh (Kazakhstan)", "kk-KZ"},
{"Khmer (Cambodia)", "km-KH"},
{"Kinyarwanda (Rwanda)", "rw-RW"},
{"Kiswahili", "sw"},
{"Kiswahili (Kenya)", "sw-KE"},
{"Konkani", "kok"},
{"Konkani (India)", "kok-IN"},
{"Korean", "ko"},
{"Korean (Korea)", "ko-KR"},
{"Kyrgyz", "ky"},
{"Kyrgyz (Kyrgyzstan)", "ky-KG"},
{"Lao (Lao P.D.R.)", "lo-LA"},
{"Latvian", "lv"},
{"Latvian (Latvia)", "lv-LV"},
{"Lithuanian", "lt"},
{"Lithuanian (Lithuania)", "lt-LT"},
{"Lower Sorbian (Germany)", "dsb-DE"},
{"Luxembourgish (Luxembourg)", "lb-LU"},
{"----n", "mk"},
{"----n (Former Yugoslav Republic of ----)", "mk-MK"},
{"Malay", "ms"},
{"Malay (Brunei Darussalam)", "ms-BN"},
{"Malay (Malaysia)", "ms-MY"},
{"Malayalam (India)", "ml-IN"},
{"Maltese (Malta)", "mt-MT"},
{"Maori (New Zealand)", "mi-NZ"},
{"Mapudungun (Chile)", "arn-CL"},
{"Marathi", "mr"},
{"Marathi (India)", "mr-IN"},
{"Mohawk (Mohawk)", "moh-CA"},
{"Mongolian", "mn"},
{"Mongolian (Cyrillic, Mongolia)", "mn-MN"},
{"Mongolian (Traditional Mongolian, PRC)", "mn-Mong-CN"},
{"Nepali (Nepal)", "ne-NP"},
{"Norwegian", "no"},
{"Norwegian, Bokmål (Norway)", "nb-NO"},
{"Norwegian, Nynorsk (Norway)", "nn-NO"},
{"Occitan (France)", "oc-FR"},
{"Oriya (India)", "or-IN"},
{"Pashto (Afghanistan)", "ps-AF"},
{"Persian", "fa"},
{"Persian (Iran)", "fa-IR"},
{"Polish", "pl"},
{"Polish (Poland)", "pl-PL"},
{"Portuguese", "pt"},
{"Portuguese (Brazil)", "pt-BR"},
{"Portuguese (Portugal)", "pt-PT"},
{"Punjabi", "pa"},
{"Punjabi (India)", "pa-IN"},
{"Quechua (Bolivia)", "quz-BO"},
{"Quechua (Ecuador)", "quz-EC"},
{"Quechua (Peru)", "quz-PE"},
{"Romanian", "ro"},
{"Romanian (Romania)", "ro-RO"},
{"Romansh (Switzerland)", "rm-CH"},
{"Russian", "ru"},
{"Russian (Russia)", "ru-RU"},
{"Sami, Inari (Finland)", "smn-FI"},
{"Sami, Lule (Norway)", "smj-NO"},
{"Sami, Lule (Sweden)", "smj-SE"},
{"Sami, Northern (Finland)", "se-FI"},
{"Sami, Northern (Norway)", "se-NO"},
{"Sami, Northern (Sweden)", "se-SE"},
{"Sami, Skolt (Finland)", "sms-FI"},
{"Sami, Southern (Norway)", "sma-NO"},
{"Sami, Southern (Sweden)", "sma-SE"},
{"Sanskrit", "sa"},
{"Sanskrit (India)", "sa-IN"},
{"Serbian", "sr"},
{"Serbian (Cyrillic, Bosnia and Herzegovina)", "sr-Cyrl-BA"},
{"Serbian (Cyrillic, Serbia)", "sr-Cyrl-CS"},
{"Serbian (Latin, Bosnia and Herzegovina)", "sr-Latn-BA"},
{"Serbian (Latin, Serbia)", "sr-Latn-CS"},
{"Sesotho sa Leboa (South Africa)", "nso-ZA"},
{"Setswana (South Africa)", "tn-ZA"},
{"Sinhala (Sri Lanka)", "si-LK"},
{"Slovak", "sk"},
{"Slovak (Slovakia)", "sk-SK"},
{"Slovenian", "sl"},
{"Slovenian (Slovenia)", "sl-SI"},
{"Spanish", "es"},
{"Spanish (Argentina)", "es-AR"},
{"Spanish (Bolivia)", "es-BO"},
{"Spanish (Chile)", "es-CL"},
{"Spanish (Colombia)", "es-CO"},
{"Spanish (Costa Rica)", "es-CR"},
{"Spanish (Dominican Republic)", "es-DO"},
{"Spanish (Ecuador)", "es-EC"},
{"Spanish (El Salvador)", "es-SV"},
{"Spanish (Guatemala)", "es-GT"},
{"Spanish (Honduras)", "es-HN"},
{"Spanish (Mexico)", "es-MX"},
{"Spanish (Nicaragua)", "es-NI"},
{"Spanish (Panama)", "es-PA"},
{"Spanish (Paraguay)", "es-PY"},
{"Spanish (Peru)", "es-PE"},
{"Spanish (Puerto Rico)", "es-PR"},
{"Spanish (Spain)", "es-ES"},
{"Spanish (United States)", "es-US"},
{"Spanish (Uruguay)", "es-UY"},
{"Spanish (Venezuela)", "es-VE"},
{"Swedish", "sv"},
{"Swedish (Finland)", "sv-FI"},
{"Swedish (Sweden)", "sv-SE"},
{"Syriac", "syr"},
{"Syriac (Syria)", "syr-SY"},
{"Tajik (Cyrillic, Tajikistan)", "tg-Cyrl-TJ"},
{"Tamazight (Latin, Algeria)", "tzm-Latn-DZ"},
{"Tamil", "ta"},
{"Tamil (India)", "ta-IN"},
{"Tatar", "tt"},
{"Tatar (Russia)", "tt-RU"},
{"Telugu", "te"},
{"Telugu (India)", "te-IN"},
{"Thai", "th"},
{"Thai (Thailand)", "th-TH"},
{"Tibetan (PRC)", "bo-CN"},
{"Turkish", "tr"},
{"Turkish (Turkey)", "tr-TR"},
{"Turkmen (Turkmenistan)", "tk-TM"},
{"Uighur (PRC)", "ug-CN"},
{"Ukrainian", "uk"},
{"Ukrainian (Ukraine)", "uk-UA"},
{"Upper Sorbian (Germany)", "hsb-DE"},
{"Urdu", "ur"},
{"Urdu (Islamic Republic of Pakistan)", "ur-PK"},
{"Uzbek", "uz"},
{"Uzbek (Cyrillic, Uzbekistan)", "uz-Cyrl-UZ"},
{"Uzbek (Latin, Uzbekistan)", "uz-Latn-UZ"},
{"Vietnamese", "vi"},
{"Vietnamese (Vietnam)", "vi-VN"},
{"Welsh (United Kingdom)", "cy-GB"},
{"Wolof (Senegal)", "wo-SN"},
{"Yakut (Russia)", "sah-RU"},
{"Yi (PRC)", "ii-CN"},
{"Yoruba (Nigeria)", "yo-NG"}
};
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Track.cs
- Util.cs
- WhitespaceRuleLookup.cs
- ImageSource.cs
- PublishLicense.cs
- Visual3D.cs
- DataServiceQueryException.cs
- DayRenderEvent.cs
- DbDataAdapter.cs
- DesignerCategoryAttribute.cs
- CmsInterop.cs
- RuntimeConfigLKG.cs
- DefaultValidator.cs
- DirectionalLight.cs
- AnimationLayer.cs
- DesignerProperties.cs
- DependencyPropertyValueSerializer.cs
- RoutedEventArgs.cs
- SymbolMethod.cs
- StringUtil.cs
- TypeReference.cs
- CodePrimitiveExpression.cs
- HostSecurityManager.cs
- WebScriptMetadataMessageEncodingBindingElement.cs
- InputLanguage.cs
- metadatamappinghashervisitor.cs
- LogWriteRestartAreaState.cs
- DetailsView.cs
- XmlSchemaSimpleContentExtension.cs
- IconHelper.cs
- BindingContext.cs
- ListBoxItem.cs
- AnnotationComponentManager.cs
- GraphicsContainer.cs
- FaultReason.cs
- PipelineDeploymentState.cs
- SevenBitStream.cs
- SplayTreeNode.cs
- MasterPageCodeDomTreeGenerator.cs
- FormClosingEvent.cs
- BoolLiteral.cs
- X509CertificateCollection.cs
- CalendarAutomationPeer.cs
- DoWorkEventArgs.cs
- ScriptBehaviorDescriptor.cs
- DataGridItemCollection.cs
- VisualBasicSettingsHandler.cs
- Duration.cs
- FileUpload.cs
- BigInt.cs
- BitmapEffectInput.cs
- ConversionValidationRule.cs
- ProxyAttribute.cs
- ProfilePropertySettings.cs
- PerformanceCounterCategory.cs
- OutputCacheProfileCollection.cs
- CacheMemory.cs
- QilFactory.cs
- LinearQuaternionKeyFrame.cs
- DataTrigger.cs
- QuaternionKeyFrameCollection.cs
- URLString.cs
- EventsTab.cs
- CardSpaceShim.cs
- NativeRightsManagementAPIsStructures.cs
- StretchValidation.cs
- SyntaxCheck.cs
- shaperfactoryquerycacheentry.cs
- Error.cs
- BinaryNode.cs
- XmlAutoDetectWriter.cs
- MULTI_QI.cs
- EmbeddedMailObject.cs
- HWStack.cs
- OdbcEnvironmentHandle.cs
- documentsequencetextcontainer.cs
- XamlHttpHandlerFactory.cs
- CollectionExtensions.cs
- XamlToRtfParser.cs
- infer.cs
- __ConsoleStream.cs
- WbmpConverter.cs
- KnownIds.cs
- IssuedTokenClientBehaviorsElement.cs
- TextSelectionHighlightLayer.cs
- AbstractDataSvcMapFileLoader.cs
- ReachDocumentReferenceSerializer.cs
- ContainerVisual.cs
- NonBatchDirectoryCompiler.cs
- UnionCqlBlock.cs
- sqlcontext.cs
- XamlStream.cs
- XamlSerializerUtil.cs
- MergablePropertyAttribute.cs
- UnaryExpression.cs
- MenuAdapter.cs
- TransformValueSerializer.cs
- UserControlCodeDomTreeGenerator.cs
- CellCreator.cs
- DataStreamFromComStream.cs