public void LanguageSubtag_newWS() { var wsManager = new PalasoWritingSystemManager(); using (var langSetup = new LanguageSetup()) { langSetup.WritingSystemManager = wsManager; langSetup.StartedInModifyState = false; langSetup.LanguageName = "Monkey"; LanguageSubtag subtag = langSetup.LanguageSubtag; Assert.AreEqual("mon", subtag.Code); LanguageSubtag newSubtag = new LanguageSubtag("mon", "Moniker", true, null); IWritingSystem newWs = wsManager.Create(newSubtag, null, null, null); wsManager.Set(newWs); subtag = langSetup.LanguageSubtag; Assert.AreEqual("aaa", subtag.Code, "Language code 'mon' should already be in use"); } }
/// <summary> /// Generates a language tag from the specified subtags. /// </summary> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public static string ToLangTag(LanguageSubtag languageSubtag, ScriptSubtag scriptSubtag, RegionSubtag regionSubtag, VariantSubtag variantSubtag) { if (languageSubtag == null) throw new ArgumentNullException("languageSubtag"); bool inPrivateUse = false; var sb = new StringBuilder(); if (languageSubtag.IsPrivateUse) { sb.Append("x-"); inPrivateUse = true; } sb.Append(languageSubtag.Code); if (scriptSubtag != null) { sb.Append("-"); if (!inPrivateUse && scriptSubtag.IsPrivateUse) { sb.Append("x-"); inPrivateUse = true; } sb.Append(scriptSubtag.Code); } if (regionSubtag != null) { sb.Append("-"); if (!inPrivateUse && regionSubtag.IsPrivateUse && !IsPrivateUseRegionCode(regionSubtag.Code)) { sb.Append("x-"); inPrivateUse = true; } sb.Append(regionSubtag.Code); } else if (languageSubtag.Code == "zh" && languageSubtag.ISO3Code == "cmn") { sb.Append("-CN"); } if (variantSubtag != null) { sb.Append("-"); if (!inPrivateUse && variantSubtag.IsPrivateUse) sb.Append("x-"); sb.Append(variantSubtag.Code); } return sb.ToString(); }
/// <summary> /// Converts the specified ICU locale to a language tag. If the ICU locale is already a valid /// language tag, it will return it. /// </summary> /// <param name="icuLocale">The ICU locale.</param> /// <returns></returns> public static string ToLangTag(string icuLocale) { if (string.IsNullOrEmpty(icuLocale)) throw new ArgumentNullException("icuLocale"); if (icuLocale.Contains("-")) { Match match = s_langTagPattern.Match(icuLocale); if (match.Success) { // We need to check for mixed case in the language code portion. This has been // observed in user data, and causes crashes later on. See LT-11288. var rgs = icuLocale.Split('-'); if (rgs[0].ToLowerInvariant() == rgs[0]) return icuLocale; var bldr = new StringBuilder(); bldr.Append(rgs[0].ToLowerInvariant()); for (var i = 1; i < rgs.Length; ++i) { bldr.Append("-"); bldr.Append(rgs[i].ToLowerInvariant()); } icuLocale = bldr.ToString(); } } Icu.UErrorCode err; string icuLanguageCode; string languageCode; Icu.GetLanguageCode(icuLocale, out icuLanguageCode, out err); if (icuLanguageCode.Length == 4 && icuLanguageCode.StartsWith("x")) languageCode = icuLanguageCode.Substring(1); else languageCode = icuLanguageCode; // Some very old projects may have codes with over-long identifiers. In desperation we truncate these. // 4-letter codes starting with 'e' are a special case. if (languageCode.Length > 3 && !(languageCode.Length == 4 && languageCode.StartsWith("e"))) languageCode = languageCode.Substring(0, 3); // The ICU locale strings in FW 6.0 allowed numbers in the language tag. The // standard doesn't allow this. Map numbers to letters deterministically, even // though the resulting code may have no relation to reality. (It may be a valid // ISO 639-3 language code that is assigned to a totally unrelated language.) if (languageCode.Contains('0')) languageCode = languageCode.Replace('0', 'a'); if (languageCode.Contains('1')) languageCode = languageCode.Replace('1', 'b'); if (languageCode.Contains('2')) languageCode = languageCode.Replace('2', 'c'); if (languageCode.Contains('3')) languageCode = languageCode.Replace('3', 'd'); if (languageCode.Contains('4')) languageCode = languageCode.Replace('4', 'e'); if (languageCode.Contains('5')) languageCode = languageCode.Replace('5', 'f'); if (languageCode.Contains('6')) languageCode = languageCode.Replace('6', 'g'); if (languageCode.Contains('7')) languageCode = languageCode.Replace('7', 'h'); if (languageCode.Contains('8')) languageCode = languageCode.Replace('8', 'i'); if (languageCode.Contains('9')) languageCode = languageCode.Replace('9', 'j'); LanguageSubtag languageSubtag; if (languageCode == icuLanguageCode) { languageSubtag = GetLanguageSubtag( (languageCode.Length == 4 && languageCode.StartsWith("e")) ? languageCode.Substring(1) : languageCode); } else { languageSubtag = new LanguageSubtag(languageCode, null, true, null); } if (icuLanguageCode == icuLocale) return ToLangTag(languageSubtag, null, null, null); string scriptCode; Icu.GetScriptCode(icuLocale, out scriptCode, out err); ScriptSubtag scriptSubtag = null; if (!string.IsNullOrEmpty(scriptCode)) scriptSubtag = GetScriptSubtag(scriptCode); string regionCode; Icu.GetCountryCode(icuLocale, out regionCode, out err); RegionSubtag regionSubtag = null; if (!string.IsNullOrEmpty(regionCode)) regionSubtag = GetRegionSubtag(regionCode); string variantCode; Icu.GetVariantCode(icuLocale, out variantCode, out err); VariantSubtag variantSubtag = null; if (!string.IsNullOrEmpty(variantCode)) { variantCode = TranslateVariantCode(variantCode, code => { string[] pieces = variantCode.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries); return Utils.ListUtils.ToString(pieces, "-", item => TranslateVariantCode(item, subItem => subItem.ToLowerInvariant())); }); variantSubtag = GetVariantSubtag(variantCode); } return ToLangTag(languageSubtag, scriptSubtag, regionSubtag, variantSubtag); }
/// <summary> /// Gets the subtags of the specified language tag. /// </summary> /// <param name="langTag">The language tag.</param> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public static bool GetSubtags(string langTag, out LanguageSubtag languageSubtag, out ScriptSubtag scriptSubtag, out RegionSubtag regionSubtag, out VariantSubtag variantSubtag) { if (string.IsNullOrEmpty(langTag)) throw new ArgumentNullException("langTag"); languageSubtag = null; scriptSubtag = null; regionSubtag = null; variantSubtag = null; Match match = s_langTagPattern.Match(langTag); if (!match.Success) return false; var parts = new[] { "language", "script", "region", "variant" }; Group privateUseGroup = match.Groups["privateuse"]; string[] privateUseSubTags = null; int privateUseSubTagIndex = 0; bool privateUsePrefix = false; string privateUseSubTag = null; int part = -1; if (privateUseGroup.Success) { for (part = parts.Length - 1; part >= 0; part--) { Group group = match.Groups[parts[part]]; if (group.Success && privateUseGroup.Index > group.Index) break; } part++; privateUseSubTags = privateUseGroup.Value.Split('-'); privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } string languageCode = match.Groups["language"].Value; if (!string.IsNullOrEmpty(languageCode)) { languageSubtag = GetLanguageSubtag(languageCode); } else if (privateUseSubTag != null && part <= 0) { languageSubtag = new LanguageSubtag(privateUseSubTag, null, true, null); privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } string scriptCode = match.Groups["script"].Value; if (!string.IsNullOrEmpty(scriptCode)) { scriptSubtag = GetScriptSubtag(scriptCode); } else if (privateUseSubTag != null && part <= 1 && s_scriptPattern.IsMatch(privateUseSubTag)) { scriptSubtag = privateUsePrefix ? new ScriptSubtag(privateUseSubTag, null, true) : GetScriptSubtag(privateUseSubTag); privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } string regionCode = match.Groups["region"].Value; if (!string.IsNullOrEmpty(regionCode)) { regionSubtag = GetRegionSubtag(regionCode); } else if (privateUseSubTag != null && part <= 2 && s_regionPattern.IsMatch(privateUseSubTag)) { regionSubtag = GetRegionSubtag(privateUseSubTag); privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } var variantSb = new StringBuilder(); bool variantPrivateUsePrefix = false; string variantCode = match.Groups["variant"].Value; if (!string.IsNullOrEmpty(variantCode)) { variantSb.Append(variantCode); } // We would like to also check this subtag against the variant pattern // to ensure that we have a legitimate variant code, but for loading legacy projects // with poorly-formed codes, we have to do something with the private use subtag, // so if it doesn't match any of the others we force it to be a variant even if // it is not properly formed. else if (privateUseSubTag != null && part <= 3) { variantSb.Append(privateUseSubTag); variantPrivateUsePrefix = privateUsePrefix; privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } while (privateUseSubTag != null) { variantSb.Append("-"); if (privateUsePrefix) variantSb.Append("x-"); variantSb.Append(privateUseSubTag); privateUseSubTag = NextSubTag(privateUseSubTags, ref privateUseSubTagIndex, out privateUsePrefix); } variantCode = variantSb.ToString(); if (!string.IsNullOrEmpty(variantCode)) { variantSubtag = variantPrivateUsePrefix ? new VariantSubtag(variantCode, null, true, null) : GetVariantSubtag(variantCode); } return true; }
/// <summary> /// Creates a new writing system. /// </summary> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public IWritingSystem Create(LanguageSubtag languageSubtag, ScriptSubtag scriptSubtag, RegionSubtag regionSubtag, VariantSubtag variantSubtag) { if (!languageSubtag.IsValid) throw new ArgumentException("Can not create a new writing system with an invalid language tag."); PalasoWritingSystem ws; lock (m_syncRoot) ws = (PalasoWritingSystem)m_localStore.CreateNew(); ws.LanguageSubtag = languageSubtag; ws.ScriptSubtag = scriptSubtag; ws.RegionSubtag = regionSubtag; ws.VariantSubtag = variantSubtag; if (!string.IsNullOrEmpty(languageSubtag.Name)) ws.Abbreviation = languageSubtag.Name.Length > 3 ? languageSubtag.Name.Substring(0, 3) : languageSubtag.Name; else ws.Abbreviation = ws.Id; CultureInfo ci = MiscUtils.GetCultureForWs(ws.Id); if (ci != null) { ws.SortUsing = WritingSystemDefinition.SortRulesType.OtherLanguage; ws.SortRules = ci.Name; } ws.Modified = false; return ws; }
public void GetValidLangCodeForNewLang() { string storePath = PrepareTempStore("Store"); string globalStorePath = PrepareTempStore("GlobalStore"); EnsureDirectoryIsEmpty(storePath); EnsureDirectoryIsEmpty(globalStorePath); var globalStore = new GlobalFileWritingSystemStore(globalStorePath); var wsManager = new PalasoWritingSystemManager( new LocalFileWritingSystemStore(storePath, globalStore), globalStore); Assert.AreEqual("qip", wsManager.GetValidLangTagForNewLang("Qipkey")); Assert.AreEqual("sn", wsManager.GetValidLangTagForNewLang("Sn")); Assert.AreEqual("eba", wsManager.GetValidLangTagForNewLang("\u00CBbashlish")); // \u00CB == E with diacritic Assert.AreEqual("eee", wsManager.GetValidLangTagForNewLang("\u00CB\u00CB\u00CBlish")); // \u00CB == E with diacritic Assert.AreEqual("aaa", wsManager.GetValidLangTagForNewLang("U")); LanguageSubtag subtag = new LanguageSubtag("qip", "Qipkey", true, null); IWritingSystem newWs = wsManager.Create(subtag, null, null, null); wsManager.Set(newWs); Assert.AreEqual("aaa", wsManager.GetValidLangTagForNewLang("Qipsing"), "code for 'qip' should already be taken"); subtag = new LanguageSubtag("aaa", "Qipsing", true, null); newWs = wsManager.Create(subtag, null, null, null); wsManager.Set(newWs); Assert.AreEqual("aab", wsManager.GetValidLangTagForNewLang("Qipwest"), "code for 'qip' should already be taken twice"); // ENHANCE: Ideally, we would want to test incrementing the middle and first character, // but that would require at least 677 (26^2 + 1) writing systems be created. }
/// <summary></summary> public IWritingSystem Create(LanguageSubtag languageSubtag, ScriptSubtag scriptSubtag, RegionSubtag regionSubtag, VariantSubtag variantSubtag) { throw new NotImplementedException(); }
static LangTagUtils() { s_icuTagPattern = new Regex(IcuTagExpr, RegexOptions.ExplicitCapture); s_langTagPattern = new Regex(LangTagExpr, RegexOptions.ExplicitCapture); s_langPattern = new Regex("\\A(" + LanguageExpr + ")\\z", RegexOptions.ExplicitCapture); s_scriptPattern = new Regex("\\A(" + ScriptExpr + ")\\z", RegexOptions.ExplicitCapture); s_regionPattern = new Regex("\\A(" + RegionExpr + ")\\z", RegexOptions.ExplicitCapture); s_variantPattern = new Regex("\\A(" + FuzzyVariantExpr + ")\\z", RegexOptions.ExplicitCapture); s_languageSubtags = new Dictionary<string, LanguageSubtag>(); foreach (var langCode in StandardTags.ValidIso639LanguageCodes) { var code = langCode.Code; switch (code) { // ISO3Code is now only set when it differs from Code. case "cmn": code = "zh"; langCode.ISO3Code = "cmn"; break; case "pes": code = "fa"; langCode.ISO3Code = "pes"; break; case "arb": code = "ar"; langCode.ISO3Code = "arb"; break; case "zlm": code = "ms"; langCode.ISO3Code = "zlm"; break; } var languageSubtag = new LanguageSubtag(code, langCode.Name, false, langCode.ISO3Code); s_languageSubtags[languageSubtag.Code] = languageSubtag; if (!string.IsNullOrEmpty(languageSubtag.ISO3Code)) s_languageSubtags[languageSubtag.ISO3Code] = languageSubtag; } s_scriptSubtags = new Dictionary<string, ScriptSubtag>(); foreach (var scriptCode in StandardTags.ValidIso15924Scripts) s_scriptSubtags[scriptCode.Code] = new ScriptSubtag(scriptCode.Code, scriptCode.Label, false); s_regionSubtags = new Dictionary<string, RegionSubtag>(); foreach (var regionCode in StandardTags.ValidIso3166Regions) s_regionSubtags[regionCode.Subtag] = new RegionSubtag(regionCode.Subtag, regionCode.Description, false); s_variantSubtags = new Dictionary<string, VariantSubtag>(); foreach (var variantCode in StandardTags.ValidRegisteredVariants) s_variantSubtags[variantCode.Subtag] = new VariantSubtag(variantCode.Subtag, variantCode.Description, false, variantCode.Prefixes); // These ones are considered non-private in that the user can't edit the code, but they already contain needed X's. s_variantSubtags["fonipa-x-etic"] = new VariantSubtag("fonipa-x-etic", "Phonetic", false, null); s_variantSubtags["fonipa-x-emic"] = new VariantSubtag("fonipa-x-emic", "Phonemic", false, null); s_variantSubtags["x-py"] = new VariantSubtag("x-py", "Pinyin", false, null); s_variantSubtags["x-pyn"] = new VariantSubtag("x-pyn", "Pinyin Numbered", false, null); s_variantSubtags["x-audio"] = new VariantSubtag("x-audio", "Audio", false, null); }
/// <summary> /// Gets the language subtag with the specified code. /// </summary> /// <param name="code">The code.</param> /// <returns></returns> public static LanguageSubtag GetLanguageSubtag(string code) { if (string.IsNullOrEmpty(code)) throw new ArgumentNullException("code"); LanguageSubtag subtag; if (!s_languageSubtags.TryGetValue(code, out subtag)) subtag = new LanguageSubtag(code, null, true, null); return subtag; }
/// <summary> /// Initializes a new instance of the <see cref="T:LanguageSubtag"/> class. /// </summary> /// <param name="subtag">The subtag.</param> /// <param name="name">The name.</param> public LanguageSubtag(LanguageSubtag subtag, string name) : this(subtag.Code, name, subtag.IsPrivateUse, subtag.ISO3Code) { }
/// <summary> /// Gets the subtags of the specified language tag. /// </summary> /// <param name="langTag">The language tag.</param> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public static bool GetSubtags(string langTag, out LanguageSubtag languageSubtag, out ScriptSubtag scriptSubtag, out RegionSubtag regionSubtag, out VariantSubtag variantSubtag) { if (string.IsNullOrEmpty(langTag)) throw new ArgumentNullException("langTag"); languageSubtag = null; scriptSubtag = null; regionSubtag = null; variantSubtag = null; if (langTag.Any(c => !Char.IsLetterOrDigit(c) && c != '-')) { return false; } var cleaner = new Palaso.WritingSystems.Migration.Rfc5646TagCleaner(langTag); cleaner.Clean(); List<string> privateUseSubTags = new List<string>(cleaner.PrivateUse.Split(new char[] {'-'}, StringSplitOptions.RemoveEmptyEntries)); int privateUseSubTagIndex = 0; bool privateUsePrefix = false; string privateUseSubTag = null; int part = -1; string languageCode = cleaner.Language; if (string.IsNullOrEmpty(languageCode)) return false; if (languageCode.Equals("qaa", StringComparison.OrdinalIgnoreCase)) { // In our own WS dialog, we don't allow no language, but if it isn't a standard one, a language like xkal // produces an identifier like qaa-x-kal, and we interepret the first thing after the x as a private // language code (not allowed as the first three characters according to the standard). // If it's NOT a valid language code (e.g., too many characters), probably came from some other // program. Treating it as a language code will fail if we try to create such a writing system, // since we will detect the invalid language code. So only interpret the first element // after the x as a language code if it is a valid one. Otherwise, we just let qaa be the language. if (privateUseSubTags.Count > 0 && IsLanguageCodeValid(privateUseSubTags[0])) { languageSubtag = new LanguageSubtag(privateUseSubTags[0], "", true, null); privateUseSubTags.RemoveAt(0); } else languageSubtag = GetLanguageSubtag("qaa"); // We do allow just plain qaa. } else { languageSubtag = GetLanguageSubtag(languageCode); } string scriptCode = cleaner.Script; if (!string.IsNullOrEmpty(scriptCode)) { if (scriptCode.Equals("Qaaa", StringComparison.OrdinalIgnoreCase) && privateUseSubTags.Count > 0) { scriptSubtag = new ScriptSubtag(privateUseSubTags[0], "", true); privateUseSubTags.RemoveAt(0); } else scriptSubtag = GetScriptSubtag(scriptCode); } string regionCode = cleaner.Region; if (!string.IsNullOrEmpty(regionCode)) { if (regionCode.Equals("QM", StringComparison.OrdinalIgnoreCase) && privateUseSubTags.Count > 0) { regionSubtag = new RegionSubtag(privateUseSubTags[0], "", true); privateUseSubTags.RemoveAt(0); } else regionSubtag = GetRegionSubtag(regionCode); } var variantSb = new StringBuilder(); string variantCode = cleaner.Variant; if (!string.IsNullOrEmpty(variantCode)) { variantSb.Append(variantCode); } if (privateUseSubTags.Count > 0) { if (variantSb.Length > 0) variantSb.Append("-"); variantSb.Append("x"); foreach (var item in privateUseSubTags) { variantSb.Append("-"); variantSb.Append(item); } } variantCode = variantSb.ToString(); if (!string.IsNullOrEmpty(variantCode)) { variantSubtag = GetVariantSubtag(variantCode); } return true; }
/// <summary> /// Generates an ICU locale from the specified language tag subtags. /// </summary> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public static string ToIcuLocale(LanguageSubtag languageSubtag, ScriptSubtag scriptSubtag, RegionSubtag regionSubtag, VariantSubtag variantSubtag) { if (languageSubtag == null) throw new ArgumentNullException("languageSubtag"); var sb = new StringBuilder(); //start with the LanguageCode if (languageSubtag.IsPrivateUse) sb.Append("x"); sb.Append(languageSubtag.Code); //now add the Script if it exists if (scriptSubtag != null) sb.AppendFormat("_{0}", scriptSubtag.Code); //now add the Region if it exists if (regionSubtag != null) sb.AppendFormat("_{0}", regionSubtag.Code); // if variantCode is notNullofEmpty then add it // and if CountryCode is empty add two underscores instead of one. if (variantSubtag != null) { string icuVariant = null; // convert language tag variants to known ICU variants // TODO: are there any more ICU variants? switch (variantSubtag.Code) { case "fonipa": icuVariant = "IPA"; break; case "fonipa-x-etic": icuVariant = "X_ETIC"; break; case "fonipa-x-emic": icuVariant = "X_EMIC"; break; case "pinyin": icuVariant = "X_PY"; break; } if (!string.IsNullOrEmpty(icuVariant)) sb.AppendFormat(regionSubtag == null ? "__{0}" : "_{0}", icuVariant); } return sb.ToString(); }
/// <summary> /// Generates a language tag from the specified subtags. /// </summary> /// <param name="languageSubtag">The language subtag.</param> /// <param name="scriptSubtag">The script subtag.</param> /// <param name="regionSubtag">The region subtag.</param> /// <param name="variantSubtag">The variant subtag.</param> /// <returns></returns> public static string ToLangTag(LanguageSubtag languageSubtag, ScriptSubtag scriptSubtag, RegionSubtag regionSubtag, VariantSubtag variantSubtag) { if (languageSubtag == null) throw new ArgumentNullException("languageSubtag"); var sb = new StringBuilder(); // Insert non-custom language, script, region into main part of code. if (languageSubtag.IsPrivateUse) { sb.Append("qaa"); } else { sb.Append(languageSubtag.Code); } var isCustomScript = false; if (scriptSubtag != null) { sb.Append("-"); // Qaaa is our flag to expect a script in private-use. If the actual value is Qaaa, we need to treat it as custom, // so we don't confuse some other private-use tag with a custom script. isCustomScript = TreatAsCustomScript(scriptSubtag.Code); if (isCustomScript) sb.Append("Qaaa"); else sb.Append(scriptSubtag.Code); } var isCustomRegion = false; if (regionSubtag != null) { sb.Append("-"); // QM is our flag to expect a region in private-use. If the actual value is QM, we need to treat it as custom, // so we don't confuse some other private-use tag with a custom region. isCustomRegion = TreatAsCustomRegion(regionSubtag.Code); if (isCustomRegion) sb.Append("QM"); else sb.Append(regionSubtag.Code); } string standardVariant = ""; string privateUse = ""; if (variantSubtag != null) privateUse = GetPrivateUseAndStandardVariant(variantSubtag.Code, out standardVariant); if (standardVariant != "") { sb.Append("-"); sb.Append(standardVariant); } // Insert custom language, script, or variant into private=use. bool inPrivateUse = false; if (languageSubtag.IsPrivateUse) { sb.Append("-"); if (!inPrivateUse) { inPrivateUse = true; sb.Append("x-"); } sb.Append(languageSubtag.Code); } if (isCustomScript) { sb.Append("-"); if (!inPrivateUse) { inPrivateUse = true; sb.Append("x-"); } sb.Append(scriptSubtag.Code); } if (isCustomRegion) { sb.Append("-"); if (!inPrivateUse) { inPrivateUse = true; sb.Append("x-"); } sb.Append(regionSubtag.Code); } else if (languageSubtag.Code == "zh" && languageSubtag.ISO3Code == "cmn" && regionSubtag == null) { sb.Append("-CN"); } if (privateUse != "") { sb.Append("-"); if (!inPrivateUse) sb.Append("x-"); sb.Append(privateUse); } return sb.ToString(); }
/// <summary> /// Setups the dialog. /// </summary> /// <param name="languageSubtag">The language subtag.</param> /// <param name="displayRelatedWss">if set to <c>true</c> related writing systems will be displayed.</param> public void SetupDialog(LanguageSubtag languageSubtag, bool displayRelatedWss) { CheckDisposed(); RegionSubtag region = null; if (languageSubtag.Code == "zh" && languageSubtag.ISO3Code == "cmn") region = new RegionSubtag("CN", "China", false); SetupDialog(m_wsManager.Create(languageSubtag, null, region, null), null, displayRelatedWss); }