private bool ShouldAddLeafNode(int keyTermHvo, int[] subKeyTerms)
{
// if we have a book filter and the keyterm doesn't have subpossibilities (ie. it's a leaf node)
// make sure this key term has an occurrence in the books specified by the book filter.
if (subKeyTerms.Length == 0)
{
if (HasBookFilter())
{
ChkTerm chkTerm = new ChkTerm(m_cache, keyTermHvo, false, false);
foreach (IChkRef chkRef in chkTerm.OccurrencesOS)
{
int bookIdOfOccurrence = ScrReference.GetBookFromBcv(chkRef.Ref);
if (FilteredBookIds.Contains(bookIdOfOccurrence))
{
// the reference is in one of our filtered books
// so add its key term to our tree.
return(true);
}
}
}
else
{
// no book filter to apply, so add all the key terms.
return(true);
}
}
else
{
// return false. not a leaf-node.
}
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Build a list of the KeyTermRef objects that will be displayed in the key terms
/// rendering grid.
/// </summary>
/// <param name="hvoTerm">hvo of the term node to get references for. This could be the
/// HVO of a category node, in which case we just clear the list.</param>
/// <param name="filteredBookIds">list of book ids that are in the current filter.
/// If null, then filtering is not on and all references should be included</param>
/// ------------------------------------------------------------------------------------
public void LoadRenderingsForKeyTerm(int hvoTerm, List <int> filteredBookIds)
{
m_dataGridView.RowEnter -= m_dataGridView_RowEnter;
m_dataGridView.RowCount = 0;
m_list.Clear();
if (m_cache.GetClassOfObject(hvoTerm) != ChkTerm.kClassId)
{
return; // Must be a category node
}
ChkTerm keyTerm = new ChkTerm(m_cache, hvoTerm);
PopulateKeyTermRefs(keyTerm, filteredBookIds);
if (m_stylesheet != null)
{
if (!String.IsNullOrEmpty(keyTerm.Name.GetAlternative(m_wsGreek)))
{
m_OriginalTerm.WritingSystemCode = m_wsGreek;
m_OriginalTerm.Font = new Font(
m_stylesheet.GetNormalFontFaceName(m_cache, m_wsGreek),
FontInfo.kDefaultFontSize / 1000);
}
else if (!String.IsNullOrEmpty(keyTerm.Name.GetAlternative(m_wsHebrew)))
{
m_OriginalTerm.WritingSystemCode = m_wsHebrew;
m_OriginalTerm.Font = new Font(
m_stylesheet.GetNormalFontFaceName(m_cache, m_wsHebrew),
FontInfo.kDefaultFontSize / 1000);
}
else
{
throw new Exception("Unexpected biblical term - no Greek or Hebrew Name. Term id = " + hvoTerm);
}
}
m_dataGridView.RowCount = m_list.Count;
m_dataGridView.KeyTermRefs = m_list;
m_dataGridView.RowEnter += m_dataGridView_RowEnter;
Sort(m_sortedColumn, false, kRefCol);
m_prevResultRow = -1;
if (m_firstLoad && m_persistence != null)
{
OnLoadSettings(m_persistence.SettingsKey);
}
m_firstLoad = false;
if (ReferenceListEmptied != null && m_dataGridView.RowCount == 0)
{
ReferenceListEmptied(this, EventArgs.Empty);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Recursively populate a list with key term references
/// </summary>
/// <param name="keyTerm">ChkTerm which is part of the keyterm hierarchy</param>
/// <param name="filteredBookIds">list of books in the filter, or null if no filter</param>
/// ------------------------------------------------------------------------------------
private void PopulateKeyTermRefs(ChkTerm keyTerm, List <int> filteredBookIds)
{
foreach (KeyTermRef chkRef in keyTerm.OccurrencesOS)
{
if (filteredBookIds == null || filteredBookIds.Contains(chkRef.RefInCurrVersification.Book))
{
chkRef.PropertyChanged -= OnKeyTermRefPropertyChanged;
chkRef.PropertyChanged += OnKeyTermRefPropertyChanged;
m_list.Add(chkRef);
}
}
foreach (ChkTerm kt in keyTerm.SubPossibilitiesOS)
{
PopulateKeyTermRefs(kt, filteredBookIds);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Assigns a rendering for this check reference.
/// </summary>
/// <param name="wordForm">The word form.</param>
/// ------------------------------------------------------------------------------------
internal void AssignRendering(IWfiWordform wordForm)
{
RenderingStatus = KeyTermRenderingStatus.Assigned;
RenderingRA = wordForm;
ChkTerm owningChkTerm = new ChkTerm(Cache, OwnerHVO);
bool fChkTermRenderingAlreadySet = false;
foreach (IChkRendering rendering in owningChkTerm.RenderingsOC)
{
if (rendering.SurfaceFormRAHvo == wordForm.Hvo)
{
fChkTermRenderingAlreadySet = true;
break;
}
}
if (!fChkTermRenderingAlreadySet)
{
ChkRendering newRendering = new ChkRendering();
owningChkTerm.RenderingsOC.Add(newRendering);
newRendering.SurfaceFormRAHvo = wordForm.Hvo;
}
}
public void SimpleUpgradeWhenExistingListHasNoRenderings()
{
CheckDisposed();
ILangProject lp = m_fdoCache.LangProject;
ICmPossibilityList oldKeyTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(oldKeyTermsList);
ChkTerm term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Abba", m_wsEn);
term.Description.SetAlternative("Daddy", m_wsEn);
AddOccurrenceToOldStyleSense(term, 41014036, null, "abba");
term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Angel", m_wsEn);
ChkTerm subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("Heavenly being", m_wsEn);
subsense.Description.SetAlternative("Supernatural being sent as a messenger from God", m_wsEn);
AddOccurrenceToOldStyleSense(subsense, 040001020, null, "aggelos");
subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("Demon", m_wsEn);
subsense.Description.SetAlternative("A fallen angel", m_wsEn);
AddOccurrenceToOldStyleSense(subsense, 040007022, null, "daimonion");
BiblicalTermsList terms = new BiblicalTermsList();
terms.Version = Guid.NewGuid();
terms.KeyTerms = new List<Term>();
terms.KeyTerms.Add(new Term(3, "KT", "\u03b1\u03b2\u03b2\u03b1", "Greek",
"abba; father", null, null, 4101403603, 4500801516, 4800400618));
terms.KeyTerms.Add(new Term(21, "KT", "\u1F04\u03B3\u03B3\u03B5\u03BB\u03BF\u03C2-1", "Greek",
"angel", null, null, 040001020));
terms.KeyTerms.Add(new Term(363, "KT", "\u03B4\u03B1\u03B9\u03BC\u1F79\u03BD\u03B9\u03BF\u03BD",
"Greek", "demon", "\u1F04\u03B3\u03B3\u03B5\u03BB\u03BF\u03C2",
"\u03B4\u03B1\u03B9\u03BC\u03BF\u03BD\u1F77\u03B6\u03BF\u03BC\u03B1\u03B9, \u03B4\u03B1\u03B9\u03BC\u03BF\u03BD\u03B9\u1F7D\u03B4\u03B7\u03C2, \u03B4\u03B1\u1F77\u03BC\u03C9\u03BD",
040007022));
List<BiblicalTermsLocalization> localizations = new List<BiblicalTermsLocalization>(1);
BiblicalTermsLocalization loc = new BiblicalTermsLocalization(1);
loc.WritingSystemHvo = m_wsEn;
loc.Categories.Add(new CategoryLocalization("KT", "Key terms"));
loc.Terms.Add(new TermLocalization(3, "abba; father", "title for God, literally dad"));
localizations.Add(loc);
// Load the terms
ICmPossibilityList newChkTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(newChkTermsList);
DummyTeKeyTermsInit.CallLoadKeyTerms(oldKeyTermsList, newChkTermsList, terms, localizations);
int wsGreek = m_wsf.GetWsFromStr("grc");
// Make sure the old list has been blown away
// We can't do this now because we delete the list asynchronously
// Assert.IsFalse(oldKeyTermsList.IsValidObject());
oldKeyTermsList = null;
// Make sure there is one category (possibility) in the new list
Assert.AreEqual(1, newChkTermsList.PossibilitiesOS.Count);
ICmPossibility ktCategory = newChkTermsList.PossibilitiesOS[0];
Assert.AreEqual("KT", ktCategory.Abbreviation.GetAlternative(m_wsEn));
// Make sure there are three keyterms in that category
Assert.AreEqual(3, ktCategory.SubPossibilitiesOS.Count);
// Look at the contents of the first ChkTerm
IChkTerm keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[0];
Assert.AreEqual(3, keyterm.TermId);
Assert.AreEqual("\u03b1\u03b2\u03b2\u03b1", keyterm.Name.GetAlternative(wsGreek));
Assert.AreEqual("abba", keyterm.Name.GetAlternative(m_wsEn));
Assert.AreEqual("title for God, literally dad",
keyterm.Description.GetAlternative(m_wsEn).Text);
Assert.AreEqual("father", keyterm.SeeAlso.GetAlternative(m_wsEn));
Assert.AreEqual(0, keyterm.RenderingsOC.Count);
Assert.AreEqual(3, keyterm.OccurrencesOS.Count, "There should be 3 references for abba");
Assert.AreEqual(0, keyterm.OccurrencesOS[0].RenderingRAHvo);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[0].Status);
Assert.AreEqual(0, keyterm.OccurrencesOS[1].RenderingRAHvo);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[1].Status);
Assert.AreEqual(0, keyterm.OccurrencesOS[2].RenderingRAHvo);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[2].Status);
// Briefly check the other two ChkTerms
keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[1];
Assert.AreEqual(21, keyterm.TermId);
Assert.AreEqual(0, keyterm.RenderingsOC.Count);
Assert.AreEqual(1, keyterm.OccurrencesOS.Count);
Assert.AreEqual(0, keyterm.OccurrencesOS[0].RenderingRAHvo);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[0].Status);
keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[2];
Assert.AreEqual(363, keyterm.TermId);
Assert.AreEqual(0, keyterm.RenderingsOC.Count);
Assert.AreEqual(1, keyterm.OccurrencesOS.Count);
Assert.AreEqual(0, keyterm.OccurrencesOS[0].RenderingRAHvo);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[0].Status);
bool fFoundResource = false;
foreach (CmResource resource in lp.TranslatedScriptureOA.ResourcesOC)
{
if (resource.Name == "BiblicalTerms")
{
Assert.AreEqual(terms.Version, resource.Version);
fFoundResource = true;
}
}
Assert.IsTrue(fFoundResource);
}
public void UpgradeWhenExistingListHasRenderings()
{
CheckDisposed();
ILangProject lp = m_fdoCache.LangProject;
IWfiWordform abc = lp.WordformInventoryOA.AddRealWordform("abc", lp.DefaultVernacularWritingSystem);
IWfiWordform def = lp.WordformInventoryOA.AddRealWordform("def", lp.DefaultVernacularWritingSystem);
IWfiWordform ghi = lp.WordformInventoryOA.AddRealWordform("ghi", lp.DefaultVernacularWritingSystem);
ICmPossibilityList oldKeyTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(oldKeyTermsList);
ChkTerm term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Abba", m_wsEn);
term.Description.SetAlternative("Daddy", m_wsEn);
AddOccurrenceToOldStyleSense(term, 41014036, abc, "abba", KeyTermRenderingStatus.Assigned);
AddOccurrenceToOldStyleSense(term, 45008015, abc, "abba", KeyTermRenderingStatus.AutoAssigned);
AddOccurrenceToOldStyleSense(term, 48004006, null, "abba"); // Not rendered
AddOccurrenceToOldStyleSense(term, 48004007, abc, "abba"); // This one is not in new list
term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Angel", m_wsEn);
ChkTerm subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("Heavenly being", m_wsEn);
subsense.Description.SetAlternative("Supernatural being sent as a messenger from God", m_wsEn);
AddOccurrenceToOldStyleSense(subsense, 040001020, def, "aggelos");
AddOccurrenceToOldStyleSense(subsense, 040001024, ghi, "aggelos");
AddOccurrenceToOldStyleSense(subsense, 040002013, null, "aggelos", KeyTermRenderingStatus.Ignored);
subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("Demon", m_wsEn);
subsense.Description.SetAlternative("A fallen angel", m_wsEn);
AddOccurrenceToOldStyleSense(subsense, 040007022, null, "daimonion");
BiblicalTermsList terms = new BiblicalTermsList();
terms.Version = Guid.NewGuid();
terms.KeyTerms = new List<Term>();
terms.KeyTerms.Add(new Term(3, "KT", "\u03b1\u03b2\u03b2\u03b1", "Greek",
"abba; father", null, null, 4101403603, 4500801516, 4800400618));
terms.KeyTerms.Add(new Term(21, "KT", "\u1F04\u03B3\u03B3\u03B5\u03BB\u03BF\u03C2", "Greek",
"angel", null, null, 04000102006, 04000102413, 04000201305));
terms.KeyTerms.Add(new Term(363, "KT", "\u03B4\u03B1\u03B9\u03BC\u1F79\u03BD\u03B9\u03BF\u03BD-1",
"Greek", "demon", "\u03B4\u03B1\u03B9\u03BC\u1F79\u03BD\u03B9\u03BF\u03BD",
"\u03B4\u03B1\u03B9\u03BC\u03BF\u03BD\u1F77\u03B6\u03BF\u03BC\u03B1\u03B9, \u03B4\u03B1\u03B9\u03BC\u03BF\u03BD\u03B9\u1F7D\u03B4\u03B7\u03C2, \u03B4\u03B1\u1F77\u03BC\u03C9\u03BD",
04000702219));
List<BiblicalTermsLocalization> localizations = new List<BiblicalTermsLocalization>(1);
BiblicalTermsLocalization loc = new BiblicalTermsLocalization(1);
loc.WritingSystemHvo = m_wsEn;
loc.Categories.Add(new CategoryLocalization("KT", "Key terms"));
loc.Terms.Add(new TermLocalization(3, "abba; father", "title for God, literally dad"));
localizations.Add(loc);
// Load the terms
ICmPossibilityList newChkTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(newChkTermsList);
DummyTeKeyTermsInit.CallLoadKeyTerms(oldKeyTermsList, newChkTermsList, terms,
localizations);
int wsGreek = m_wsf.GetWsFromStr("grc");
// Make sure the old list has been blown away
// We can't do this now because we delete the list asynchronously
// Assert.IsFalse(oldKeyTermsList.IsValidObject());
oldKeyTermsList = null;
// Make sure there is one category (possibility) in the new list
ICmPossibility ktCategory = newChkTermsList.PossibilitiesOS[0];
Assert.AreEqual("KT", ktCategory.Abbreviation.GetAlternative(m_wsEn));
// Make sure there are three keyterms in that category
Assert.AreEqual(3, ktCategory.SubPossibilitiesOS.Count);
// Check the ChkTerm and ChkRefs for "abba"
IChkTerm keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[0];
Assert.AreEqual(3, keyterm.TermId);
Assert.AreEqual("\u03b1\u03b2\u03b2\u03b1", keyterm.Name.GetAlternative(wsGreek));
Assert.AreEqual("abba", keyterm.Name.GetAlternative(m_wsEn));
Assert.AreEqual("title for God, literally dad",
keyterm.Description.GetAlternative(m_wsEn).Text);
Assert.AreEqual("father", keyterm.SeeAlso.GetAlternative(m_wsEn));
Assert.AreEqual(1, keyterm.RenderingsOC.Count);
ChkRendering abbaRendering = new ChkRendering(m_fdoCache, keyterm.RenderingsOC.HvoArray[0]);
Assert.AreEqual(abc, abbaRendering.SurfaceFormRA);
Assert.AreEqual(3, keyterm.OccurrencesOS.Count, "There should be 3 references for abba");
Assert.AreEqual(KeyTermRenderingStatus.Assigned, keyterm.OccurrencesOS[0].Status);
Assert.AreEqual(abc, keyterm.OccurrencesOS[0].RenderingRA);
Assert.AreEqual(KeyTermRenderingStatus.AutoAssigned, keyterm.OccurrencesOS[1].Status);
Assert.AreEqual(abc, keyterm.OccurrencesOS[1].RenderingRA);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[2].Status);
Assert.AreEqual(0, keyterm.OccurrencesOS[2].RenderingRAHvo);
// Check the ChkRefs for "angel"
keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[1];
Assert.AreEqual(21, keyterm.TermId);
Assert.AreEqual(2, keyterm.RenderingsOC.Count);
bool fFoundDEF = false;
bool fFoundGHI = false;
foreach (IChkRendering rendering in keyterm.RenderingsOC)
{
fFoundDEF |= (rendering.SurfaceFormRAHvo == def.Hvo);
fFoundGHI |= (rendering.SurfaceFormRAHvo == ghi.Hvo);
}
Assert.IsTrue(fFoundDEF);
Assert.IsTrue(fFoundGHI);
Assert.AreEqual(3, keyterm.OccurrencesOS.Count);
Assert.AreEqual(KeyTermRenderingStatus.Assigned, keyterm.OccurrencesOS[0].Status);
Assert.AreEqual(def, keyterm.OccurrencesOS[0].RenderingRA);
Assert.AreEqual(KeyTermRenderingStatus.Assigned, keyterm.OccurrencesOS[1].Status);
Assert.AreEqual(ghi, keyterm.OccurrencesOS[1].RenderingRA);
Assert.AreEqual(KeyTermRenderingStatus.Ignored, keyterm.OccurrencesOS[2].Status);
Assert.IsNull(keyterm.OccurrencesOS[2].RenderingRA);
// Check the ChkRefs for "demon"
keyterm = (IChkTerm)ktCategory.SubPossibilitiesOS[2];
Assert.AreEqual(363, keyterm.TermId);
Assert.AreEqual(0, keyterm.RenderingsOC.Count);
Assert.AreEqual(1, keyterm.OccurrencesOS.Count);
Assert.AreEqual(KeyTermRenderingStatus.Unassigned, keyterm.OccurrencesOS[0].Status);
Assert.AreEqual(0, keyterm.OccurrencesOS[0].RenderingRAHvo);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds an occurrence to and old-style sense.
/// </summary>
/// <param name="term">The ChkTerm (a sense or subsense).</param>
/// <param name="reference">The Scripture reference.</param>
/// <param name="wordform">The wordform.</param>
/// <param name="keyword">The keyword (transliterated from Greek)</param>
/// <returns>The newly added ChkRef</returns>
/// ------------------------------------------------------------------------------------
protected ChkRef AddOccurrenceToOldStyleSense(ChkTerm term, int reference,
IWfiWordform wordform, string keyword)
{
return AddOccurrenceToOldStyleSense(term, reference, wordform, keyword,
(wordform == null) ? KeyTermRenderingStatus.Unassigned : KeyTermRenderingStatus.Assigned);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds an occurrence to and old-style sense.
/// </summary>
/// <param name="term">The ChkTerm (a sense or subsense).</param>
/// <param name="reference">The Scripture reference.</param>
/// <param name="wordform">The wordform.</param>
/// <param name="keyword">The keyword (transliterated from Greek)</param>
/// <param name="status">The rendering status.</param>
/// <returns>The newly added ChkRef</returns>
/// ------------------------------------------------------------------------------------
protected ChkRef AddOccurrenceToOldStyleSense(ChkTerm term, int reference,
IWfiWordform wordform, string keyword, KeyTermRenderingStatus status)
{
ChkRef occurrence = new ChkRef();
term.OccurrencesOS.Append(occurrence);
occurrence.KeyWord.UnderlyingTsString = m_factory.MakeString(keyword, m_wsEn);
occurrence.Ref = reference;
// If wordform is null, status must either be unassigned or ignored
// If wordform is not null, status must either be assigned or auto-assigned
Debug.Assert(((wordform == null) && (status == KeyTermRenderingStatus.Unassigned ||
status == KeyTermRenderingStatus.Ignored)) ||
((wordform != null) && (status == KeyTermRenderingStatus.Assigned ||
status == KeyTermRenderingStatus.AutoAssigned)));
occurrence.Status = status;
occurrence.RenderingRA = wordform;
return occurrence;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Build a list of the KeyTermRef objects that will be displayed in the key terms
/// rendering grid.
/// </summary>
/// <param name="hvoTerm">hvo of the term node to get references for. This could be the
/// HVO of a category node, in which case we just clear the list.</param>
/// <param name="filteredBookIds">list of book ids that are in the current filter.
/// If null, then filtering is not on and all references should be included</param>
/// ------------------------------------------------------------------------------------
public void LoadRenderingsForKeyTerm(int hvoTerm, List<int> filteredBookIds)
{
m_dataGridView.RowEnter -= m_dataGridView_RowEnter;
m_dataGridView.RowCount = 0;
m_list.Clear();
if (m_cache.GetClassOfObject(hvoTerm) != ChkTerm.kClassId)
return; // Must be a category node
ChkTerm keyTerm = new ChkTerm(m_cache, hvoTerm);
PopulateKeyTermRefs(keyTerm, filteredBookIds);
if (m_stylesheet != null)
{
if (!String.IsNullOrEmpty(keyTerm.Name.GetAlternative(m_wsGreek)))
{
m_OriginalTerm.WritingSystemCode = m_wsGreek;
m_OriginalTerm.Font = new Font(
m_stylesheet.GetNormalFontFaceName(m_cache, m_wsGreek),
FontInfo.kDefaultFontSize / 1000);
}
else if (!String.IsNullOrEmpty(keyTerm.Name.GetAlternative(m_wsHebrew)))
{
m_OriginalTerm.WritingSystemCode = m_wsHebrew;
m_OriginalTerm.Font = new Font(
m_stylesheet.GetNormalFontFaceName(m_cache, m_wsHebrew),
FontInfo.kDefaultFontSize / 1000);
}
else
throw new Exception("Unexpected biblical term - no Greek or Hebrew Name. Term id = " + hvoTerm);
}
m_dataGridView.RowCount = m_list.Count;
m_dataGridView.KeyTermRefs = m_list;
m_dataGridView.RowEnter += m_dataGridView_RowEnter;
Sort(m_sortedColumn, false, kRefCol);
m_prevResultRow = -1;
if (m_firstLoad && m_persistence != null)
OnLoadSettings(m_persistence.SettingsKey);
m_firstLoad = false;
if (ReferenceListEmptied != null && m_dataGridView.RowCount == 0)
ReferenceListEmptied(this, EventArgs.Empty);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Recursively populate a list with key term references
/// </summary>
/// <param name="keyTerm">ChkTerm which is part of the keyterm hierarchy</param>
/// <param name="filteredBookIds">list of books in the filter, or null if no filter</param>
/// ------------------------------------------------------------------------------------
private void PopulateKeyTermRefs(ChkTerm keyTerm, List<int> filteredBookIds)
{
foreach (KeyTermRef chkRef in keyTerm.OccurrencesOS)
{
if (filteredBookIds == null || filteredBookIds.Contains(chkRef.RefInCurrVersification.Book))
{
chkRef.PropertyChanged -= OnKeyTermRefPropertyChanged;
chkRef.PropertyChanged += OnKeyTermRefPropertyChanged;
m_list.Add(chkRef);
}
}
foreach (ChkTerm kt in keyTerm.SubPossibilitiesOS)
PopulateKeyTermRefs(kt, filteredBookIds);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds the CkkRef records associated with the given term to the hashtable.
/// </summary>
/// <param name="keyTermHvo">The key term hvo.</param>
/// <param name="bcvToChkRefs">The BCV to CHK refs.</param>
/// ------------------------------------------------------------------------------------
private void AddChkRefsToBCVmap(int keyTermHvo, ref Dictionary<int, List<KeyTermRef>> bcvToChkRefs)
{
ChkTerm chkTerm = new ChkTerm(m_cache, keyTermHvo, false, false);
List<int> filteredBookNum = m_FilteredBookIds;
// if we don't have a book filter, we only care about
// updating keyterms for renderings in books we have in our
// project.
// NOTE: What do we do about updating renderings for books
// that have been removed from the project?
if (filteredBookNum == null)
filteredBookNum = new List<int>();
if (filteredBookNum.Count == 0)
{
foreach (ScrBook book in m_scr.ScriptureBooksOS)
filteredBookNum.Add(book.CanonicalNum);
}
foreach (IChkRef chkRef in chkTerm.OccurrencesOS)
{
if (filteredBookNum != null && filteredBookNum.Count > 0)
{
int bookNumOfOccurrence = ScrReference.GetBookFromBcv(chkRef.Ref);
// if we have a book filter, we only care about mapping for
// renderings that are showing.
if (!filteredBookNum.Contains(bookNumOfOccurrence))
continue;
}
if (!bcvToChkRefs.ContainsKey(chkRef.Ref))
{
bcvToChkRefs.Add(chkRef.Ref, new List<KeyTermRef>());
}
bcvToChkRefs[chkRef.Ref].Add(chkRef as KeyTermRef);
}
}
public void FindCorrespondingChkRef()
{
CheckDisposed();
// First, create a possibility list with the old key terms and set some ChkRefs to
// have renderings.
ILangProject lp = m_fdoCache.LangProject;
IWfiWordform abc = lp.WordformInventoryOA.AddRealWordform("abc", lp.DefaultVernacularWritingSystem);
IWfiWordform def = lp.WordformInventoryOA.AddRealWordform("def", lp.DefaultVernacularWritingSystem);
IWfiWordform ghi = lp.WordformInventoryOA.AddRealWordform("ghi", lp.DefaultVernacularWritingSystem);
IWfiWordform jkl = lp.WordformInventoryOA.AddRealWordform("jkl", lp.DefaultVernacularWritingSystem);
IWfiWordform mno = lp.WordformInventoryOA.AddRealWordform("mno", lp.DefaultVernacularWritingSystem);
ICmPossibilityList oldKeyTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(oldKeyTermsList);
ChkTerm term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Adultery", m_wsEn);
ChkTerm subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("The act of sexual unfaithfulness", m_wsEn);
ChkRef chkrefMoicheuw040005027 = AddOccurrenceToOldStyleSense(subsense, 040005027, abc, "moicheuw");
ChkRef chkrefMoicheuw040005028 = AddOccurrenceToOldStyleSense(subsense, 040005028, abc, "moicheuw");
ChkRef chkrefMoichaomai040005032 = AddOccurrenceToOldStyleSense(subsense, 040005032, def, "moichaomai");
ChkRef chkrefMoicheia040015019 = AddOccurrenceToOldStyleSense(subsense, 040015019, ghi, "moicheia");
ChkRef chkrefMoichaomai040019009 = AddOccurrenceToOldStyleSense(subsense, 040019009, def, "moichaomai");
subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("One who sexually violates marriage vows", m_wsEn);
ChkTerm subsubsense = new ChkTerm();
subsense.SubPossibilitiesOS.Append(subsubsense);
subsubsense.Name.SetAlternative("Masculine offenders", m_wsEn);
ChkRef chkrefMoichos042018011 = AddOccurrenceToOldStyleSense(subsubsense, 042018011, jkl, "moichos");
ChkRef chkrefMoichos046006009 = AddOccurrenceToOldStyleSense(subsubsense, 046006009, jkl, "moichos");
ChkRef chkrefMoichos058013004 = AddOccurrenceToOldStyleSense(subsubsense, 058013004, jkl, "moichos");
subsubsense = new ChkTerm();
subsense.SubPossibilitiesOS.Append(subsubsense);
subsubsense.Name.SetAlternative("Feminine offenders", m_wsEn);
ChkRef chkrefMoichalis045007003 = AddOccurrenceToOldStyleSense(subsubsense, 045007003, mno, "moichalis");
ChkRef chkrefMoichalis061002014 = AddOccurrenceToOldStyleSense(subsubsense, 061002014, mno, "moichalis");
// Next, load the new list of Biblicalk terms
BiblicalTermsList terms = new BiblicalTermsList();
terms.Version = Guid.NewGuid();
terms.KeyTerms = new List <Term>();
terms.KeyTerms.Add(new Term(3, "KT", "\u03b1\u03b2\u03b2\u03b1", "Greek",
"abba; father", null, null, 4101403603, 4500801516, 4800400618));
string sGrkMoichaomai = "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9";
terms.KeyTerms.Add(new Term(1139, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-1",
"Greek", "commit adultery", sGrkMoichaomai,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04000503223, 04001900917, 04101001123, 04101001210));
string sGrkMoicheia = "\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1";
terms.KeyTerms.Add(new Term(1140, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-2",
"Greek", "adultery", sGrkMoicheia,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04001501909, 04300800310));
string sGrkMoicheuw = "\u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9";
terms.KeyTerms.Add(new Term(1141, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-3",
"Greek", "commit adultery", sGrkMoicheuw,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04000502705, 04000502708, 04000502815, 04001901812, 04101001907, 04201601810, 04201601817,
04201802005, 04300800410, 04500202204, 04500202205, 04501300904, 05900201105, 05900201113,
06600202208));
string sGrkMoichalis = "\u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2";
terms.KeyTerms.Add(new Term(1142, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-4",
"Greek", "adulterous; adulteress", sGrkMoichalis,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04001203909, 04001600404, 04100803815, 04500700306, 04500700326, 05900400401, 06100201404));
string sGrkMoichos = "\u03BC\u03BF\u03B9\u03C7\u1F79\u03C2";
terms.KeyTerms.Add(new Term(1143, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-5",
"Greek", "adulterer", sGrkMoichos,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04201801122, 04600600917));
List <BiblicalTermsLocalization> localizations = new List <BiblicalTermsLocalization>(1);
ICmPossibilityList newBiblicalTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(newBiblicalTermsList);
DummyTeKeyTermsInit.CallLoadKeyTerms(newBiblicalTermsList, terms, localizations);
ICmPossibility newKtList = null;
foreach (ICmPossibility category in newBiblicalTermsList.PossibilitiesOS)
{
if (category.Abbreviation.GetAlternative(m_wsEn) == "KT")
{
newKtList = category;
}
}
Assert.IsNotNull(newKtList);
// Now check to make sure FindCorrespondingChkRefs works
List <IChkRef> chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichalis045007003);
Assert.AreEqual(2, chkRefs.Count);
Assert.AreEqual(sGrkMoichalis, chkRefs[0].KeyWord.Text);
Assert.AreEqual(045007003, chkRefs[0].Ref);
Assert.AreEqual(6, chkRefs[0].Location);
Assert.AreEqual(sGrkMoichalis, chkRefs[1].KeyWord.Text);
Assert.AreEqual(045007003, chkRefs[1].Ref);
Assert.AreEqual(26, chkRefs[1].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichalis061002014);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichalis, chkRefs[0].KeyWord.Text);
Assert.AreEqual(061002014, chkRefs[0].Ref);
Assert.AreEqual(4, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichaomai040005032);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichaomai, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005032, chkRefs[0].Ref);
Assert.AreEqual(23, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichaomai040019009);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichaomai, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040019009, chkRefs[0].Ref);
Assert.AreEqual(17, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheia040015019);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoicheia, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040015019, chkRefs[0].Ref);
Assert.AreEqual(9, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheuw040005027);
Assert.AreEqual(2, chkRefs.Count);
Assert.AreEqual(sGrkMoicheuw, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005027, chkRefs[0].Ref);
Assert.AreEqual(5, chkRefs[0].Location);
Assert.AreEqual(sGrkMoicheuw, chkRefs[1].KeyWord.Text);
Assert.AreEqual(040005027, chkRefs[1].Ref);
Assert.AreEqual(8, chkRefs[1].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheuw040005028);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoicheuw, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005028, chkRefs[0].Ref);
Assert.AreEqual(15, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos042018011);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichos, chkRefs[0].KeyWord.Text);
Assert.AreEqual(042018011, chkRefs[0].Ref);
Assert.AreEqual(22, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos046006009);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichos, chkRefs[0].KeyWord.Text);
Assert.AreEqual(046006009, chkRefs[0].Ref);
Assert.AreEqual(17, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos058013004);
Assert.AreEqual(0, chkRefs.Count, "We removed this reference from the new list to test the case where no match is found");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Check all of the sibling references for a key term to see if any of the verses
/// have the same word form that was assigned. If they do, then the status will
/// be set to auto-assigned.
/// </summary>
/// <param name="assignedRef">ChkRef that was explicitly assigned</param>
/// <param name="wordForm">word for that was assigned to the ChkRef item</param>
/// ------------------------------------------------------------------------------------
private void AutoAssignVernacularEquivalents(IChkRef assignedRef, IWfiWordform wordForm)
{
int iDummy;
ChkTerm parent = new ChkTerm(m_cache, assignedRef.OwnerHVO);
foreach (KeyTermRef autoAssignRef in parent.OccurrencesOS)
{
if (autoAssignRef.RenderingStatus != KeyTermRenderingStatus.Unassigned)
continue;
if (TeEditingHelper.FindTextInVerse(m_scr,
wordForm.Form.GetAlternativeTss(wordForm.Cache.DefaultVernWs),
autoAssignRef.RefInCurrVersification, true,
out iDummy, out iDummy, out iDummy, out iDummy))
{
// TODO: update the local view constructor cache
autoAssignRef.RenderingStatus = KeyTermRenderingStatus.AutoAssigned;
autoAssignRef.RenderingRA = wordForm;
}
}
}
void CheckOccurrencesCount(int expectedCount, TreeNode node)
{
int hvoKeyTerm = (int)node.Tag;
ChkTerm keyTerm = new ChkTerm(Cache, hvoKeyTerm, false, false);
Assert.AreEqual(expectedCount, keyTerm.OccurrencesOS.Count);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Assigns a rendering for this check reference.
/// </summary>
/// <param name="wordForm">The word form.</param>
/// ------------------------------------------------------------------------------------
internal void AssignRendering(IWfiWordform wordForm)
{
RenderingStatus = KeyTermRenderingStatus.Assigned;
RenderingRA = wordForm;
ChkTerm owningChkTerm = new ChkTerm(Cache, OwnerHVO);
bool fChkTermRenderingAlreadySet = false;
foreach (IChkRendering rendering in owningChkTerm.RenderingsOC)
{
if (rendering.SurfaceFormRAHvo == wordForm.Hvo)
{
fChkTermRenderingAlreadySet = true;
break;
}
}
if (!fChkTermRenderingAlreadySet)
{
ChkRendering newRendering = new ChkRendering();
owningChkTerm.RenderingsOC.Add(newRendering);
newRendering.SurfaceFormRAHvo = wordForm.Hvo;
}
}
private bool ShouldAddLeafNode(int keyTermHvo, int[] subKeyTerms)
{
// if we have a book filter and the keyterm doesn't have subpossibilities (ie. it's a leaf node)
// make sure this key term has an occurrence in the books specified by the book filter.
if (subKeyTerms.Length == 0)
{
if (HasBookFilter())
{
ChkTerm chkTerm = new ChkTerm(m_cache, keyTermHvo, false, false);
foreach (IChkRef chkRef in chkTerm.OccurrencesOS)
{
int bookIdOfOccurrence = ScrReference.GetBookFromBcv(chkRef.Ref);
if (FilteredBookIds.Contains(bookIdOfOccurrence))
{
// the reference is in one of our filtered books
// so add its key term to our tree.
return true;
}
}
}
else
{
// no book filter to apply, so add all the key terms.
return true;
}
}
else
{
// return false. not a leaf-node.
}
return false;
}
public void FindCorrespondingChkRef()
{
CheckDisposed();
// First, create a possibility list with the old key terms and set some ChkRefs to
// have renderings.
ILangProject lp = m_fdoCache.LangProject;
IWfiWordform abc = lp.WordformInventoryOA.AddRealWordform("abc", lp.DefaultVernacularWritingSystem);
IWfiWordform def = lp.WordformInventoryOA.AddRealWordform("def", lp.DefaultVernacularWritingSystem);
IWfiWordform ghi = lp.WordformInventoryOA.AddRealWordform("ghi", lp.DefaultVernacularWritingSystem);
IWfiWordform jkl = lp.WordformInventoryOA.AddRealWordform("jkl", lp.DefaultVernacularWritingSystem);
IWfiWordform mno = lp.WordformInventoryOA.AddRealWordform("mno", lp.DefaultVernacularWritingSystem);
ICmPossibilityList oldKeyTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(oldKeyTermsList);
ChkTerm term = new ChkTerm();
oldKeyTermsList.PossibilitiesOS.Append(term);
term.Name.SetAlternative("Adultery", m_wsEn);
ChkTerm subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("The act of sexual unfaithfulness", m_wsEn);
ChkRef chkrefMoicheuw040005027 = AddOccurrenceToOldStyleSense(subsense, 040005027, abc, "moicheuw");
ChkRef chkrefMoicheuw040005028 = AddOccurrenceToOldStyleSense(subsense, 040005028, abc, "moicheuw");
ChkRef chkrefMoichaomai040005032 = AddOccurrenceToOldStyleSense(subsense, 040005032, def, "moichaomai");
ChkRef chkrefMoicheia040015019 = AddOccurrenceToOldStyleSense(subsense, 040015019, ghi, "moicheia");
ChkRef chkrefMoichaomai040019009 = AddOccurrenceToOldStyleSense(subsense, 040019009, def, "moichaomai");
subsense = new ChkTerm();
term.SubPossibilitiesOS.Append(subsense);
subsense.Name.SetAlternative("One who sexually violates marriage vows", m_wsEn);
ChkTerm subsubsense = new ChkTerm();
subsense.SubPossibilitiesOS.Append(subsubsense);
subsubsense.Name.SetAlternative("Masculine offenders", m_wsEn);
ChkRef chkrefMoichos042018011 = AddOccurrenceToOldStyleSense(subsubsense, 042018011, jkl, "moichos");
ChkRef chkrefMoichos046006009 = AddOccurrenceToOldStyleSense(subsubsense, 046006009, jkl, "moichos");
ChkRef chkrefMoichos058013004 = AddOccurrenceToOldStyleSense(subsubsense, 058013004, jkl, "moichos");
subsubsense = new ChkTerm();
subsense.SubPossibilitiesOS.Append(subsubsense);
subsubsense.Name.SetAlternative("Feminine offenders", m_wsEn);
ChkRef chkrefMoichalis045007003 = AddOccurrenceToOldStyleSense(subsubsense, 045007003, mno, "moichalis");
ChkRef chkrefMoichalis061002014 = AddOccurrenceToOldStyleSense(subsubsense, 061002014, mno, "moichalis");
// Next, load the new list of Biblicalk terms
BiblicalTermsList terms = new BiblicalTermsList();
terms.Version = Guid.NewGuid();
terms.KeyTerms = new List<Term>();
terms.KeyTerms.Add(new Term(3, "KT", "\u03b1\u03b2\u03b2\u03b1", "Greek",
"abba; father", null, null, 4101403603, 4500801516, 4800400618));
string sGrkMoichaomai = "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9";
terms.KeyTerms.Add(new Term(1139, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-1",
"Greek", "commit adultery", sGrkMoichaomai,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04000503223, 04001900917, 04101001123, 04101001210));
string sGrkMoicheia = "\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1";
terms.KeyTerms.Add(new Term(1140, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-2",
"Greek", "adultery", sGrkMoicheia,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04001501909, 04300800310));
string sGrkMoicheuw = "\u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9";
terms.KeyTerms.Add(new Term(1141, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-3",
"Greek", "commit adultery", sGrkMoicheuw,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04000502705, 04000502708, 04000502815, 04001901812, 04101001907, 04201601810, 04201601817,
04201802005, 04300800410, 04500202204, 04500202205, 04501300904, 05900201105, 05900201113,
06600202208));
string sGrkMoichalis = "\u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2";
terms.KeyTerms.Add(new Term(1142, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-4",
"Greek", "adulterous; adulteress", sGrkMoichalis,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04001203909, 04001600404, 04100803815, 04500700306, 04500700326, 05900400401, 06100201404));
string sGrkMoichos = "\u03BC\u03BF\u03B9\u03C7\u1F79\u03C2";
terms.KeyTerms.Add(new Term(1143, "KT", "\u03BC\u03BF\u03B9\u03C7\u1F71\u03BF\u03BC\u03B1\u03B9-5",
"Greek", "adulterer", sGrkMoichos,
"\u03BC\u03BF\u03B9\u03C7\u03B5\u1F77\u03B1, \u03BC\u03BF\u03B9\u03C7\u03B5\u1F7B\u03C9, \u03BC\u03BF\u03B9\u03C7\u03B1\u03BB\u1F77\u03C2, \u03BC\u03BF\u03B9\u03C7\u1F79\u03C2",
04201801122, 04600600917));
List<BiblicalTermsLocalization> localizations = new List<BiblicalTermsLocalization>(1);
ICmPossibilityList newBiblicalTermsList = new CmPossibilityList();
lp.CheckListsOC.Add(newBiblicalTermsList);
DummyTeKeyTermsInit.CallLoadKeyTerms(newBiblicalTermsList, terms, localizations);
ICmPossibility newKtList = null;
foreach (ICmPossibility category in newBiblicalTermsList.PossibilitiesOS)
{
if (category.Abbreviation.GetAlternative(m_wsEn) == "KT")
newKtList = category;
}
Assert.IsNotNull(newKtList);
// Now check to make sure FindCorrespondingChkRefs works
List<IChkRef> chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichalis045007003);
Assert.AreEqual(2, chkRefs.Count);
Assert.AreEqual(sGrkMoichalis, chkRefs[0].KeyWord.Text);
Assert.AreEqual(045007003, chkRefs[0].Ref);
Assert.AreEqual(6, chkRefs[0].Location);
Assert.AreEqual(sGrkMoichalis, chkRefs[1].KeyWord.Text);
Assert.AreEqual(045007003, chkRefs[1].Ref);
Assert.AreEqual(26, chkRefs[1].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichalis061002014);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichalis, chkRefs[0].KeyWord.Text);
Assert.AreEqual(061002014, chkRefs[0].Ref);
Assert.AreEqual(4, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichaomai040005032);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichaomai, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005032, chkRefs[0].Ref);
Assert.AreEqual(23, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichaomai040019009);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichaomai, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040019009, chkRefs[0].Ref);
Assert.AreEqual(17, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheia040015019);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoicheia, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040015019, chkRefs[0].Ref);
Assert.AreEqual(9, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheuw040005027);
Assert.AreEqual(2, chkRefs.Count);
Assert.AreEqual(sGrkMoicheuw, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005027, chkRefs[0].Ref);
Assert.AreEqual(5, chkRefs[0].Location);
Assert.AreEqual(sGrkMoicheuw, chkRefs[1].KeyWord.Text);
Assert.AreEqual(040005027, chkRefs[1].Ref);
Assert.AreEqual(8, chkRefs[1].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoicheuw040005028);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoicheuw, chkRefs[0].KeyWord.Text);
Assert.AreEqual(040005028, chkRefs[0].Ref);
Assert.AreEqual(15, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos042018011);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichos, chkRefs[0].KeyWord.Text);
Assert.AreEqual(042018011, chkRefs[0].Ref);
Assert.AreEqual(22, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos046006009);
Assert.AreEqual(1, chkRefs.Count);
Assert.AreEqual(sGrkMoichos, chkRefs[0].KeyWord.Text);
Assert.AreEqual(046006009, chkRefs[0].Ref);
Assert.AreEqual(17, chkRefs[0].Location);
chkRefs = ChkRefMatcher.FindCorrespondingChkRefs(newKtList,
chkrefMoichos058013004);
Assert.AreEqual(0, chkRefs.Count, "We removed this reference from the new list to test the case where no match is found");
}
