public void PuaCharacterToString()
{
string unicodeData =
"VULGAR FRACTION ONE THIRD;No;0;ON;<fraction> 0031 2044 0033;;;1/3;N;FRACTION ONE THIRD;;;;";
PUACharacter puaChar = new PUACharacter("2153",unicodeData);
Assert.AreEqual("2153;" + unicodeData, puaChar.ToString(), "Error while writing PUACharacter");
}
public void SetUp()
{
m_comparer = new UCDComparer();
m_bidi = new BidiCharacter("0669",
"ARABIC-INDIC DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;");
m_pua = new PUACharacter("0669",
"ARABIC-INDIC DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;");
}
public void CreateNewPuaCharacter()
{
// Make some test characters
PUACharacter newPuaChar =
new PUACharacter("E001","ARABIC-INDIC DIGIT THREE;Nd;0;L;;3;3;3;N;;;;;");
PUACharacter copyOfNewPuaChar = new PUACharacter(newPuaChar);
PUACharacter modifiedPuaChar =
new PUACharacter("E001","CHEESE DIGIT THREE;Lu;0;L;;;;;N;;;0063;0664;0665");
PUACharacter copyOfModifiedPuaChar = new PUACharacter(modifiedPuaChar);
// "click" new
m_dlgWsProps.PressBtnNewPUA(newPuaChar);
CheckPuaCharactersMatch(copyOfNewPuaChar, "using the 'new' button", m_dlgWsProps);
// "click" modify
m_dlgWsProps.PressBtnModifyPUA(modifiedPuaChar);
CheckPuaCharactersMatch(copyOfModifiedPuaChar, "using the 'modify' button", m_dlgWsProps);
// "click" okay
m_dlgWsProps.PressOk();
TestUtils.Check_PUA(0xE001, "CHEESE DIGIT THREE", LgGeneralCharCategory.kccLu);
}
/// <summary>
/// Makes a PUACharacter.
/// This is useful when you are extending the class so that further constructors
/// can make sure that we copy all the important data internally.
/// </summary>
/// <param name="puaChar">The PUACharacter that we are copying.</param>
public PUACharacter(PUACharacter puaChar)
{
this.Copy(puaChar);
}
/// <summary>
/// Constructs a UCDCharacter based off a copy of the given puaChar.
/// </summary>
/// <param name="puaChar"></param>
public UCDCharacter(PUACharacter puaChar) : base (puaChar)
{
}
public void PuaWithPua()
{
PUACharacter otherPua = m_pua;
Assert.AreEqual(0, m_comparer.Compare(m_pua, otherPua));
otherPua = new PUACharacter("0669",
"ARABIC-INDIC DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;");
Assert.AreEqual(0, m_comparer.Compare(m_pua, otherPua));
otherPua = new PUACharacter("004F", "LATIN CAPITAL LETTER O;Lu;0;L;;;;;N;;;;006F;");
Assert.Greater(m_comparer.Compare(m_pua, otherPua), 0);
otherPua = new PUACharacter("0668",
"ARABIC-INDIC DIGIT EIGHT;Nd;0;AN;;8;8;8;N;;;;;");
Assert.Greater(m_comparer.Compare(m_pua, otherPua), 0);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructs a new list item for the PUACharacterDlg wrapped around <c>puaChar</c>
/// </summary>
/// <param name="puaChar">The PUACharacter that this represents.</param>
/// <param name="fIsNew">Indicates whether the PUACharacter is a newly added one (not
/// yet saved/installed).</param>
/// ------------------------------------------------------------------------------------
public PuaListItem(PUACharacter puaChar, bool fIsNew)
{
m_puaChar = puaChar;
m_fIsNew = fIsNew;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the cached character associated with the given codepoint
/// </summary>
/// <param name="codepoint">The integer codepoint of the cached character.</param>
/// <returns>The character as a PUACharacter</returns>
/// ------------------------------------------------------------------------------------
public PUACharacter FindCachedIcuEntry(int codepoint)
{
CheckDisposed();
//? Need to have at least 4 digits in the string.
//? string codepointAsString = string.Format("{0:x4}", codepoint).ToUpper();
string codepointAsString = codepoint.ToString("x").ToUpper();
foreach (int[] range in m_cachedIcuRanges)
{
if (IsInRange(codepoint, range))
{
// If the range is not loaded, load it
if (range[2]++ == 0)
FillRange(range);
return (PUACharacter)m_cachedIcu.Find(codepointAsString, new UCDComparer());
}
}
// If we get here, we didn't find the codepoint
PUACharacter newIcuChar = new PUACharacter(codepointAsString);
// Load the character if it exists and has a name
if (newIcuChar.RefreshFromIcu(false))
{
// This can be called from PuaCharacterDlg where m_cachedIcu has not been initialized.
InitializeIcuCache();
m_cachedIcu.Insert(newIcuChar);
return newIcuChar;
}
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays the PUACharacterDlg dialog to edit the given <c>puaChar</c>.
/// </summary>
/// <param name="puaChar">The PUACharacter to edit.</param>
/// <param name="modify"><c>true</c> if we are modifying an existing character rather
/// than making a new one.</param>
/// ------------------------------------------------------------------------------------
private void DisplayPUACharacterDlg(PUACharacter puaChar, bool modify)
{
using (PUACharacterDlg puaDlg = CreatePUACharacterDlg())
{
puaDlg.PUAChar = puaChar;
puaDlg.Modify = modify;
puaDlg.SetDialogProperties(m_helpTopicProvider);
puaDlg.ParentDialog = this;
if (puaDlg.CallShowDialog() == DialogResult.OK)
{
// For the Add dialog, create a new list item
if (!puaDlg.Modify)
{
// puaChar will be modified by the dialog box if the user presses okay
PuaListItem puaLstItem = new PuaListItem(puaChar, true);
m_lstPUACharacters.Items.Add(puaLstItem, true);
}
else
{
PuaListItem puaListItem = FindListItem(puaChar.CodePoint);
if (puaListItem != null)
{
m_lstPUACharacters.SetItemChecked(
m_lstPUACharacters.Items.IndexOf(puaListItem), true);
}
}
// Mark the character as modified if they actually clicked okay.
MarkAsModified(puaChar);
}
}
m_lstPUACharacters.Refresh();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Determines whether a Pua Character has already been defined for a certain codepoint
/// </summary>
/// <param name="puaChar">The codepoint you wish to check</param>
/// <returns><c>true</c> if it contains codepoint, otherwise <c>false</c></returns>
/// ------------------------------------------------------------------------------------
public bool IsDefinedPuaCharacter(PUACharacter puaChar)
{
CheckDisposed();
return IsDefinedPuaCharacter(puaChar.CodePoint);
}
/// <summary>
/// Compares two PUACharacters to see if they are the same.
/// </summary>
/// <param name="puaChar">The second PUACharacter to compare with.</param>
/// <returns><c>true</c> if the characters are identical.</returns>
public bool Equals(PUACharacter puaChar)
{
return
this.m_codepoint == puaChar.m_codepoint &&
this.m_name == puaChar.m_name &&
this.m_generalCategory.Equals(puaChar.m_generalCategory) &&
this.m_canonicalCombiningClass.Equals(puaChar.m_canonicalCombiningClass) &&
this.m_bidiClass.Equals(puaChar.m_bidiClass) &&
this.m_decompositionType.Equals(puaChar.m_decompositionType) &&
this.m_decomposition == puaChar.m_decomposition &&
this.m_numericType == puaChar.m_numericType &&
this.m_numericValue == puaChar.m_numericValue &&
this.m_bidiMirrored.Equals(puaChar.m_bidiMirrored) &&
this.m_unicode1Name == puaChar.m_unicode1Name &&
this.m_isoComment == puaChar.m_isoComment &&
this.m_upper == puaChar.m_upper &&
this.m_lower == puaChar.m_lower &&
this.m_title == puaChar.m_title;
}
/// <summary>
/// Constructs a new BidiCharacter, copying all the values from <c>puaChar</c>
/// </summary>
/// <param name="puaChar"></param>
public BidiCharacter(PUACharacter puaChar) : base(puaChar){}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Assert that PUACharacter match what we expect.
/// </summary>
/// <param name="puaCharacterExpected">The expected PUACharacter</param>
/// <param name="message">The message to append, e.g. "using the 'new' button"</param>
/// <param name="wsPropsDlg">The ws props DLG.</param>
/// ------------------------------------------------------------------------------------
private void CheckPuaCharactersMatch(
PUACharacter puaCharacterExpected, string message,
DummyWritingSystemPropertiesDialog wsPropsDlg)
{
Assert.IsTrue(wsPropsDlg.IsPuaCodepointAdded(puaCharacterExpected.CodePoint),
"Didn't add the PUACharacter " + puaCharacterExpected.CodePoint + " " + message);
Assert.AreEqual(puaCharacterExpected.ToString(),
wsPropsDlg.GetPuaString(puaCharacterExpected),
"Didn't modify the PUACharacter " + message);
Assert.IsTrue(wsPropsDlg.IsPuaAdded(puaCharacterExpected),
"Didn't modify the PUACharacter " + message);
}
public void CreateNewPuaCharacterWithBadData()
{
PUACharacter newPuaChar =
new PUACharacter("E000", "LATIN CAPITAL LETTER H;Lu;0;L;;;;;N;;;0068;0664;0665");
PUACharacter copyOfNewPuaChar =
new PUACharacter("E000", "LATIN CAPITAL LETTER H;Lu;0;L;;;;;N;;;0068;0664;0665");
m_dlgWsProps.PressBtnNewPUA(newPuaChar);
CheckPuaCharactersMatch(copyOfNewPuaChar, "using the 'new' button", m_dlgWsProps);
PUACharacter modifiedPuaChar =
new PUACharacter("E000", "CHEESE DIGIT THREE;Lu;0;AN;;3;3;3;N;;;0063;0664;0665");
PUACharacter copyOfModifiedPuaChar = new PUACharacter(modifiedPuaChar);
m_dlgWsProps.PressBtnModifyPUA(modifiedPuaChar);
CheckPuaCharactersMatch(copyOfModifiedPuaChar, "using the 'modify' button",
m_dlgWsProps);
}
public void DisabledFields()
{
PUACharacter newPuaChar =
new PUACharacter("EABC", "arabic-indic digit three;Nd;0;AN;;3;3;3;N;;;ABBB;ABBB;ABBB");
PUACharacter correctedPuaChar =
new PUACharacter("EABC", "ARABIC-INDIC DIGIT THREE;Nd;0;AN;;3;3;3;N;;;;;");
PUACharacterDlg newDlgBox = new PUACharacterDlg();
// m_puaChar.GeneralCategory = newDlgBoxSelectedItem;
m_dlgWsProps.PressBtnNewPUA(newPuaChar);
// PUACharacterDlg
CheckPuaCharactersMatch(correctedPuaChar, "when setting the general category...",
m_dlgWsProps);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Returns a list of the user defined custom characters in ICU by scanning the Unicode data file.
/// </summary>
/// ------------------------------------------------------------------------------------
public static List<PUACharacter> GetDefinedCustomPUACharsFromICU()
{
List<PUACharacter> definedChars = new List<PUACharacter>();
string uniData = DirectoryFinder.GetIcuDirectory; // "c:\\work\\fw60\\distfiles\\Icu40\\icudt40l\\"
uniData = uniData.Substring(0, uniData.LastIndexOf(@"\icudt"));
uniData = Path.Combine(uniData, @"data\unidata\UnicodeData.txt");
StreamReader reader = new StreamReader(uniData, System.Text.Encoding.ASCII);
int chT = reader.Peek(); // force autodetection of encoding.
try
{
string line;
while((line = reader.ReadLine()) != null)
{
// skip entirely blank lines
if(line.Length <= 0)
continue;
if (line.IndexOf("User Added") != -1)
{
PUACharacter puaChar = new PUACharacter("0000");
string codepoint = line.Substring(0, line.IndexOf(';')).Trim();
puaChar.CodePoint = codepoint;
puaChar.RefreshFromIcu(false);
definedChars.Add(puaChar);
}
}
}
finally
{
reader.Close();
}
// REVIEW (TimS/EberhardB): We don't think we should call GC.Collect().
// If there seems to be a need for it, then we probably need to call
// Dispose() on one of the variables we want disposed.
GC.Collect();
return definedChars;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Makes sure that if the specified codepoint is a custom PUA character, that that
/// character is added to the language definition's PUA collection.
/// </summary>
/// ------------------------------------------------------------------------------------
private static void UpdateLangDefPUACollection(int codepoint,
LanguageDefinition langDef, List<PUACharacter> customPuaCharacters)
{
// Go through all the custom defined PUA characters in ICU and make sure that if
// our codepoint is one of them, the language definition contains our codepoint
// in its collection of PUA characters.
foreach (PUACharacter customChar in customPuaCharacters)
{
string sCodePoint = codepoint.ToString("x4").ToUpperInvariant();
// Is our codepoint one of the custom PUA characters? If so,
// add it to the language definition's PUA collection.
if (sCodePoint == customChar.CodePoint)
{
PUACharacter puaChar = new PUACharacter(sCodePoint);
puaChar.RefreshFromIcu(false);
langDef.AddPuaDefinition(codepoint, puaChar.ToString());
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Determines whether or not the specified codepoint is defined in ICU. If it is and
/// its a custom PUA character, then make sure the language definition's PUA character
/// collection is updated. Return false if the codepoint is not defined in ICU.
/// </summary>
/// ------------------------------------------------------------------------------------
private static bool IsCodePointDefined(int codepoint)
{
PUACharacter puaChar = new PUACharacter(codepoint);
try
{
// If the definition doesn't exist in ICU or the character has no name then
// it's undefined and shouldn't be allowed in the valid characters list.
if (!puaChar.RefreshFromIcu(false) || puaChar.Name.Length == 0)
return false;
// If the ICU category is one of the "Other" categories, then it's
// undefined and shouldn't be allowed in the valid characters list.
string ucdrep = puaChar.GeneralCategory.UcdRepresentation;
ucdrep = ucdrep.ToUpperInvariant();
// TODO: When tabs are supported, then allow them (they are in category Cc).
// See TE-3004.
if (ucdrep[0] == 'C' && ucdrep[1] != 'F')
return false;
}
catch
{
return false;
}
return true;
}
/// <summary>
/// Constructs a new Normalization character with the given normalization property.
/// </summary>
/// <param name="puaChar"></param>
/// <param name="property"></param>
public NormalizationCharacter(PUACharacter puaChar, string property) : base(puaChar)
{
this.property = property;
}
public void PuaCharacterTextConstructor()
{
PUACharacter puaCharacter = new PUACharacter("0669", "ARABIC-INDIC DIGIT NINE;Nd;0;AN;;9;9;9;N;;;;;");
}
/// <summary>
/// Copy data from the given PUACharacter
/// </summary>
/// <param name="sourcePuaChar">The character to copy.</param>
public void Copy(PUACharacter sourcePuaChar)
{
this.CodePoint = sourcePuaChar.m_codepoint;
this.Name = sourcePuaChar.m_name;
this.m_generalCategory = sourcePuaChar.m_generalCategory;
this.m_canonicalCombiningClass = sourcePuaChar.m_canonicalCombiningClass;
this.m_bidiClass = sourcePuaChar.m_bidiClass;
this.m_decompositionType = sourcePuaChar.m_decompositionType;
this.m_decomposition = sourcePuaChar.m_decomposition;
this.m_numericType = sourcePuaChar.m_numericType;
this.m_numericValue = sourcePuaChar.m_numericValue;
this.m_bidiMirrored = sourcePuaChar.m_bidiMirrored;
this.m_unicode1Name = sourcePuaChar.m_unicode1Name;
this.m_isoComment = sourcePuaChar.m_isoComment;
this.m_upper = sourcePuaChar.m_upper;
this.m_lower = sourcePuaChar.m_lower;
this.m_title = sourcePuaChar.m_title;
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Tests the "Modify" button.
/// </summary>
/// <param name="puaChar">The pua char.</param>
/// --------------------------------------------------------------------------------
public void PressBtnModifyPUA(PUACharacter puaChar)
{
CheckDisposed();
// Set the test pua character used to hold all the information to enter.
// NOTE: This is never used directly,
// it is only used to hold values to be copied one at time
DummyPUACharacterDlg.TestPuaCharacter = puaChar;
// Select puaChar in the list
foreach (PuaListItem pualistItem in m_lstPUACharacters.Items)
{
if (pualistItem.PUAChar.CodePoint == puaChar.CodePoint)
{
m_lstPUACharacters.SelectedItem = pualistItem;
break;
}
}
// "click" modify
m_btnModifyPUA_Click(null, null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Finds the given PUACharacter via its codepoint and sets it as modified.
/// </summary>
/// <param name="puaChar">The PUACharacter to mark as modified</param>
/// ------------------------------------------------------------------------------------
public void MarkAsModified(PUACharacter puaChar)
{
CheckDisposed();
PuaListItem puaListItem = FindListItem(puaChar.CodePoint);
if (puaListItem != null)
{
puaListItem.Modified = true;
// Update the underlying LD data
m_langDefCurrent.RemovePuaDefinition(puaListItem.PUAChar.CharDef);
m_langDefCurrent.AddPuaDefinition(puaListItem.PUAChar.CharDef);
}
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Gets the PUA character as string
/// </summary>
/// <param name="addedPuaChar">The PUACharacter that was added.</param>
/// <returns>
/// </returns>
/// --------------------------------------------------------------------------------
public string GetPuaString(PUACharacter addedPuaChar)
{
CheckDisposed();
foreach (PuaListItem pualistItem in m_lstPUACharacters.Items)
{
// Find the PUACharacter in the list.
if (pualistItem.PUAChar.CodePoint == addedPuaChar.CodePoint)
{
// Return the value of the actual PUACharacter that is in the list
return pualistItem.PUAChar.ToString();
}
}
return "No PUACharacter found";
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// ------------------------------------------------------------------------------------
private void FillRange(int[] range)
{
// Makes a new empty Icu Cache, if it doesn't already exist
InitializeIcuCache();
PUACharacter newIcuChar;
for (int codepoint = range[0]; codepoint <= range[1]; codepoint++)
{
// TODO: Make sure that leaving off leading zeros is okay.
newIcuChar = new PUACharacter(codepoint.ToString("x").ToUpper());
// Fill in the character from the ICU database.
newIcuChar.RefreshFromIcu(true);
// Add the character to the cache
m_cachedIcu.Insert(newIcuChar);
// REVIEW (TimS/EberhardB): We don't think we should call GC.Collect().
// If there seems to be a need for it, then we probably need to call
// Dispose() on one of the variables we want disposed.
if (codepoint % 0x100 == 0)
GC.Collect();
}
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Selectes the given PUACharacter via its codepoint from the list
/// </summary>
/// <param name="puaChar">The pua char.</param>
/// --------------------------------------------------------------------------------
public void SelectPuaCharacter(PUACharacter puaChar)
{
CheckDisposed();
foreach (PuaListItem puaListItem in m_lstPUACharacters.Items)
{
// Find the PUACharacter in the list.
if (puaListItem.PUAChar.CodePoint == puaChar.CodePoint)
{
// Return the value of the actual PUACharacter that is in the list
m_lstPUACharacters.SelectedItem = puaListItem;
break;
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructs a new list item for the PUACharacterDlg wrapped around <c>puaChar</c>
/// </summary>
/// <param name="puaChar">The PUACharacter that this represents.</param>
/// ------------------------------------------------------------------------------------
public PuaListItem(PUACharacter puaChar) : this(puaChar, false)
{
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Tests to see if a PUACharacter with the given codepoint was added to m_lstPUACharacters
/// and that it has the same properties.
/// </summary>
/// <param name="addedPuaChar">The PUACharacter that was added.</param>
/// <returns>
/// <c>true</c> if the character is found and it matches.
/// </returns>
/// --------------------------------------------------------------------------------
public bool IsPuaAdded(PUACharacter addedPuaChar)
{
CheckDisposed();
foreach (PuaListItem pualistItem in m_lstPUACharacters.Items)
{
// Find the PUACharacter in the list.
if (pualistItem.PUAChar.CodePoint == addedPuaChar.CodePoint)
return pualistItem.PUAChar.Equals(addedPuaChar);
}
return false;
}
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>
/// Simulates pressing the "Add" button.
/// </summary>
/// <param name="puaChar">The pua char.</param>
/// --------------------------------------------------------------------------------
public void PressBtnNewPUA(PUACharacter puaChar)
{
CheckDisposed();
// Set the test pua character used to hold all the information to enter.
// NOTE: This is never used directly,
// it is only used to hold values to be copied one at time
DummyPUACharacterDlg.TestPuaCharacter = puaChar;
// "Click" new
m_btnNewPUA_Click(null, null);
}