/// <summary>
/// Collect up a set of unique WfiWordforms.
/// </summary>
private void GetUniqueWords(Dictionary <string, IWfiWordform> wordforms, string buffer)
{
int start = -1; // -1 means we're still looking for a word to start.
int length = 0;
int totalLengh = buffer.Length;
for (int i = 0; i < totalLengh; i++)
{
bool isWordforming = m_ws.get_IsWordForming(buffer[i]);
if (isWordforming)
{
length++;
if (start < 0) //first character in this word?
{
start = i;
}
}
if ((start > -1) && // had a word and found yet?
(!isWordforming || i == totalLengh - 1 /*last char of the input*/))
{
string word = buffer.Substring(start, length);
if (!wordforms.ContainsKey(word))
{
ITsString tss = TsStringUtils.MakeString(word, m_ws.Handle);
wordforms.Add(word, WfiWordformServices.FindOrCreateWordform(m_cache, tss));
}
length = 0;
start = -1;
}
}
}
public void ReferencesToDeletedWordformsShouldSwitch()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
var text = Cache.ServiceLocator.GetInstance <ITextFactory>().Create();
//Cache.LangProject.TextsOC.Add(text);
var stText = Cache.ServiceLocator.GetInstance <IStTextFactory>().Create();
text.ContentsOA = stText;
var para = Cache.ServiceLocator.GetInstance <IStTxtParaFactory>().Create();
stText.ParagraphsOS.Add(para);
var seg = Cache.ServiceLocator.GetInstance <ISegmentFactory>().Create();
para.SegmentsOS.Add(seg);
seg.AnalysesRS.Add(wf1);
seg.AnalysesRS.Add(wf2);
seg.AnalysesRS.Add(wf3);
seg.AnalysesRS.Add(wf2);
seg.AnalysesRS.Add(wf3);
var wordset = Cache.ServiceLocator.GetInstance <IWfiWordSetFactory>().Create();
Cache.LangProject.MorphologicalDataOA.TestSetsOC.Add(wordset);
wordset.CasesRC.Add(wf2);
ICmPossibilityList list = Cache.LangProject.KeyTermsList;
var term = Cache.ServiceLocator.GetInstance <IChkTermFactory>().Create();
list.PossibilitiesOS.Add(term);
var rendering = Cache.ServiceLocator.GetInstance <IChkRenderingFactory>().Create();
term.RenderingsOC.Add(rendering);
rendering.SurfaceFormRA = wf2;
var chkRef = Cache.ServiceLocator.GetInstance <IChkRefFactory>().Create();
term.OccurrencesOS.Add(chkRef);
chkRef.RenderingRA = wf2;
WfiWordformServices.FixDuplicates(Cache, m_progress);
// One but only one should survive.
var wf = Survivor(wf1, wf2, wf3);
Assert.That(seg.AnalysesRS.Count, Is.EqualTo(5));
Assert.That(seg.AnalysesRS[0], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[1], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[2], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[3], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[4], Is.EqualTo(wf));
// for several tests to prove anything, the wordform that survives must NOT be the
// one that was there already.
Assert.That(wf, Is.Not.EqualTo(wf2));
Assert.That(wordset.CasesRC, Has.Member(wf));
Assert.That(rendering.SurfaceFormRA, Is.EqualTo(wf));
Assert.That(chkRef.RenderingRA, Is.EqualTo(wf));
}
/// <summary>
/// This actually makes the fix.
/// </summary>
public void Process()
{
Debug.Assert(m_dlg != null);
var cache = (FdoCache)m_dlg.Mediator.PropertyTable.GetValue("cache");
UndoableUnitOfWorkHelper.Do(ITextStrings.ksUndoMergeAnalyses, ITextStrings.ksRedoMergeAnalyses,
cache.ActionHandlerAccessor,
() => WfiWordformServices.MergeDuplicateAnalyses(cache, new ProgressBarWrapper(m_dlg.ProgressBar)));
}
private void CreateTryAWordSandbox()
{
// skip if it's before we've set the word
if (m_sWordForm == null)
{
return;
}
// skip if it's before we've set up the rootsite control
if (m_rootb == null)
{
return;
}
// skip if we're not visible
if (!Visible)
{
return;
}
//Debug.WriteLine("TryAWordRootSite:WordForm - creating sandbox for " + m_sWordForm.Text);
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
m_wordform = WfiWordformServices.FindOrCreateWordform(m_cache, m_sWordForm);
});
//if (m_cache.IsDummyObject(hvo))
// m_wordform = new WfiWordform();
IAnalysis analysis = m_vc.GetGuessForWordform(m_wordform, m_cache.DefaultVernWs);
if (analysis is NullWAG)
{
analysis = m_wordform;
}
m_rootb.SetRootObject(analysis.Hvo, m_vc, m_kfragSingleInterlinearAnalysisWithLabels, m_styleSheet);
//Debug.Assert(m_tryAWordSandbox == null);
m_tryAWordSandbox = new TryAWordSandbox(m_cache,
Mediator,
m_propertyTable,
StyleSheet,
m_vc.LineChoices,
analysis);
m_tryAWordSandbox.Visible = false;
Controls.Add(m_tryAWordSandbox);
SetSandboxSize();
SetSandboxLocation();
m_tryAWordSandbox.Visible = true;
SetBackgroundColor();
int height = Math.Max(ScrollRange.Height, m_tryAWordSandbox.Height) + SystemInformation.HorizontalScrollBarHeight;
if (Height != height)
{
Height = height;
}
m_tryAWordSandbox.SizeChanged += m_tryAWordSandbox_SizeChanged;
//m_tryAWordSandbox.Focus();
}
public void DifferentAnalyses_AreNotMerged()
{
var wf = MakeWordform("bank");
var wa1 = MakeAnalysis(wf);
var entryBank = MakeEntry("bank", "side of river");
MakeBundle(wa1, entryBank.SensesOS[0]);
var wa2 = MakeAnalysis(wf);
var entryKick = MakeEntry("bank", "place for money");
MakeBundle(wa2, entryKick.SensesOS[0]);
var wa3 = MakeAnalysis(wf);
MakeBundle(wa3, entryBank.SensesOS[0]);
var verb = MakePartOfSpeech("verb");
wa3.CategoryRA = verb;
var wa4 = MakeAnalysis(wf);
MakeBundle(wa4, "bank"); // analysis only to morpheme level
var wa5 = MakeAnalysis(wf);
MakeBundle(wa5, "bank0"); // analysis only to morpheme level
var wa6 = MakeAnalysis(wf);
var bundle6 = MakeBundle(wa6, "bank");
bundle6.MsaRA = MakeMsa(entryBank);
var wa7 = MakeAnalysis(wf);
var bundle7 = MakeBundle(wa7, "bank0");
bundle7.MorphRA = MorphServices.MakeMorph(entryBank, TsStringUtils.MakeTss("bank", Cache.DefaultVernWs));
var wa8 = MakeAnalysis(wf);
MakeBundle(wa8, entryBank.SensesOS[0]);
MakeBundle(wa8, entryBank.SensesOS[0]); // makes sure it handles different number of bundles
WfiWordformServices.MergeDuplicateAnalyses(Cache, m_progress);
// We could try for something stronger; the basic idea is that it should change nothing.
// But the kind of changes it makes is deleting objects, so this should cover it.
Assert.That(wa1.IsValidObject);
Assert.That(wa2.IsValidObject);
Assert.That(wa3.IsValidObject);
Assert.That(wa4.IsValidObject);
Assert.That(wa5.IsValidObject);
Assert.That(wa6.IsValidObject);
Assert.That(wa7.IsValidObject);
Assert.That(wa8.IsValidObject);
}
public void WordformsWithNothingSpecialMerged()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
WfiWordformServices.FixDuplicates(Cache, m_progress);
// One but only one should survive.
Survivor(wf1, wf2, wf3);
}
public void CopesWithNullVernacular()
{
var wf1 = MakeWordform("");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
WfiWordformServices.FixDuplicates(Cache, m_progress);
var wf = Survivor(wf2, wf3);
Assert.That(wf1.IsValidObject, Is.True);
}
/// <summary>
/// Implement the add words to spelling dictionary command. (May be called by reflection,
/// though I don't think there is a current explicit menu item.)
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public bool OnAddWordsToSpellDict(object argument)
{
CheckDisposed();
if (Cache == null)
{
return(false); // impossible?
}
WfiWordformServices.ConformSpellingDictToWordforms(Cache);
return(true); // handled
}
public void IdenticalTrivialAnalyses_AreMerged()
{
var wf = MakeWordform("bank");
var wa1 = MakeAnalysis(wf);
var wa2 = MakeAnalysis(wf);
WfiWordformServices.MergeDuplicateAnalyses(Cache, m_progress);
Assert.That(!wa1.IsValidObject || !wa2.IsValidObject); // one should be deleted
Assert.That(wa1.IsValidObject || wa2.IsValidObject); // and one should survive!
}
/// <summary>
/// Implement the add words to spelling dictionary command. (May be called by reflection,
/// though I don't think there is a current explicit menu item.)
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public bool OnAddWordsToSpellDict(object argument)
{
CheckDisposed();
FdoCache cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
if (cache == null)
{
return(false); // impossible?
}
WfiWordformServices.ConformSpellingDictToWordforms(cache);
return(true); // handled
}
public void ExtraWritingSystemsAreCopied()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
int wsSpn = Cache.WritingSystemFactory.GetWsFromStr("es");
wf2.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("Spanish", wsSpn));
WfiWordformServices.FixDuplicates(Cache, m_progress);
var wf = Survivor(wf1, wf2, wf3);
Assert.That(wf, Is.Not.EqualTo(wf2)); // otherwise it doesn't prove much
Assert.That(wf.Form.get_String(wsSpn).Text, Is.EqualTo("Spanish"));
}
public void SpellingInCorrectBeatsUnknown()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
wf2.SpellingStatus = (int)SpellingStatusStates.incorrect;
WfiWordformServices.FixDuplicates(Cache, m_progress);
// One but only one should survive.
var wf = Survivor(wf1, wf2, wf3);
Assert.That(wf, Is.Not.EqualTo(wf2)); // otherwise it doesn't prove much
Assert.That(wf.SpellingStatus, Is.EqualTo((int)SpellingStatusStates.incorrect));
}
/// <summary>
/// This actually makes the fix.
/// </summary>
public void Process()
{
Debug.Assert(m_dlg != null);
var cache = (FdoCache)m_dlg.Mediator.PropertyTable.GetValue("cache");
string failures = null;
UndoableUnitOfWorkHelper.Do(ITextStrings.ksUndoMergeWordforms, ITextStrings.ksRedoMergeWordforms, cache.ActionHandlerAccessor,
() => failures = WfiWordformServices.FixDuplicates(cache, m_dlg.ProgressBar));
if (!string.IsNullOrEmpty(failures))
{
MessageBox.Show(m_dlg, string.Format(ITextStrings.ksWordformMergeFailures, failures), ITextStrings.ksWarning,
MessageBoxButtons.OK);
}
}
public void ChecksumIsReset()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
wf1.Checksum = 5;
wf2.Checksum = 6;
wf3.Checksum = 7;
WfiWordformServices.FixDuplicates(Cache, m_progress);
var wf = Survivor(wf1, wf2, wf3);
Assert.That(wf, Is.Not.EqualTo(wf2)); // otherwise it doesn't prove much
Assert.That(wf.Checksum, Is.EqualTo(0));
}
public bool OnUseVernSpellingDictionary(object argument)
{
bool checking = !IsVernacularSpellingEnabled();
if (checking)
{
OnEnableVernacularSpelling();
}
else
{
WfiWordformServices.DisableVernacularSpellingDictionary(Cache);
}
m_mediator.PropertyTable.SetProperty("UseVernSpellingDictionary", checking);
RestartSpellChecking();
return(true);
}
private static FwXWindow RefreshCacheWindowAndAll(LexTextApp app, string fullProjectFileName)
{
var manager = app.FwManager;
var appArgs = new FwAppArgs(fullProjectFileName);
var newAppWindow =
(FwXWindow)manager.ReopenProject(manager.Cache.ProjectId.Name, appArgs).ActiveMainWindow;
if (IsVernacularSpellingEnabled(newAppWindow.Mediator))
{
WfiWordformServices.ConformSpellingDictToWordforms(newAppWindow.Cache);
}
//clear out any sort cache files (or whatever else might mess us up) and then refresh
newAppWindow.ClearInvalidatedStoredData();
newAppWindow.RefreshDisplay();
return(newAppWindow);
}
public void AnalysesPreserved()
{
var wf1 = MakeWordform("wordXX");
var wa1 = MakeAnalysis(wf1);
var wf2 = MakeWordform("wordXX");
var wa2 = MakeAnalysis(wf2);
var wf3 = MakeWordform("wordXX");
var wa3 = MakeAnalysis(wf3);
WfiWordformServices.FixDuplicates(Cache, m_progress);
var wf = Survivor(wf1, wf2, wf3);
Assert.That(wa1.Owner, Is.EqualTo(wf));
Assert.That(wa2.Owner, Is.EqualTo(wf));
Assert.That(wa3.Owner, Is.EqualTo(wf));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Writes this rendering to the specified cache.
/// </summary>
/// <param name="term">The term to which this rendering belongs.</param>
/// <param name="ResolveConflict">The delegate to call to resolve a conflict when a
/// different rendering already exists.</param>
/// ------------------------------------------------------------------------------------
internal void WriteToCache(IChkTerm term, Func <IChkRef, string, string, bool> ResolveConflict)
{
IChkRef occ = term.OccurrencesOS.FirstOrDefault(o => o.Ref == Reference && o.Location == Location);
if (occ == null)
{
MessageBox.Show(string.Format("Couldn't find occurrence {0} in {1} for imported rendering of term: {2}.",
Location, (new BCVRef(Reference)), term.Name.AnalysisDefaultWritingSystem), "Unable to Import");
return;
}
if (string.IsNullOrEmpty(VernRendering))
{
if (occ.Status != KeyTermRenderingStatus.Ignored)
{
occ.Status = KeyTermRenderingStatus.Ignored;
occ.RenderingRA = null;
}
return;
}
string existingRendering = occ.RenderingRA == null ? null :
occ.RenderingRA.Form.VernacularDefaultWritingSystem.Text;
if (existingRendering == VernRendering)
{
return; // already set. Nothing to do.
}
if (!string.IsNullOrEmpty(existingRendering))
{
if (!ResolveConflict(occ, existingRendering, VernRendering))
{
return; // Leave existing rendering
}
}
// See if the word form already exists
IWfiWordform wordForm = WfiWordformServices.FindOrCreateWordform(term.Cache,
VernRendering, term.Services.WritingSystems.DefaultVernacularWritingSystem);
KeyTermRef ktRef = new KeyTermRef(occ);
// Change the reference's status and attach the word form to the ChkRef
ktRef.AssignRendering(wordForm);
}
public void SetAgentOpinion()
{
ICmAgent agent = Cache.LangProject.DefaultComputerAgent;
IWfiWordform wf = WfiWordformServices.FindOrCreateWordform(Cache,
TsStringUtils.MakeTss("xxxyyyzzz12234", Cache.DefaultVernWs));
IWfiAnalysis wa = Cache.ServiceLocator.GetInstance <IWfiAnalysisFactory>().Create();
wf.AnalysesOC.Add(wa);
Assert.AreEqual(Opinions.noopinion, wa.GetAgentOpinion(agent));
wa.SetAgentOpinion(agent, Opinions.approves);
Assert.AreEqual(Opinions.approves, wa.GetAgentOpinion(agent));
wa.SetAgentOpinion(agent, Opinions.disapproves);
Assert.AreEqual(Opinions.disapproves, wa.GetAgentOpinion(agent));
wa.SetAgentOpinion(agent, Opinions.noopinion);
Assert.AreEqual(Opinions.noopinion, wa.GetAgentOpinion(agent));
}
public void InconsistentAlternativesPreventMergeAndAreReported()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordZZ");
var wf4 = MakeWordform("wordZZ");
var wf5 = MakeWordform("wordZZ");
int wsSpn = Cache.WritingSystemFactory.GetWsFromStr("es");
wf1.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("Spanish", wsSpn));
wf2.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("SpanishOther", wsSpn));
wf3.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("Spanish", wsSpn));
wf4.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("SpanishOther", wsSpn));
wf5.Form.set_String(wsSpn, Cache.TsStrFactory.MakeString("SpanishYetAnother", wsSpn));
var failureList = WfiWordformServices.FixDuplicates(Cache, m_progress);
// None should be deleted.
Assert.That(wf1.IsValidObject && wf2.IsValidObject && wf3.IsValidObject && wf4.IsValidObject && wf5.IsValidObject);
Assert.That(failureList, Is.EqualTo("wordXX wordZZ"));
}
public void ComplexMerge_SucceedsAndFixesRefs()
{
var wf = MakeWordform("bank");
var wa1 = MakeAnalysis(wf);
var entryBankRiver = MakeEntry("bank", "side of river");
MakeBundle(wa1, entryBankRiver.SensesOS[0]);
var wa2 = MakeAnalysis(wf);
var entryBankMoney = MakeEntry("bank", "place for money");
MakeBundle(wa2, entryBankMoney.SensesOS[0]);
var wadup1 = MakeAnalysis(wf);
MakeBundle(wadup1, entryBankMoney.SensesOS[0]);
var wadup2 = MakeAnalysis(wf);
MakeBundle(wadup2, entryBankMoney.SensesOS[0]);
var wgMoney = MakeGloss(wa2, "money");
var wgPlaceMoney = MakeGloss(wadup1, "place for money");
var wgdup1 = MakeGloss(wa2, "money");
var wgdup2 = MakeGloss(wadup1, "money");
var wgdup3 = MakeGloss(wadup2, "money");
var text = MakeText("");
var seg = MakeSegment(text.ContentsOA, "bank bank bank bank bank bank bank bank");
seg.AnalysesRS.Add(wa1);
seg.AnalysesRS.Add(wa2);
seg.AnalysesRS.Add(wadup1);
seg.AnalysesRS.Add(wadup2);
seg.AnalysesRS.Add(wgMoney);
seg.AnalysesRS.Add(wgPlaceMoney);
seg.AnalysesRS.Add(wgdup1);
seg.AnalysesRS.Add(wgdup2);
seg.AnalysesRS.Add(wgdup3);
WfiWordformServices.MergeDuplicateAnalyses(Cache, m_progress);
// Theoretically, wa3 or wa4 could legitimately be the survivor. But in fact it is now wa1.
var survivor = wa2;
Assert.That(survivor.IsValidObject);
Assert.That(wa2.IsValidObject);
Assert.That(wadup1.IsValidObject, Is.False);
Assert.That(wadup2.IsValidObject, Is.False);
var survivingGloss = wgMoney; // Enhance: any other duplicate surviving is OK.
Assert.That(survivingGloss.IsValidObject);
Assert.That(wgPlaceMoney.IsValidObject);
Assert.That(wgPlaceMoney.Owner, Is.EqualTo(survivor));
Assert.That(wgdup1.IsValidObject, Is.False);
Assert.That(wgdup2.IsValidObject, Is.False);
Assert.That(wgdup3.IsValidObject, Is.False);
Assert.That(seg.AnalysesRS[0], Is.EqualTo(wa1));
Assert.That(seg.AnalysesRS[1], Is.EqualTo(survivor));
Assert.That(seg.AnalysesRS[2], Is.EqualTo(survivor));
Assert.That(seg.AnalysesRS[3], Is.EqualTo(survivor));
Assert.That(seg.AnalysesRS[4], Is.EqualTo(survivingGloss));
Assert.That(seg.AnalysesRS[5], Is.EqualTo(wgPlaceMoney));
Assert.That(seg.AnalysesRS[6], Is.EqualTo(survivingGloss));
Assert.That(seg.AnalysesRS[7], Is.EqualTo(survivingGloss));
Assert.That(seg.AnalysesRS[8], Is.EqualTo(survivingGloss));
}
private static IAnalysis CreateWordAnalysisStack(FdoCache cache, Word word, ITsStrFactory strFactory)
{
if (word.Items == null || word.Items.Length <= 0)
{
return(null);
}
IAnalysis analysis = null;
var wsFact = cache.WritingSystemFactory;
ILgWritingSystem wsMainVernWs = null;
foreach (var wordItem in word.Items)
{
ITsString wordForm = null;
switch (wordItem.type)
{
case "txt":
wsMainVernWs = GetWsEngine(wsFact, wordItem.lang);
wordForm = strFactory.MakeString(wordItem.Value, wsMainVernWs.Handle);
analysis = WfiWordformServices.FindOrCreateWordform(cache, wordForm);
break;
case "punct":
wordForm = strFactory.MakeString(wordItem.Value,
GetWsEngine(wsFact, wordItem.lang).Handle);
analysis = WfiWordformServices.FindOrCreatePunctuationform(cache, wordForm);
break;
}
if (wordForm != null)
{
break;
}
}
// now add any alternative word forms. (overwrite any existing)
if (analysis != null && analysis.HasWordform)
{
AddAlternativeWssToWordform(analysis, word, wsMainVernWs, strFactory);
}
if (analysis != null)
{
UpgradeToWordGloss(word, ref analysis);
}
else
{
Debug.Assert(analysis != null, "What else could this do?");
}
//Add any morphemes to the thing
if (word.morphemes != null && word.morphemes.morphs.Length > 0)
{
//var bundle = newSegment.Cache.ServiceLocator.GetInstance<IWfiMorphBundleFactory>().Create();
//analysis.Analysis.MorphBundlesOS.Add(bundle);
//foreach (var morpheme in word.morphemes)
//{
// //create a morpheme
// foreach(item item in morpheme.items)
// {
// //fill in morpheme's stuff
// }
//}
}
return(analysis);
}
