/// <summary> /// serialize the language definitions to temporary files, so we don't clobber the ones /// used by the application or other tests. /// </summary> /// <param name="finalLangDef"></param> protected override void Serialize(LanguageDefinition finalLangDef) { if (m_cache.LanguageWritingSystemFactoryAccessor.BypassInstall) SerializeToTempfile(finalLangDef); else base.Serialize(finalLangDef); }
public void GetAbbreviationsNameOnly() { LanguageDefinition langDef = new LanguageDefinition(m_wsEn); langDef.XmlWritingSystem.WritingSystem.IcuLocale = "en"; Assert.AreEqual("en", langDef.LocaleAbbr); Assert.AreEqual("", langDef.CountryAbbr); Assert.AreEqual("", langDef.VariantAbbr); }
/// ---------------------------------------------------------------------------------------- /// <summary> /// For a given LanguageDefinition, if the ValidChars field is empty then try to get a set /// of ExemplarCharacters (valid characters) from ICU for this language. /// </summary> /// <param name="langDef"></param> /// <param name="cpe">A character property engine (needed for normalization).</param> /// ---------------------------------------------------------------------------------------- public static void TryLoadValidCharsIfEmpty(LanguageDefinition langDef, ILgCharacterPropertyEngine cpe) { //Try to load the ValidChars if none have been loaded yet. if (string.IsNullOrEmpty(langDef.ValidChars)) { string IcuLocale = (langDef.BaseLocale ?? langDef.LocaleAbbr); langDef.ValidChars = GetValidCharsForLocale(IcuLocale, cpe); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void SetupEthnologueCode(LanguageDefinition langDef) { string strNone = FwCoreDlgs.kstidNone; if (langDef.EthnoCode != null && langDef.EthnoCode.Length > 0) { SetLanguageCodeLabels(langDef.EthnoCode); } else { SqlConnection dbConnection = null; SqlCommand sqlCommand = null; string sConnection = string.Format("Server={0}; Database=Ethnologue; User ID=FWDeveloper; " + "Password=careful; Pooling=false;", MiscUtils.LocalServerName); dbConnection = new SqlConnection(sConnection); dbConnection.Open(); sqlCommand = dbConnection.CreateCommand(); // REVIEW (SteveMiller): Isn't there a better way to get the output variable // than to do the IF and SELECT in dynamic SQL code? Seems like there should // be something in C# that would do this. sqlCommand.CommandText = string.Format("declare @EthnoCode nchar(3); " + "exec GetIsoCode '{0}', @EthnoCode output; " + "if @EthnoCode is not null select @EthnoCode", langDef.LocaleAbbr); SqlDataReader reader = sqlCommand.ExecuteReader(System.Data.CommandBehavior.Default); if (reader.HasRows) { reader.Read(); SetLanguageCodeLabels(reader.GetString(0)); langDef.EthnoCode = reader.GetString(0); } else { SetLanguageCodeLabels(strNone); } reader.Close(); dbConnection.Close(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void SavePUACheckedChars(LanguageDefinition langDef) { if (m_lstPUACharacters.Items.Count == 0) return; ValidCharacters validChars = ValidCharacters.Load(langDef); if (validChars == null) return; // First clear out any characters in the PUA list for the writing system // unless they are still in the list of checked items. // Also remove them from the valid characters list. foreach (PuaListItem puaItem in m_lstPUACharacters.Items) { if (!m_lstPUACharacters.CheckedItems.Contains(puaItem)) { langDef.RemovePuaDefinition(puaItem.PUAChar.CharDef); char c = (char)puaItem.PUAChar.Character; validChars.RemoveCharacter(c.ToString()); } } // Add the characters which are checked to the PUA list for the writing system and // the valid characters list. foreach (PuaListItem puaItem in m_lstPUACharacters.CheckedItems) { langDef.AddPuaDefinition(puaItem.PUAChar.CharDef); // Now add the character to the valid characters list if it is not a diacritic // or some other category that is disallowed in the valid characters list. string chr = ((char)puaItem.PUAChar.Character).ToString(); ValidCharacterType chrType = langDef.GetOverrideCharType(chr); if (chrType != ValidCharacterType.None) validChars.AddCharacter(chr, chrType); } // Put the updated valid characters back into the final lang. definition. langDef.ValidChars = validChars.XmlString; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void SaveICUrules(LanguageDefinition langDef) { if (txtIcuRules.Enabled) { ICollation coll = UseOrCreateCollation(langDef); coll.IcuRules = txtIcuRules.Text; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged /// resources; <c>false</c> to release only unmanaged resources. /// </param> /// ------------------------------------------------------------------------------------ protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; if (disposing) { // release managed objects if (components != null) components.Dispose(); if (m_fwTextBoxTestWs != null) m_fwTextBoxTestWs.Dispose(); // We may have made the cache from COM objects given to us by a COM client. // In that case, we have to dispose it. if (m_cacheMadeLocally && m_cache != null) m_cache.Dispose(); if (m_langDefCurrent != null) m_langDefCurrent.ReleaseRootRb(); if (cbDictionaries != null) cbDictionaries.Dispose(); } // release unmanaged objects regardless of disposing flag if (m_fwt != null && Marshal.IsComObject(m_fwt)) { System.Runtime.InteropServices.Marshal.ReleaseComObject(m_fwt); m_fwt = null; } if (m_strmLog != null && Marshal.IsComObject(m_strmLog)) { System.Runtime.InteropServices.Marshal.ReleaseComObject(m_strmLog); m_strmLog = null; } PUACharacter.ReleaseTheCom(); // Garbage collect the cached ICU m_cachedIcu = null; // GC.Collect(); Can't be deterministic about when it happens, even by calling for a collection. m_langDefCurrent = null; m_fwTextBoxTestWs = null; cbDictionaries = null; base.Dispose(disposing); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected void btnRemove_Click(object sender, EventArgs e) { // if we're removing from the end of the list, the new index will be the previous one, // otherwise, keep the index the same. int indexNext = m_listBoxRelatedWSs.SelectedIndex == m_listBoxRelatedWSs.Items.Count - 1 ? m_listBoxRelatedWSs.SelectedIndex - 1 : m_listBoxRelatedWSs.SelectedIndex; m_listOrigLangDefs.Remove(m_langDefCurrent); m_listFinalLangDefs.Remove(m_langDefCurrent); PopulateRelatedWSsListBox(); m_langDefCurrent = m_listFinalLangDefs[indexNext]; SetupDialogFromCurrentLanguageDefinition(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected virtual void ShowMsgTooBadWsAlreadyInDb(LanguageDefinition finalLangDef, string origIcuLocale, string strExisting) { string msg = string.Format(FwCoreDlgs.kstidTooBadWsAlreadyInDb, strExisting, finalLangDef.WritingSystem.IcuLocale, origIcuLocale); MessageBox.Show(msg, FwCoreDlgs.kstidWspLabel, MessageBoxButtons.OK); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Tests can override this to specify a temp location to store the output. /// </summary> /// <param name="finalLangDef"></param> /// ------------------------------------------------------------------------------------ protected virtual void Serialize(LanguageDefinition finalLangDef) { finalLangDef.Serialize(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void Set_regionVariantControl(LanguageDefinition langDef) { m_fUserChangedVariantControl = false; m_regionVariantControl.LangDef = langDef; m_fUserChangedVariantControl = true; m_FullCode.Text = langDef.CurrentFullLocale(); m_regionVariantControl.PropDlg = true; LoadShortWsNameFromCurrentLanguageDefn(); rbLeftToRight.Checked = !langDef.WritingSystem.RightToLeft; rbRightToLeft.Checked = langDef.WritingSystem.RightToLeft; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Save the selected encoding converter /// </summary> /// ------------------------------------------------------------------------------------ protected void Save_cbEncodingConverter(LanguageDefinition langdef) { // save the selected encoding converter string str = cbEncodingConverter.SelectedItem as string; if (str == FwCoreDlgs.kstidNone) str = null; Debug.Assert(str == null || !str.Contains(FwCoreDlgs.kstidNotInstalled)); langdef.WritingSystem.LegacyMapping = str; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the "invalid" character as a valid character. /// </summary> /// <param name="addedCharError">The checking error containing the character that will /// be added to the valid character inventory.</param> /// ------------------------------------------------------------------------------------ private void AddAsValidCharacter(CheckingError addedCharError) { Debug.Assert(addedCharError.CheckId == StandardCheckIds.kguidCharacters, "Checking error should be from the valid characters check"); ILgWritingSystemFactory lgwsf = m_cache.LanguageWritingSystemFactoryAccessor; int hvoWs = m_cache.DefaultVernWs; IWritingSystem ws = lgwsf.get_EngineOrNull(hvoWs); LanguageDefinition langDef = new LanguageDefinition(ws); LgWritingSystem lgWs = new LgWritingSystem(m_cache, hvoWs); langDef.ValidChars = ws.ValidChars; if (StringUtils.IsCharacterDefined(addedCharError.CitedText)) { using (new WaitCursor(Parent)) { // Get the valid characters from the database ValidCharacters validChars = ValidCharacters.Load(langDef); if (validChars != null) { validChars.AddCharacter(addedCharError.CitedText); ws.ValidChars = langDef.ValidChars = validChars.XmlString; StringUtils.UpdatePUACollection(langDef, validChars.AllCharacters); ws.SaveIfDirty(m_cache.DatabaseAccessor); langDef.Serialize(); } // Mark all data grid view rows containing the newly-defined valid character to irrelevant. for (int iRow = 0; iRow < m_list.Count; iRow++) { CheckingError checkError = GetCheckingError(iRow); if (((StTxtPara)checkError.QuoteOA.ParagraphsOS[0]).Contents.Text == addedCharError.CitedText) { // We don't want to create an undoable action, so we suppress subtasks. using (SuppressSubTasks supressActionHandler = new SuppressSubTasks(m_cache, true)) checkError.Status = CheckingStatus.StatusEnum.Irrelevant; } } IsStale = true; m_dataGridView.Invalidate(); } } else { string msg = ResourceHelper.GetResourceString("kstidUndefinedCharacterMsg"); MessageBox.Show(this, msg, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information); } }
/// <summary> /// Create a New LanguageDefinition and inherit its general data from the current language definition. /// </summary> /// <param name="wsf"></param> /// <param name="langDef"></param> /// <returns></returns> public ILanguageDefinition CreateNewFrom(ILgWritingSystemFactory wsf, LanguageDefinition langDef) { LanguageDefinition newLangDef = CreateNew(wsf) as LanguageDefinition; newLangDef.LocaleName = langDef.LocaleName; newLangDef.SetEthnologueCode(langDef.EthnoCode, langDef.LocaleName); newLangDef.LocaleAbbr = langDef.LocaleAbbr; newLangDef.ValidChars = langDef.ValidChars; newLangDef.MatchedPairs = langDef.MatchedPairs; newLangDef.PunctuationPatterns = langDef.PunctuationPatterns; newLangDef.CapitalizationInfo = langDef.CapitalizationInfo; newLangDef.QuotationMarks = langDef.QuotationMarks; newLangDef.LoadDefaultICUValues(); newLangDef.FinishedInitializing(); return newLangDef; }
/// ----------------------------------------------------------------------------------- /// <summary> /// Check if we can go to next tab. /// </summary> /// ----------------------------------------------------------------------------------- protected override bool ValidToGoForward() { if (CurrentStepNumber != 1) return true; // Don't leave the region/variant page if we don't have valid data. if (!m_regionVariantControl.CheckValid()) return false; string caption = FwCoreDlgs.kstidNwsCaption; string strLoc = m_langDef.WritingSystem.IcuLocale; // Catch case where we are going to overwrite an existing writing system in the Db. if (m_langDef.IsWritingSystemInDb()) { ILgWritingSystemFactory wsf = m_langDef.XmlWritingSystem.WritingSystem.WritingSystemFactory; int defWs = wsf.UserWs; int ws = wsf.GetWsFromStr(strLoc); IWritingSystem qws = wsf.get_EngineOrNull(ws); string strDispName = qws.get_UiName(defWs); string msg = string.Format(FwCoreDlgs.kstidCantOverwriteWsInDb, strDispName, strLoc, Environment.NewLine, m_langDef.DisplayName); MessageBox.Show(msg, caption, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return false; } // Catch case where we are going to overwrite an existing LD.xml file. // This should be avoided by the callers to this dialog, but just in case, we'll // handle it here as well. if (m_langDef.IsLocaleInLanguagesDir()) { string msg = string.Format(FwCoreDlgs.kstidLocaleAlreadyInLanguages, m_langDef.DisplayName, m_langDef.WritingSystem.IcuLocale, Environment.NewLine); DialogResult dr = MessageBox.Show(msg, FwCoreDlgs.ksWsAlreadyExists, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); // If the user cancels, we don't leave the dialog. if (dr == DialogResult.Yes) { // We need to load the existing LD.xml file and then write it out to the // database, overwriting the original writing system. We then close the wizard. try { m_langDef = null; LanguageDefinitionFactory ldf = new LanguageDefinitionFactory(); m_langDef = ldf.InitializeFromXml(m_wsf, strLoc) as LanguageDefinition; Debug.Assert(m_langDef != null); if (m_langDef != null) { m_langDef.SaveWritingSystem(strLoc); } DialogResult = DialogResult.OK; Visible = false; } catch { MessageBox.Show(FwCoreDlgs.kstidErrorSavingWs, caption, MessageBoxButtons.OK, MessageBoxIcon.Error); DialogResult = DialogResult.Cancel; Visible = false; } } return false; } return true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected virtual DialogResult ShowMsgLocaleAlreadyInLanguages(LanguageDefinition finalLangDef) { string msg = string.Format(FwCoreDlgs.kstidLocaleAlreadyInLanguages, finalLangDef.DisplayName, finalLangDef.WritingSystem.IcuLocale, Environment.NewLine); DialogResult dr = MessageBox.Show(msg, FwCoreDlgs.kstidWspLabel, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); return dr; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected virtual DialogResult ShowMsgWsAlreadyInDb(LanguageDefinition finalLangDef, string origIcuLocale, string strExisting, IWritingSystem wsOld) { string msg = string.Format(FwCoreDlgs.kstidWsAlreadyInDb, strExisting, finalLangDef.WritingSystem.IcuLocale, origIcuLocale, wsOld.LanguageName, Environment.NewLine); using (MergeToExistingWsDlg dlg = new MergeToExistingWsDlg(m_helpTopicProvider)) { dlg.Initialize(msg, m_app); dlg.ShowDialog(this); return dlg.DialogResult; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <returns>true if the two LanguageDefinitions' PuaDefinitions are the same</returns> /// ------------------------------------------------------------------------------------ private static bool ComparePuaDefinitions(LanguageDefinition originalLangDef, LanguageDefinition finalLangDef) { //determine if originalLangDef.PuaDefinitions==null before this.... if (originalLangDef.PuaDefinitions == null && finalLangDef.PuaDefinitions == null) { return true; } else if ((originalLangDef.PuaDefinitions == null && finalLangDef.PuaDefinitions != null) || (originalLangDef.PuaDefinitions != null && finalLangDef.PuaDefinitions == null)) { return false; } //it is safe to perform further checks else if (originalLangDef.PuaDefinitions.Length != finalLangDef.PuaDefinitions.Length) { return false; } else { for (int j = 0; j < originalLangDef.PuaDefinitions.Length; j++) { if (!originalLangDef.PuaDefinitions[j].Equals(finalLangDef.PuaDefinitions[j])) return false; } } return true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private bool IsNew(LanguageDefinition langDef) { // the givin language definition is new if its object is in both // the original list and the final list. int indexInFinalLangDefs = m_listFinalLangDefs.IndexOf(langDef); int indexInOrigLangDefs = m_listOrigLangDefs.IndexOf(langDef); return indexInOrigLangDefs != -1 && indexInFinalLangDefs != -1; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="originalLangDef"></param> /// <param name="finalLangDef"></param> /// <returns>true if the two LanguageDefinitions' IcuLocale are the same</returns> /// ------------------------------------------------------------------------------------ private static bool CompareIcuLocale(LanguageDefinition originalLangDef, LanguageDefinition finalLangDef) { string oldIcuLocale = originalLangDef.WritingSystem.IcuLocale; string newIcuLocale = finalLangDef.WritingSystem.IcuLocale; //I suppose this is what we really want to check for the name change???? return oldIcuLocale.Equals(newIcuLocale); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void AddLangDefinition(LanguageDefinition newLangDef, bool fSwitchToGeneralTab) { SaveCurrentLangDef(); // add the new language definition to our language definitions. // Note: we'll add the same object to original and final definitions to indicate these are new // and will always be equivalent in comparisons. m_listOrigLangDefs.Add(newLangDef); m_listFinalLangDefs.Add(newLangDef); // make this new current language def. m_langDefCurrent = newLangDef; PopulateRelatedWSsListBox(); SetupDialogFromCurrentLanguageDefinition(); if (fSwitchToGeneralTab) { try { // switch to General tab to allow the user to make the current ws valid but don't do context checking. m_fSkipCheckOkToChangeContext = true; SwitchTab(kWsGeneral); } finally { m_fSkipCheckOkToChangeContext = false; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="originalLangDef"></param> /// <param name="finalLangDef"></param> /// <returns>true if the two LanguageDefinitions' SpellCheckDictionary are the same</returns> /// ------------------------------------------------------------------------------------ private static bool CompareSpellDictionary(LanguageDefinition originalLangDef, LanguageDefinition finalLangDef) { string oldSpellDictionary = originalLangDef.WritingSystem.SpellCheckDictionary; string newSpellDictionary = finalLangDef.WritingSystem.SpellCheckDictionary; //I suppose this is what we really want to check for the name change???? return oldSpellDictionary.Equals(newSpellDictionary); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private LanguageDefinition EstablishCurrentLangDefFromSelectedIndex() { m_langDefCurrentIndex = m_listBoxRelatedWSs.SelectedIndex; m_langDefCurrent = m_listFinalLangDefs[m_langDefCurrentIndex]; m_listBoxRelatedWSs.Focus(); UpdateListBoxButtons(); return m_langDefCurrent; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private static bool CompareIcuRules(LanguageDefinition originalLangDef, LanguageDefinition finalLangDef) { return GetIcuRules(originalLangDef) == GetIcuRules(finalLangDef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private static ICollation UseOrCreateCollation(LanguageDefinition langDef) { ICollation coll = null; if (langDef.WritingSystem.CollationCount > 0) coll = langDef.WritingSystem.get_Collation(0); if (coll == null) coll = CollationClass.Create(); langDef.WritingSystem.set_Collation(0, coll); return coll; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="langDef"></param> /// <returns>icuRules string for first collation, or empty string if no icu rules were found for given language definition</returns> /// ------------------------------------------------------------------------------------ protected static string GetIcuRules(LanguageDefinition langDef) { string icuRules = ""; if (langDef.WritingSystem.CollationCount > 0) icuRules = langDef.WritingSystem.get_Collation(0).IcuRules; if (icuRules == null) icuRules = ""; return icuRules; }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private void SetupSortTab(LanguageDefinition langDef) { if (m_langDefCurrent.BaseLocale != null) { btnSimilarWs.SelectedLocaleId = m_langDefCurrent.BaseLocale; } else { System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(WritingSystemPropertiesDialog)); // apply default text btnSimilarWs.Text = (string)resources.GetObject("btnSimilarWs.Text"); } SetupICURulesAndBtnSimilarWs(); // Copy the ICU rules from the first collation if it exists. if (langDef.WritingSystem.CollationCount > 0) { string icuRules = GetIcuRules(langDef); if (txtIcuRules.Enabled) txtIcuRules.Text = icuRules; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ private LanguageDefinition ReloadLangDefFromExistingLangDefInLanguageDir(LanguageDefinition langDef) { ILgWritingSystemFactory qwsf = langDef.WritingSystem.WritingSystemFactory; Debug.Assert(langDef.IcuLocaleOriginal != langDef.WritingSystem.IcuLocale); string origIcuLocale = langDef.IcuLocaleOriginal; string locale = langDef.WritingSystem.IcuLocale; langDef.ReleaseRootRb(); // Ensure this is clear before setting to null. int indexToReplace = FinalLanguageDefns.IndexOf(langDef); langDef = null; langDef = CreateLanguageDefFromXml(qwsf, locale); Debug.Assert(langDef.IcuLocaleOriginal == langDef.WritingSystem.IcuLocale); langDef.IcuLocaleTarget = origIcuLocale; // replace the existing language definition with this one. Debug.Assert(langDef != null); FinalLanguageDefns.RemoveAt(indexToReplace); FinalLanguageDefns.Insert(indexToReplace, langDef); if (indexToReplace == m_langDefCurrentIndex) { EstablishCurrentLangDefFromSelectedIndex(); SetupDialogFromCurrentLanguageDefinition(); } return langDef; }
/// <summary> /// Adds the default word-forming character overrides to the list of valid /// characters for each vernacular writing system that is using the old /// valid characters representation. /// </summary> /// <param name="cache">The cache.</param> void AddDefaultWordformingOverridesIfNeeded(FdoCache cache) { ILgWritingSystemFactory lgwsf = cache.LanguageWritingSystemFactoryAccessor; foreach (ILgWritingSystem wsObj in cache.LangProject.VernWssRC) { IWritingSystem ws = lgwsf.get_EngineOrNull(wsObj.Hvo); string validCharsSrc = ws.ValidChars; if (!ValidCharacters.IsNewValidCharsString(validCharsSrc)) { LanguageDefinition langDef = new LanguageDefinition(ws); ValidCharacters valChars = ValidCharacters.Load(langDef); valChars.AddDefaultWordformingCharOverrides(); ws.ValidChars = langDef.ValidChars = valChars.XmlString; using (new SuppressSubTasks(cache)) { ws.SaveIfDirty(cache.DatabaseAccessor); } langDef.Serialize(); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected virtual bool IsLocaleInLanguagesDir(LanguageDefinition finalLangDef) { return finalLangDef.IsLocaleInLanguagesDir(); }