private static Set<NamedWritingSystem> GetNamedWritingSystemsFromLDFs(ILgWritingSystemFactory wsf,
string[] fileList, Set<NamedWritingSystem> namedWritingSystems)
{
Set<string> names = new Set<string>();
foreach (NamedWritingSystem nws in namedWritingSystems)
names.Add(nws.IcuLocale);
// Now add the ones from the XML files.
foreach (string pathname in fileList)
{
string[] bits = pathname.Split('\\');
string filename = bits[bits.Length - 1];
bits = filename.Split('.');
string icuLocale = bits[0]; // Name up to first '.'.
// The first test excludes names like en.xml1.
if (bits[1] == "xml" && !names.Contains(icuLocale.ToLowerInvariant()))
{
try
{
// This will get the language name from the XML language def. file. This
// should be the same name the user chose to call the language when creating
// its writing system.
LanguageDefinitionFactory ldf = new LanguageDefinitionFactory(wsf, icuLocale);
if (ldf.LanguageDefinition == null)
{
System.Diagnostics.Debug.WriteLine("The XML file for " + icuLocale +
" did not parse properly.");
}
else
{
string displayName = ldf.LanguageDefinition.DisplayName;
// REVIEW: These two lines are how we used to get the display name. Now we read
// it from the language def. file (i.e. the .xml file). Will the name from the
// XML file always be in the display locale?
//Icu.UErrorCode err;
//Icu.GetDisplayName(icuLocale, displayLocale, out displayName, out err);
// If it can't find a name, the normal behavior is to return the icuLocale.
// If that happens we leave this one out.
// If anything worse happens (e.g., that might produce a bad error code),
// the other checks we make here should detect it.
if (displayName != null && displayName != icuLocale && displayName.Length != 0)
namedWritingSystems.Add(new NamedWritingSystem(displayName, icuLocale));
}
}
catch (FileNotFoundException e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
// LanguageDefinitionFactory can throw this error. Just ignore it.
}
}
}
return namedWritingSystems;
}
public void PopulateFromLanguageClass()
{
//Extracts the locale filename from a given path
int icuName = m_inputFilename.LastIndexOf("\\");
string icuPortion = m_inputFilename.Substring(icuName+1);
//Appears this maps the XML file to a LanguageDefinition class
/////////////////
ILgWritingSystemFactory wsf = LgWritingSystemFactoryClass.Create();
LanguageDefinitionFactory langDefFactory = new LanguageDefinitionFactory(wsf, icuPortion);
LanguageDefinition langDef = langDefFactory.InitializeFromXml(wsf, icuPortion) as LanguageDefinition;
if (langDef == null)
{
throw new Exception("Unable to read and parse the input XML file " + m_inputFilename);
}
/////////////////
int i=0;
int cpua = langDef.PuaDefinitionCount;
// if we have PUA characters in the LD file make an array of PUACharacters. But be careful
// to handle invalid definitions gracefully.
if (langDef.PuaDefinitions != null && cpua != 0)
{
puaChars = new PUACharacter[cpua];
foreach (CharDef charDef in langDef.PuaDefinitions)
{
try
{
puaChars[i] = new PUACharacter(charDef);
++i;
}
catch
{
}
}
}
if (i < cpua)
{
if (i == 0)
{
puaChars = null;
}
else
{
PUACharacter[] puaGoodChars = new PUACharacter[i];
for (int ic = 0; ic < i; ++ic)
puaGoodChars[ic] = puaChars[ic];
puaChars = puaGoodChars;
}
if (LogFile.IsLogging())
LogFile.AddErrorLine("Warning, " + (cpua - i) + " out of " + cpua +
" PUA character definitions are invalid.");
}
baseLocale = langDef.BaseLocale;
newLocale = langDef.XmlWritingSystem.WritingSystem.IcuLocale;
localeResources = langDef.LocaleResources;
// Get the collation elements, whether from the CollationElements element directly,
// or from the WritingSystem element.
collationElements = langDef.CollationElements;
if (collationElements == null)
{
IWritingSystem lws = langDef.WritingSystem;
int ccoll = lws.CollationCount;
if (ccoll > 0)
collationElements = lws.get_Collation(0).IcuRules;
}
localeWinLCID = langDef.XmlWritingSystem.WritingSystem.Locale.ToString();
// make sure the newlocale has the proper case for each property:
// lang, country and variant
InstallLanguage.LocaleParser lp = new LocaleParser(newLocale);
newLocale = lp.Locale;
// Make sure the display names [Name, Country & Variant] have Unicode characters
// greater than 7F converted to the \uxxxx format where xxxx is the unicode
// hex value of the character.
localeName = ConvertToUnicodeNotation(langDef.LocaleName);
localeScript = ConvertToUnicodeNotation(langDef.LocaleScript);
localeCountry = ConvertToUnicodeNotation(langDef.LocaleCountry);
localeVariant = ConvertToUnicodeNotation(langDef.LocaleVariant);
// Save the multilingual names of the writing system, together with the
// ICU locale for each name.
NameMultiUnicode rgName = langDef.XmlWritingSystem.Name;
int cws = rgName.Count;
// If we don't have a name, use the IcuLocale rather than going without a name.
// Otherwise it won't register as a language in en.txt/res.
if (cws == 0)
{
StringWithWs sw = new StringWithWs(langDef.XmlWritingSystem.WritingSystem.IcuLocale, "en");
rgName.Add(sw);
cws = 1;
}
m_rgNames = new System.Collections.ArrayList(cws);
for (int iws = 0; iws < cws; ++iws)
{
StringWithWs x = rgName[iws];
m_rgNames.Add(x);
}
// TODO - dlh
// Once collationElements are handled, something will have to be checked there
// as the current implementation assumes that it's in the valid format.
wsf.Shutdown(); // This is (always) needed to balance creating the factory.
}
/// -----------------------------------------------------------------------------------
/// <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>
/// Set writing system and initialize some values for the dialog
/// </summary>
/// <param name="wsSelected">The writing system.</param>
/// <returns><c>true</c> if successful, <c>false</c> if something went wrong.</returns>
/// ------------------------------------------------------------------------------------
internal protected bool TrySetupDialog(IWritingSystem wsSelected)
{
// for now, always set the displayWs to "en" so we read good information from LDFs (LT-8628)
//m_displayWs = wsSelected.WritingSystemFactory.UserWs;
m_displayWs = wsSelected.WritingSystemFactory.get_Engine("en").WritingSystem;
LoadAvailableConverters();
m_LanguageDefinitionFactory = new LanguageDefinitionFactory();
m_NamedWritingSystemsDb = m_cache.LangProject.GetDbNamedWritingSystems();
//set up the initial state of the following lists
CreateLanguageDefinitionsFromNamedWss(m_listOrigLangDefs, wsSelected);
CreateLanguageDefinitionsFromNamedWss(m_listFinalLangDefs, wsSelected);
PopulateRelatedWSsListBox();
int selectedIndex = IndexOfFinalLangDef(wsSelected.IcuLocale);
SelectIndexOfListBoxRelatedWss(selectedIndex);
EstablishCurrentLangDefFromSelectedIndex();
SetupDialogFromCurrentLanguageDefinition();
m_fNewRendering = false;
return true;
}
/// <summary>
/// creates a clone of the current object.
/// </summary>
/// <returns></returns>
object ICloneable.Clone()
{
LanguageDefinition clonedLangDef = null;
using (MemoryStream stream = new MemoryStream())
{
using (XmlTextWriter xtw = new XmlTextWriter(stream, Encoding.UTF8))
{
Serialize(xtw);
xtw.Flush();
stream.Seek(0, SeekOrigin.Begin);
using (XmlReader sr = XmlReader.Create(stream))
{
LanguageDefinitionFactory ldf = new LanguageDefinitionFactory();
ldf.Deserialize(sr);
clonedLangDef = ldf.LanguageDefinition as LanguageDefinition;
clonedLangDef.m_icuLocaleOrig = this.m_icuLocaleOrig;
}
}
}
return clonedLangDef;
}
public void SerializeAndDeserialize()
{
IWritingSystem ws = m_wsf.get_Engine("tl");
int wsIdTl = m_wsf.GetWsFromStr("tl");
ws.Locale = 13321;
ws.DefaultMonospace = "Courier New";
ws.DefaultSansSerif = "Arial";
ws.DefaultBodyFont = "Charis SIL";
ws.DefaultSerif = "Times New Roman";
ws.set_Name(m_wsIdEn, "Tagalog");
ws.set_Name(wsIdTl, "Tagalog");
ws.set_Abbr(m_wsIdEn, "TGL");
ICollation coll = CollationClass.Create();
coll.WinLCID = 1033;
coll.WinCollation = "Latin1_General_CI_AI";
coll.set_Name(m_wsIdEn, "Default Collation");
coll.WritingSystemFactory = m_wsf;
ws.set_Collation(0, coll);
LanguageDefinition langDef = new LanguageDefinition(ws);
langDef.BaseLocale = "en_US";
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "tl";
langDef.LocaleName = "Tagalog";
langDef.LocaleScript = "";
langDef.LocaleCountry = "";
langDef.LocaleVariant = "";
langDef.XmlWritingSystem.WritingSystem.Locale = 13321;
langDef.CollationElements = "\"& B < ...";
langDef.ValidChars = "abcdefg";
langDef.LocaleResources = @"
zoneStrings {
{
'Europe/London',
'Greenwich Mean Time',
}
}" ;
CharDef[] charDefs = new CharDef[2];
charDefs[0] = new CharDef(0xF170, "COMBINING SNAKE BELOW;Mn;202;NSM;;;;");
charDefs[1] = new CharDef(0xF210, "LATIN SMALL LETTER P WITH STROKE;Ll;0;L;;;;");
langDef.PuaDefinitions = charDefs;
FileName[] fonts = new FileName[4];
fonts[0] = new FileName("arial.ttf");
fonts[1] = new FileName("arialbd.ttf");
fonts[2] = new FileName("ariali.ttf");
fonts[3] = new FileName("arialbi.ttf");
langDef.Fonts = fonts;
langDef.Keyboard = new FileName("Tagalog.kmx");
langDef.EncodingConverter = new EncodingConverter("SIL_IPA93.tec.vbs", "SIL-IPA93.tec");
string tmpFileName = Path.GetTempFileName();
langDef.Serialize(tmpFileName);
LanguageDefinitionFactory otherIcuWs = new LanguageDefinitionFactory();
LanguageDefinitionFactory.WritingSystemFactory = m_wsf;
otherIcuWs.Deserialize(tmpFileName);
ILanguageDefinition newLangDef = otherIcuWs.LanguageDefinition;
IWritingSystem deserializedWs = newLangDef.WritingSystem;
ICollation deserializedColl = newLangDef.GetCollation(0);
StreamReader reader = new StreamReader(tmpFileName);
string line = reader.ReadLine();
while (line != null)
{
Console.WriteLine(line);
line = reader.ReadLine();
}
reader.Close();
File.Delete(tmpFileName);
Assert.AreEqual(ws.Locale, deserializedWs.Locale);
Assert.AreEqual(ws.IcuLocale, deserializedWs.IcuLocale);
Assert.AreEqual(ws.DefaultSansSerif, deserializedWs.DefaultSansSerif);
Assert.AreEqual(ws.DefaultBodyFont, deserializedWs.DefaultBodyFont);
Assert.AreEqual(ws.get_Name(m_wsIdEn), deserializedWs.get_Name(m_wsIdEn));
Assert.AreEqual(coll.WinLCID, deserializedColl.WinLCID);
Assert.AreEqual(coll.WinCollation, deserializedColl.WinCollation);
// ENHANCE: Add ValidChars to the interface
// Assert.AreEqual(ws.ValidChars, deserializedWs.ValidChars);
Assert.AreEqual(coll.get_Name(m_wsIdEn), deserializedColl.get_Name(m_wsIdEn));
}
private LanguageDefinition CreateTempLanguageDefinitionFileFromWs(int hvoWs)
{
IWritingSystem ws = m_inMemoryCache.Cache.LanguageWritingSystemFactoryAccessor.get_EngineOrNull(hvoWs);
string shortAbbr = ws.get_Abbr(InMemoryFdoCache.s_wsHvos.En);
if (String.IsNullOrEmpty(shortAbbr))
{
// set default abbr, if not set.
string enName = ws.LanguageName; // ws.get_Name(InMemoryFdoCache.s_wsHvos.En);
ws.set_Abbr(InMemoryFdoCache.s_wsHvos.En, WritingSystemPropertiesDialog.CreateDefaultLanguageNameAbbr(enName));
}
// this is part of setup, so pretend this is how we actually loaded it.
ws.Dirty = false;
LanguageDefinitionFactory ldf = new LanguageDefinitionFactory(ws);
LanguageDefinition langDef = ldf.LanguageDefinition as LanguageDefinition;
DummyWritingSystemPropertiesDialog.SerializeToTempfile(langDef);
return langDef;
}
/// <summary>
///
/// </summary>
/// <param name="qwsf"></param>
/// <param name="locale"></param>
/// <returns></returns>
internal static LanguageDefinition DeserializeLanguageDefFromTempfile(ILgWritingSystemFactory qwsf, string locale)
{
LanguageDefinitionFactory langDefFactory = new LanguageDefinitionFactory();
if (LanguageDefinitionFactory.WritingSystemFactory == null)
LanguageDefinitionFactory.WritingSystemFactory = qwsf;
string filename;
if (s_icuLocaleToTmpLangDefFiles.TryGetValue(locale, out filename) && File.Exists(filename))
{
langDefFactory.Deserialize(filename);
return langDefFactory.LanguageDefinition as LanguageDefinition;
}
return null;
}
public void UserPromptOnMultipleLines_UpArrow()
{
CheckDisposed();
// This problem only happens with the Graphite renderer so we need to select a
// Graphite font
ILgWritingSystemFactory wsf = Cache.LanguageWritingSystemFactoryAccessor;
LanguageDefinitionFactory languageDefinitionFactory = new LanguageDefinitionFactory();
ILanguageDefinition langDef = languageDefinitionFactory.InitializeFromXml(wsf, "en");
langDef.WritingSystem.DefaultSerif = "Charis SIL";
langDef.WritingSystem.FontVariation = "";
try
{
// Save all changes and exit normally.
// (Make sure tests don't clobber an existing *.xml file.)
//langDef.Serialize(tmpFilename);
langDef.SaveWritingSystem("en");
}
catch
{
Assert.Fail("Failed to set the charis font for the english writing system!");
}
Options.ShowEmptyParagraphPromptsSetting = true;
m_draftForm.Width = 30; // set view narrow to make multiple-line user prompt
// Clear the section headings and then refresh the view to show user prompts.
IScrBook exodus = m_scr.ScriptureBooksOS[0];
IScrSection section2 = exodus.SectionsOS[1];
IScrSection section3 = exodus.SectionsOS[2];
StTxtPara heading2Para = (StTxtPara)section2.HeadingOA.ParagraphsOS[0];
StTxtPara heading3Para = (StTxtPara)section3.HeadingOA.ParagraphsOS[0];
StTxtPara Content2LastPara = (StTxtPara)section2.ContentOA.ParagraphsOS[section2.ContentOA.ParagraphsOS.Count - 1];
StTxtPara content3Para = (StTxtPara)section3.ContentOA.ParagraphsOS[0];
heading2Para.Contents.Text = string.Empty;
heading3Para.Contents.Text = string.Empty;
Content2LastPara.Contents.Text = "Second content para";
content3Para.Contents.Text = "Third content para";
m_draftView.RefreshDisplay();
// Make a selection in the second section head.
m_draftView.TeEditingHelper.GoToLastSection();
// Move down into the content and then back to the heading with the up arrow.
// (This issue is only a problem when selecting the user prompt with the keyboard).
m_draftView.RootBox.Activate(VwSelectionState.vssEnabled);
m_draftView.OnKeyDown(new KeyEventArgs(Keys.Down));
m_draftView.OnKeyDown(new KeyEventArgs(Keys.Up));
Application.DoEvents();
// get the hvo and tag of the current selection.
ITsString tss;
int ich;
int hvo;
int tag;
int ws;
bool assocPrev;
m_draftView.RootBox.Selection.TextSelInfo(false, out tss, out ich, out assocPrev,
out hvo, out tag, out ws);
// Confirm that the selection is in the second section head
Assert.AreEqual(heading3Para.Hvo, hvo);
// Press up arrow.
m_draftView.RootBox.Activate(VwSelectionState.vssEnabled);
m_draftView.OnKeyDown(new KeyEventArgs(Keys.Up));
// Confirm that the selection has moved up.
m_draftView.RootBox.Selection.TextSelInfo(false, out tss, out ich, out assocPrev,
out hvo, out tag, out ws);
Assert.AreEqual(Content2LastPara.Hvo, hvo);
}
/// <summary>
/// Get the writing system code (int) for the given RFC4646 language code
/// (string).
/// </summary>
public int GetWsFromRfcLang(string code, string sLdmlDir)
{
int ws;
if (m_mapRFCtoWs.TryGetValue(code, out ws))
return ws;
string sWs = ConvertFromRFCtoICU(code);
string sWsLower = sWs.ToLowerInvariant();
if (!m_mapIcuLCToWs.TryGetValue(sWsLower, out ws))
{
// See if a compatible XML file exists defining this writing system.
LanguageDefinition langDef;
try
{
LanguageDefinitionFactory fact = new LanguageDefinitionFactory();
langDef = fact.InitializeFromXml(
m_cache.LanguageWritingSystemFactoryAccessor, sWs) as LanguageDefinition;
}
catch
{
langDef = null;
}
ILgWritingSystem lgws;
if (langDef != null)
{
// ICU locale case may differ - keep existing XML based value
string sICU = langDef.IcuLocaleOriginal;
Debug.Assert(sWsLower == sICU.ToLowerInvariant());
langDef.SaveWritingSystem(sICU, true);
ws = m_cache.LanguageWritingSystemFactoryAccessor.GetWsFromStr(sICU);
Debug.Assert(ws >= 1);
lgws = LgWritingSystem.CreateFromDBObject(m_cache, ws);
}
else
{
WritingSystemDefinition wsd = null;
if (!String.IsNullOrEmpty(sLdmlDir))
{
LdmlInFolderWritingSystemStore ldmlstore = new LdmlInFolderWritingSystemStore(sLdmlDir);
foreach (WritingSystemDefinition wsdT in ldmlstore.WritingSystemDefinitions)
{
if (wsdT.RFC4646 == code)
{
wsd = wsdT;
break;
}
}
}
// This creates a new writing system for the given key.
IWritingSystem wrsy = m_cache.LanguageWritingSystemFactoryAccessor.get_Engine(sWs);
m_cache.ResetLanguageEncodings();
ws = wrsy.WritingSystem;
Debug.Assert(ws >= 1);
lgws = LgWritingSystem.CreateFromDBObject(m_cache, ws);
lgws.ICULocale = sWs;
if (wsd == null)
{
lgws.Abbr.UserDefaultWritingSystem = sWs;
lgws.Name.UserDefaultWritingSystem = sWs;
}
else
{
lgws.Abbr.UserDefaultWritingSystem = wsd.Abbreviation;
lgws.Name.UserDefaultWritingSystem = wsd.LanguageName;
lgws.DefaultSerif = wsd.DefaultFontName;
lgws.DefaultBodyFont = wsd.DefaultFontName;
lgws.RightToLeft = wsd.RightToLeftScript;
// TODO: collation, keyboard.
}
// Make sure XML file is written. See LT-8743.
wrsy.SaveIfDirty(m_cache.DatabaseAccessor);
}
m_rgnewWrtSys.Add(lgws);
m_cache.LangProject.AnalysisWssRC.Add(ws);
m_cache.LangProject.CurAnalysisWssRS.Append(ws);
if (m_fUpdateVernWss)
{
m_cache.LangProject.VernWssRC.Add(ws);
m_cache.LangProject.CurVernWssRS.Append(ws);
}
m_mapIcuLCToWs.Add(sWsLower, ws);
}
m_mapRFCtoWs.Add(code, ws);
return ws;
}
public void SerializeAndDeserialize()
{
IWritingSystem ws = m_wsf.get_Engine("tl");
int wsIdTl = m_wsf.GetWsFromStr("tl");
ws.Locale = 13321;
ws.DefaultMonospace = "Courier New";
ws.DefaultSansSerif = "Arial";
ws.DefaultBodyFont = "Charis SIL";
ws.DefaultSerif = "Times New Roman";
ws.set_Name(m_wsIdEn, "Tagalog");
ws.set_Name(wsIdTl, "Tagalog");
ws.set_Abbr(m_wsIdEn, "TGL");
ICollation coll = CollationClass.Create();
coll.WinLCID = 1033;
coll.WinCollation = "Latin1_General_CI_AI";
coll.set_Name(m_wsIdEn, "Default Collation");
coll.WritingSystemFactory = m_wsf;
ws.set_Collation(0, coll);
LanguageDefinition langDef = new LanguageDefinition(ws);
langDef.BaseLocale = "en_US";
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "tl";
langDef.LocaleName = "Tagalog";
langDef.LocaleScript = "";
langDef.LocaleCountry = "";
langDef.LocaleVariant = "";
langDef.XmlWritingSystem.WritingSystem.Locale = 13321;
langDef.CollationElements = "\"& B < ...";
langDef.ValidChars = "abcdefg";
langDef.LocaleResources = @"
zoneStrings {
{
'Europe/London',
'Greenwich Mean Time',
}
}";
CharDef[] charDefs = new CharDef[2];
charDefs[0] = new CharDef(0xF170, "COMBINING SNAKE BELOW;Mn;202;NSM;;;;");
charDefs[1] = new CharDef(0xF210, "LATIN SMALL LETTER P WITH STROKE;Ll;0;L;;;;");
langDef.PuaDefinitions = charDefs;
FileName[] fonts = new FileName[4];
fonts[0] = new FileName("arial.ttf");
fonts[1] = new FileName("arialbd.ttf");
fonts[2] = new FileName("ariali.ttf");
fonts[3] = new FileName("arialbi.ttf");
langDef.Fonts = fonts;
langDef.Keyboard = new FileName("Tagalog.kmx");
langDef.EncodingConverter = new EncodingConverter("SIL_IPA93.tec.vbs", "SIL-IPA93.tec");
string tmpFileName = Path.GetTempFileName();
langDef.Serialize(tmpFileName);
LanguageDefinitionFactory otherIcuWs = new LanguageDefinitionFactory();
LanguageDefinitionFactory.WritingSystemFactory = m_wsf;
otherIcuWs.Deserialize(tmpFileName);
ILanguageDefinition newLangDef = otherIcuWs.LanguageDefinition;
IWritingSystem deserializedWs = newLangDef.WritingSystem;
ICollation deserializedColl = newLangDef.GetCollation(0);
StreamReader reader = new StreamReader(tmpFileName);
string line = reader.ReadLine();
while (line != null)
{
Console.WriteLine(line);
line = reader.ReadLine();
}
reader.Close();
File.Delete(tmpFileName);
Assert.AreEqual(ws.Locale, deserializedWs.Locale);
Assert.AreEqual(ws.IcuLocale, deserializedWs.IcuLocale);
Assert.AreEqual(ws.DefaultSansSerif, deserializedWs.DefaultSansSerif);
Assert.AreEqual(ws.DefaultBodyFont, deserializedWs.DefaultBodyFont);
Assert.AreEqual(ws.get_Name(m_wsIdEn), deserializedWs.get_Name(m_wsIdEn));
Assert.AreEqual(coll.WinLCID, deserializedColl.WinLCID);
Assert.AreEqual(coll.WinCollation, deserializedColl.WinCollation);
// ENHANCE: Add ValidChars to the interface
// Assert.AreEqual(ws.ValidChars, deserializedWs.ValidChars);
Assert.AreEqual(coll.get_Name(m_wsIdEn), deserializedColl.get_Name(m_wsIdEn));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets (or makes) the writing system. If there isn't already one with this locale id,
/// we assume there is an XML language definition we can load.
/// </summary>
/// ------------------------------------------------------------------------------------
public IWritingSystem EnsureRealWs(ILgWritingSystemFactory wsf)
{
if (wsf.GetWsFromStr(m_icuLocale) == 0)
{
// Need to create a new writing system from the XML file.
LanguageDefinitionFactory ldf =
new LanguageDefinitionFactory(wsf, m_icuLocale);
string pathname = DirectoryFinder.LanguagesDirectory + "\\" + m_icuLocale + ".xml";
ldf.Deserialize(pathname);
ldf.LanguageDefinition.SaveWritingSystem(m_icuLocale);
}
return wsf.get_EngineOrNull(wsf.GetWsFromStr(m_icuLocale));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Finds or creates the writing system.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="icuLocale">The icu locale.</param>
/// <returns>The writing system</returns>
/// ------------------------------------------------------------------------------------
private LgWritingSystem FindOrCreateWs(FdoCache cache, string icuLocale)
{
// Look to see if the writing system already exists in the database
foreach (LgWritingSystem ws in cache.LanguageEncodings)
{
if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale))
return ws;
}
// Create a new writing system based on the one noted in the XML file.
// Load it in from the XML and save into the database.
LanguageDefinitionFactory ldf =
new LanguageDefinitionFactory(cache.LanguageWritingSystemFactoryAccessor, icuLocale);
ldf.LanguageDefinition.SaveWritingSystem(icuLocale);
cache.ResetLanguageEncodings();
// search again. It better be there now!
foreach (LgWritingSystem ws in cache.LanguageEncodings)
{
if (LanguageDefinition.SameLocale(ws.ICULocale, icuLocale))
return ws;
}
Debug.Assert(false);
return null;
}
