/// <summary>
/// This guess factors in the placement of an occurrence in its segment for making other
/// decisions like matching lowercase alternatives for sentence initial occurrences.
/// </summary>
public IAnalysis GetBestGuess(AnalysisOccurrence occurrence)
{
// first see if we can make a guess based on the lowercase form of a sentence initial (non-lowercase) wordform
// TODO: make it look for the first word in the sentence...may not be at Index 0!
if (occurrence.Analysis is IWfiWordform && occurrence.Index == 0)
{
ITsString tssWfBaseline = occurrence.BaselineText;
var tracker = new CpeTracker(Cache.WritingSystemFactory, tssWfBaseline);
ILgCharacterPropertyEngine cpe = tracker.CharPropEngine(0);
string sLower = cpe.ToLower(tssWfBaseline.Text);
// don't bother looking up the lowercased wordform if the instanceOf is already in lowercase form.
if (sLower != tssWfBaseline.Text)
{
ITsString tssLower = TsStringUtils.MakeTss(sLower, TsStringUtils.GetWsAtOffset(tssWfBaseline, 0));
IWfiWordform lowercaseWf;
if (Cache.ServiceLocator.GetInstance <IWfiWordformRepository>().TryGetObject(tssLower, out lowercaseWf))
{
IAnalysis bestGuess;
if (TryGetBestGuess(lowercaseWf, occurrence.BaselineWs, out bestGuess))
{
return(bestGuess);
}
}
}
}
if (occurrence.BaselineWs == -1)
{
return(null); // happens with empty translation lines
}
return(GetBestGuess(occurrence.Analysis, occurrence.BaselineWs));
}
/// <summary>
/// Returns a sequence of IAnalysis objects inclusive of the current occurrence
/// and the end occurrence (otherAC). Parameter occurrence must occur AFTER 'this'
/// occurrence.
/// </summary>
/// <param name="point2">An AnalysisOccurrence</param>
/// <returns></returns>
public IEnumerable <IAnalysis> GetAdvancingOccurrencesInclusiveOf(AnalysisOccurrence point2)
{
if (!point2.IsValid)
{
throw new ArgumentException("Invalid Analysis Occurrence");
}
if (Segment == point2.Segment)
{
// Case 1: Two points in same ISegment object
if (Index > point2.Index)
{
throw new ArgumentException("Second AnalysisOccurrence is before the first!");
}
// Copy out sub-array of Analyses between the two ACs indices
return(Segment.AnalysesRS.ToList().GetRange(Index, point2.Index - Index + 1));
}
if (Segment.Owner == point2.Segment.Owner)
{
// Case 2: Two points in different ISegment objects, but in same StTxtPara
if (Segment.IndexInOwner > point2.Segment.IndexInOwner)
{
throw new ArgumentException("Second AnalysisOccurrence is before the first!");
}
// Need to copy out end of first segment, any segments in between and beginning of second segment
return(CopyOutAnalysesFromMultipleSegments(point2));
}
var para1 = Segment.Owner as IStTxtPara;
var para2 = point2.Segment.Owner as IStTxtPara;
if (!(para1.Owner as IStText).ParagraphsOS.Contains(para2))
{
throw new ArgumentOutOfRangeException("point2", "AnalysisOccurrences are not within the same Text!");
}
throw new NotImplementedException("So far we only handle this in same Segment or Paragraph.");
}
/// <summary>
/// Copy out IAnalysis objects from the end of this ISegment through the beginning of
/// parameter's ISegment (inclusive). Also copies objects from intervening ISegments.
/// Assumes parameter is in the same StTxtPara!
/// </summary>
/// <param name="point2"></param>
/// <returns></returns>
private IEnumerable <IAnalysis> CopyOutAnalysesFromMultipleSegments(AnalysisOccurrence point2)
{
// Need to copy out end of first segment, any segments in between and beginning of second segment
var result = new List <IAnalysis>();
var paraSegs = (Segment.Owner as IStTxtPara).SegmentsOS;
if (paraSegs == null)
{
throw new NullReferenceException("Unexpected error!");
}
for (var i = Segment.IndexInOwner; i <= point2.Segment.IndexInOwner; i++)
{
if (i == Segment.IndexInOwner)
{
// Copy out end of this segment
result.AddRange(paraSegs[i].AnalysesRS.ToList().GetRange(Index, Segment.AnalysesRS.Count - Index));
continue;
}
if (i == point2.Segment.IndexInOwner)
{
// Copy out beginning of this segment
result.AddRange(paraSegs[i].AnalysesRS.ToList().GetRange(0, point2.Index + 1));
continue;
}
// Copy out all of this segment
result.AddRange(paraSegs[i].AnalysesRS);
}
return(result);
}
/// <summary>
/// Tests to see if this AnalysisOccurrence is later in the text than the
/// parameter.
/// </summary>
/// <param name="otherPoint"></param>
/// <returns></returns>
public bool IsAfter(AnalysisOccurrence otherPoint)
{
if (Paragraph.Owner.Hvo != otherPoint.Paragraph.Owner.Hvo)
{
throw new ArgumentException("The two points are not from the same text!");
}
var imyPara = Paragraph.IndexInOwner;
var iotherPara = otherPoint.Paragraph.IndexInOwner;
if (imyPara > iotherPara)
{
return(true);
}
if (imyPara < iotherPara)
{
return(false);
}
var imySeg = Segment.IndexInOwner;
var iotherSeg = otherPoint.Segment.IndexInOwner;
if (imySeg > iotherSeg)
{
return(true);
}
if (imySeg < iotherSeg)
{
return(false);
}
var iother = otherPoint.Index;
return(Index > iother);
}
/// <summary>
/// Get all of the Analyses associated with a single ConstChartWordGroup.
/// Returns null if there is a problem finding them. Includes PunctuationForms.
/// </summary>
/// <returns></returns>
public IEnumerable<IAnalysis> GetAllAnalyses()
{
if (!IsValidRef)
return null;
var point1 = new AnalysisOccurrence(BeginSegmentRA, BeginAnalysisIndex);
var point2 = new AnalysisOccurrence(EndSegmentRA, EndAnalysisIndex);
return point1.GetAdvancingOccurrencesInclusiveOf(point2);
}
internal void CallGetWordGroupCellsBorderingChOrph(AnalysisOccurrence occurrence,
out ChartLocation precCell, out ChartLocation follCell)
{
var iPara = m_ccl.CallGetParaIndexForOccurrence(occurrence);
Assert.Greater(iPara, -1, "Can't get ChOrph paragraph index.");
var offset = occurrence.GetMyBeginOffsetInPara();
Assert.Greater(offset, -1, "Can't get ChOrph offset.");
m_ccl.GetWordGroupCellsBorderingChOrph(iPara, offset, out precCell, out follCell);
}
/// <summary>
/// Make one.
/// </summary>
/// <param name="cache"></param>
/// <param name="hvoRoot"></param>
public InterlinRibbon(FdoCache cache, int hvoRoot)
{
Cache = cache;
m_iEndSelLim = -1;
m_endSelLimPoint = null;
m_wsf = cache.WritingSystemFactory;
HvoRoot = hvoRoot;
ReadOnlyView = true;
m_fShowRangeSelAfterLostFocus = true;
}
/// <summary>
/// Create a new one.
/// </summary>
/// <param name="cache"></param>
/// <param name="ss"></param>
/// <param name="choices"></param>
/// <param name="mediator"></param>
public Sandbox(FdoCache cache, Mediator mediator, IVwStylesheet ss,
InterlinLineChoices choices, AnalysisOccurrence selected, FocusBoxController focusBox)
: this(cache, mediator, ss, choices)
{
FocusBox = focusBox;
m_interlinDoc = focusBox.InterlinDoc;
m_occurrenceSelected = selected;
// Finish initialization with occurrence context.
LoadForWordBundleAnalysis(m_occurrenceSelected.Analysis.Hvo);
}
/// <summary>
/// Saves the given AnalysisOccurrence in the InterlinMaster.
/// </summary>
/// <param name="point"></param>
/// <param name="fPersistNow">if true, this annotation will persist.</param>
/// <param name="index">The index of the selected text in the list</param>
public void Save(AnalysisOccurrence point, bool fPersistNow, int index, Mediator mediator)
{
if (point == null || !point.IsValid)
{
Reset(index, mediator); // let's just reset for an empty location.
return;
}
var iParaInText = point.Segment.Paragraph.IndexInOwner;
var begOffset = point.Segment.GetAnalysisBeginOffset(point.Index);
var endOffset = point.HasWordform ? begOffset + point.BaselineText.Length : begOffset;
Save(index, iParaInText, begOffset, endOffset, fPersistNow, mediator);
}
private void ParseText()
{
using (var pp = new ParagraphParser(Cache))
{
pp.Parse(m_txtPara);
}
var seg = m_txtPara.SegmentsOS[0];
var wordArray = seg.AnalysesRS.ToArray();
var cwords = wordArray.Length;
m_occurrences = new AnalysisOccurrence[cwords];
for (var i = 0; i < cwords; i++)
m_occurrences[i] = new AnalysisOccurrence(seg, i);
}
private static AnalysisOccurrence[] GetParaAnalyses(IStTxtPara para)
{
var result = new List<AnalysisOccurrence>();
var point1 = new AnalysisOccurrence(para.SegmentsOS[0], 0);
if (!point1.IsValid)
return result.ToArray();
do
{
if (point1.HasWordform)
result.Add(point1);
point1 = point1.NextWordform();
} while (point1 != null && point1.IsValid);
return result.ToArray();
}
public void RibbonLayout()
{
EndSetupTask();
// SUT#1 (but not one that changes data)
m_ribbon.MakeRoot();
m_ribbon.CallLayout();
Assert.IsNotNull(m_ribbon.RootBox, "layout should produce some root box");
var widthEmpty = m_ribbon.RootBox.Width;
var glosses = new AnalysisOccurrence[0];
// SUT#2 This changes data! Use a UOW.
UndoableUnitOfWorkHelper.Do("RibbonLayoutUndo", "RibbonLayoutRedo",
Cache.ActionHandlerAccessor, () => glosses = GetParaAnalyses(m_firstPara));
Assert.Greater(glosses.Length, 0);
var firstGloss = new List<AnalysisOccurrence> { glosses[0] };
// SUT#3 This changes some internal data! Use a UOW.
UndoableUnitOfWorkHelper.Do("CacheAnnsUndo", "CacheAnnsRedo", Cache.ActionHandlerAccessor,
() => m_ribbon.CacheRibbonItems(firstGloss));
m_ribbon.CallLayout();
int widthOne = m_ribbon.RootBox.Width;
int heightOne = m_ribbon.RootBox.Height;
Assert.IsTrue(widthOne > widthEmpty, "adding a wordform should make the root box wider");
var glossList = new List<AnalysisOccurrence>();
glossList.AddRange(glosses);
// SUT#4 This changes some internal data! Use a UOW.
UndoableUnitOfWorkHelper.Do("CacheAnnsUndo", "CacheAnnsRedo", Cache.ActionHandlerAccessor,
() => m_ribbon.CacheRibbonItems(glossList));
m_ribbon.CallLayout();
int widthMany = m_ribbon.RootBox.Width;
int heightMany = m_ribbon.RootBox.Height;
Assert.IsTrue(widthMany > widthOne, "adding more wordforms should make the root box wider");
// In a real view they might not be exactly equal due to subscripts and the like, but our
// text and anaysis are very simple.
Assert.AreEqual(heightOne, heightMany, "ribbon should not wrap!");
}
/// <summary>
/// Copy out IAnalysis objects from the end of this ISegment through the beginning of
/// parameter's ISegment (inclusive). Also copies objects from intervening ISegments.
/// Assumes parameter is in the same StTxtPara!
/// </summary>
/// <param name="point2"></param>
/// <returns></returns>
private IEnumerable<IAnalysis> CopyOutAnalysesFromMultipleSegments(AnalysisOccurrence point2)
{
// Need to copy out end of first segment, any segments in between and beginning of second segment
var result = new List<IAnalysis>();
var paraSegs = (Segment.Owner as IStTxtPara).SegmentsOS;
if (paraSegs == null)
throw new NullReferenceException("Unexpected error!");
for (var i = Segment.IndexInOwner; i <= point2.Segment.IndexInOwner; i++)
{
if (i == Segment.IndexInOwner)
{
// Copy out end of this segment
result.AddRange(paraSegs[i].AnalysesRS.ToList().GetRange(Index, Segment.AnalysesRS.Count - Index));
continue;
}
if (i == point2.Segment.IndexInOwner)
{
// Copy out beginning of this segment
result.AddRange(paraSegs[i].AnalysesRS.ToList().GetRange(0, point2.Index + 1));
continue;
}
// Copy out all of this segment
result.AddRange(paraSegs[i].AnalysesRS);
}
return result;
}
/// <summary>
/// Returns a sequence of IAnalysis objects inclusive of the current occurrence
/// and the end occurrence (otherAC). Parameter occurrence must occur AFTER 'this'
/// occurrence.
/// </summary>
/// <param name="point2">An AnalysisOccurrence</param>
/// <returns></returns>
public IEnumerable<IAnalysis> GetAdvancingOccurrencesInclusiveOf(AnalysisOccurrence point2)
{
if (!point2.IsValid)
throw new ArgumentException("Invalid Analysis Occurrence");
if (Segment == point2.Segment)
{
// Case 1: Two points in same ISegment object
if (Index > point2.Index)
throw new ArgumentException("Second AnalysisOccurrence is before the first!");
// Copy out sub-array of Analyses between the two ACs indices
return Segment.AnalysesRS.ToList().GetRange(Index, point2.Index - Index + 1);
}
if (Segment.Owner == point2.Segment.Owner)
{
// Case 2: Two points in different ISegment objects, but in same StTxtPara
if (Segment.IndexInOwner > point2.Segment.IndexInOwner)
throw new ArgumentException("Second AnalysisOccurrence is before the first!");
// Need to copy out end of first segment, any segments in between and beginning of second segment
return CopyOutAnalysesFromMultipleSegments(point2);
}
var para1 = Segment.Owner as IStTxtPara;
var para2 = point2.Segment.Owner as IStTxtPara;
if (!(para1.Owner as IStText).ParagraphsOS.Contains(para2))
{
throw new ArgumentOutOfRangeException("point2", "AnalysisOccurrences are not within the same Text!");
}
throw new NotImplementedException("So far we only handle this in same Segment or Paragraph.");
}
/// <summary>
/// More efficient equality if the other argument is known to be an AnalysisOccurrence.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(AnalysisOccurrence other)
{
return other.Segment == Segment && other.Index == Index;
}
/// <summary>
/// Verifies that the specified number of Analyses have been removed from
/// the start of the original list.
/// </summary>
/// <param name="allParaOccurrences"></param>
/// <param name="removedWords"></param>
/// <returns></returns>
private void AssertUsedAnalyses(AnalysisOccurrence[] allParaOccurrences, int removedWords)
{
m_helper.AssertUsedAnalyses(m_mockRibbon, allParaOccurrences, removedWords);
}
/// <summary>
///
/// </summary>
public bool TryGetBestGuess(AnalysisOccurrence occurrence, out IAnalysis bestGuess)
{
bestGuess = GetBestGuess(occurrence);
return(!(bestGuess is NullWAG));
}
private void ParseTestText()
{
// Seg: 0 1 2
// Index:0 1 2 3 0 1 2 3 0 1 2
// xxxpus xxxyalola xxxnihimbilira. xxxnihimbilira xxxpus xxxyalola. xxxhesyla xxxnihimbilira.
using (var pp = new ParagraphParser(Cache))
{
pp.Parse(m_para1);
}
var coords = new int[8, 2] { { 0, 0 }, { 0, 1 }, { 0, 2 }, { 1, 0 }, { 1, 1 }, { 1, 2 }, { 2, 0 }, { 2, 1 } };
m_occurrences = new AnalysisOccurrence[8];
for (int i = 0; i < 8; i++)
m_occurrences[i] = new AnalysisOccurrence(m_para1.SegmentsOS[coords[i, 0]], coords[i, 1]);
}
/// <summary>
/// Finds a real analysis in the segment from the indicated direction.
/// When used just to check if there is an analysis, the direction doesn't matter.
/// </summary>
/// <param name="seg">The seg.</param>
/// <param name="forward">if set to <c>true</c> find a real analysis looking forward.</param>
/// <returns>The analysis found or null</returns>
private AnalysisOccurrence FindRealAnalysisInSegment(ISegment seg, bool forward)
{
if (seg == null) return null;
int index = -1;
AnalysisOccurrence realAnalysis = null;
bool found = false;
for (int i = 0; i < seg.AnalysesRS.Count; i++)
{ // need to count to create occurances
index++;
int ind = forward ? index : seg.AnalysesRS.Count - index;
realAnalysis = new AnalysisOccurrence(seg, ind);
if (m_vc.CanBeAnalyzed(realAnalysis))
{
found = true;
break; // found the first or last real analysis
}
}
return found ? realAnalysis : null;
}
/// <summary>
/// Get the next segment with either a non-null annotation that is configured or
/// a non-punctuation analysis. Also skip segments that are Scripture labels (like
/// Chapter/Verse/Footnote numbers.
/// It tries the next one after the SelectedOccurrence.Segment
/// then tries the next paragraph, etc..
/// Use this version if the calling code already has the actual para/seg objects.
/// </summary>
/// <param name="currentPara"></param>
/// <param name="seg"></param>
/// <param name="upward">true if moving up and left, false otherwise</param>
/// <param name="realAnalysis">the first or last real analysis found in the next segment</param>
/// <returns>A segment meeting the criteria or null if not found.</returns>
private ISegment GetNextSegment(IStTxtPara currentPara, ISegment seg, bool upward,
out AnalysisOccurrence realAnalysis)
{
ISegment nextSeg = null;
realAnalysis = null;
var currentText = currentPara.Owner as IStText;
Debug.Assert(currentText != null, "Paragraph not owned by a text.");
var lines = LineChoices.m_specs as IEnumerable<InterlinLineSpec>;
var delta = upward ? -1 : 1;
var nextSegIndex = delta + seg.IndexInOwner;
do
{
if (0 <= nextSegIndex && nextSegIndex < currentPara.SegmentsOS.Count)
{
nextSeg = currentPara.SegmentsOS[nextSegIndex];
nextSegIndex += delta; // increment for next loop in case it doesn't check out
}
else
{ // try the first (last) segment in the next (previous) paragraph
int nextParaIndex = delta + currentPara.IndexInOwner;
nextSeg = null;
IStTxtPara nextPara = null;
if (0 <= nextParaIndex && nextParaIndex < currentText.ParagraphsOS.Count)
{ // try to find this paragraph's first (last) segment
currentPara = (IStTxtPara)currentText.ParagraphsOS[nextParaIndex];
nextSegIndex = upward ? currentPara.SegmentsOS.Count - 1 : 0;
}
else
{ // no more paragraphs in this text
break;
}
}
realAnalysis = FindRealAnalysisInSegment(nextSeg, !upward);
} while (nextSeg == null || (realAnalysis == null && !HasVisibleTranslationOrNote(nextSeg, lines)));
return nextSeg;
}
/// <summary>
/// Move the sandbox to the AnalysisOccurrence, (which may be a WfiWordform, WfiAnalysis, or WfiGloss).
/// </summary>
/// <param name="target"></param>
/// <param name="fSaveGuess">if true, saves guesses; if false, skips guesses but still saves edits.</param>
/// <param name="fMakeDefaultSelection">true to make the default selection within the new sandbox.</param>
/// <param name="fShow">true makes the focusbox visible.</param>
public virtual void TriggerAnalysisSelected(AnalysisOccurrence target, bool fSaveGuess, bool fMakeDefaultSelection, bool fShow)
{
// This can happen, though it is rare...see LT-8193.
if (!target.IsValid)
{
return;
}
if (IsFocusBoxInstalled)
FocusBox.UpdateRealFromSandbox(null, fSaveGuess, target);
TryHideFocusBoxAndUninstall();
RecordGuessIfNotKnown(target);
InstallFocusBox();
RootBox.DestroySelection();
FocusBox.SelectOccurrence(target);
SetFocusBoxSizeForVc();
SelectedOccurrence = target;
if (fShow)
{
SimulateReplaceAnalysis(target);
MoveFocusBoxIntoPlace();
// Now it is the right size and place we can show it.
TryShowFocusBox();
// All this CAN hapen because we're editing in another window...for example,
// if we edit something that deletes the current wordform in a concordance view.
// In that case we don't want to steal the focus.
if (ParentForm == Form.ActiveForm)
FocusBox.FocusSandbox();
}
if (fMakeDefaultSelection)
m_mediator.IdleQueue.Add(IdleQueuePriority.Medium, FocusBox.MakeDefaultSelection);
}
/// <summary>
/// Returns a sequence of IAnalysis objects inclusive of the current occurrence
/// and the end occurrence (otherAC).
/// </summary>
/// <param name="point2">An AnalysisOccurrence</param>
public IEnumerable <IAnalysis> GetAdvancingWordformsInclusiveOf(AnalysisOccurrence point2)
{
return(from occurrence in GetAdvancingOccurrencesInclusiveOf(point2)
where !(occurrence is IPunctuationForm)
select occurrence);
}
/// <summary>
/// More efficient equality if the other argument is known to be an AnalysisOccurrence.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Equals(AnalysisOccurrence other)
{
return(other.Segment == Segment && other.Index == Index);
}
/// <summary>
/// Verify that the parameter tag points to the right possibility marker
/// and that it refers to the correct begin and end points in the text.
/// </summary>
/// <param name="ttag"></param>
/// <param name="poss"></param>
/// <param name="point1"></param>
/// <param name="point2"></param>
private static void VerifyTextTag(ITextTag ttag, ICmPossibility poss,
AnalysisOccurrence point1, AnalysisOccurrence point2)
{
Assert.IsNotNull(ttag, "There should be a TextTag object.");
Assert.AreEqual(poss.Hvo, ttag.TagRA.Hvo, "Text Tag has wrong possibility Hvo.");
Assert.AreEqual(point1.Segment.Hvo, ttag.BeginSegmentRA.Hvo, "Tag has wrong BeginSegment");
Assert.AreEqual(point1.Index, ttag.BeginAnalysisIndex, "Tag has wrong BeginAnalysisIndex");
Assert.AreEqual(point2.Segment.Hvo, ttag.EndSegmentRA.Hvo, "Tag has wrong EndSegment");
Assert.AreEqual(point2.Index, ttag.EndAnalysisIndex, "Tag has wrong EndAnalysisIndex");
}
/// <summary>
/// Returns a sequence of IAnalysis objects inclusive of the current occurrence
/// and the end occurrence (otherAC).
/// </summary>
/// <param name="point2">An AnalysisOccurrence</param>
public IEnumerable<IAnalysis> GetAdvancingWordformsInclusiveOf(AnalysisOccurrence point2)
{
return from occurrence in GetAdvancingOccurrencesInclusiveOf(point2)
where !(occurrence is IPunctuationForm)
select occurrence;
}
/// <summary>
/// Tests to see if this AnalysisOccurrence is later in the text than the
/// parameter.
/// </summary>
/// <param name="otherPoint"></param>
/// <returns></returns>
public bool IsAfter(AnalysisOccurrence otherPoint)
{
if(Paragraph.Owner.Hvo != otherPoint.Paragraph.Owner.Hvo)
throw new ArgumentException("The two points are not from the same text!");
var imyPara = Paragraph.IndexInOwner;
var iotherPara = otherPoint.Paragraph.IndexInOwner;
if (imyPara > iotherPara)
return true;
if (imyPara < iotherPara)
return false;
var imySeg = Segment.IndexInOwner;
var iotherSeg = otherPoint.Segment.IndexInOwner;
if (imySeg > iotherSeg)
return true;
if (imySeg < iotherSeg)
return false;
var iother = otherPoint.Index;
return Index > iother;
}
internal void RecordGuessIfNotKnown(AnalysisOccurrence selected)
{
if (m_vc != null) // I think this only happens in tests.
m_vc.RecordGuessIfNotKnown(selected);
}
/// <summary>
/// Select the word indicated by the occurrence.
/// Note that this does not save any changes made in the Sandbox. It is mainly used
/// when the view is read-only.
/// </summary>
public override void SelectOccurrence(AnalysisOccurrence target)
{
if (target == null)
{
TryHideFocusBoxAndUninstall();
return;
}
if (SelectedOccurrence == target && IsFocusBoxInstalled)
{
// Don't steal the focus from another window. See FWR-1795.
if (ParentForm == Form.ActiveForm)
{
if (ExistingFocusBox.CanFocus)
{
ExistingFocusBox.Focus(); // important when switching tabs with ctrl-tab.
}
else
{
VisibleChanged += FocusWhenVisible;
}
}
return;
}
if (!m_vc.CanBeAnalyzed(target))
return;
#if DEBUG
// test preconditions.
Debug.Assert(target.IsValid && !(target.Analysis is IPunctuationForm), "Given annotation type should not be punctuation"
+ " but was " + target.Analysis.ShortName + ".");
#endif
TriggerAnnotationSelected(target, true);
}
/// <summary>
/// Move the sandbox (see main method), making the default selection.
/// </summary>
/// <param name="target"></param>
/// <param name="fSaveGuess">if true, saves guesses; if false, skips guesses but still saves edits.</param>
public void TriggerAnnotationSelected(AnalysisOccurrence target, bool fSaveGuess)
{
TriggerAnalysisSelected(target, fSaveGuess, true);
}
/// <summary>
/// Approve all the suggested analyses in this text. See LT-4312.
/// </summary>
/// <param name="cmd">The command object from the selection event.</param>
public void ApproveAllSuggestedAnalyses(Command cmd)
{ // Go through the entire text looking for suggested analyses that can be approved.
// remember where the focus box or ip is
// might be on an analysis, labels or translation text
var helper = SelectionHelper.Create(RootBox.Site); // only helps restore translation and note line selections
AnalysisOccurrence focusedWf = SelectedOccurrence; // need to restore focus box if selected
// find the very first analysis
ISegment firstRealSeg = null;
IAnalysis firstRealOcc = null;
int occInd = 0;
foreach (IStPara p in RootStText.ParagraphsOS)
{
var para = (IStTxtPara) p;
foreach (ISegment seg in para.SegmentsOS)
{
firstRealSeg = seg;
occInd = 0;
foreach(IAnalysis an in seg.AnalysesRS)
{
if (an.HasWordform && an.IsValidObject)
{
firstRealOcc = an;
break;
}
occInd++;
}
if (firstRealOcc != null) break;
}
if (firstRealOcc != null) break;
}
// Set it as the current segment and recurse
if (firstRealOcc == null)
return; // punctuation only or nothing to analyze
AnalysisOccurrence ao = null;
if (focusedWf != null && focusedWf.Analysis == firstRealOcc)
ao = new AnalysisOccurrence(focusedWf.Segment, focusedWf.Index);
else
ao = new AnalysisOccurrence(firstRealSeg, occInd);
TriggerAnalysisSelected(ao, true, true, false);
var navigator = new SegmentServices.StTextAnnotationNavigator(ao);
// This needs to be outside the block for the UOW, since what we are suppressing
// happens at the completion of the UOW.
SuppressResettingGuesses(
() =>
{
// Needs to include GetRealAnalysis, since it might create a new one.
UndoableUnitOfWorkHelper.Do(cmd.UndoText, cmd.RedoText, Cache.ActionHandlerAccessor,
() =>
{
var nav = new SegmentServices.StTextAnnotationNavigator(SelectedOccurrence);
AnalysisOccurrence lastOccurrence;
var analyses = navigator.GetAnalysisOccurrencesAdvancingInStText().ToList();
foreach (var occ in analyses)
{ // This could be punctuation or any kind of analysis.
IAnalysis occAn = occ.Analysis; // averts “Access to the modified closure” warning in resharper
if (occAn is IWfiAnalysis || occAn is IWfiWordform)
{ // this is an analysis or a wordform
int hvo = m_vc.GetGuess(occAn);
if (occAn.Hvo != hvo)
{ // this is a guess, so approve it
// 1) A second occurence of a word that has had a lexicon entry or sense created for it.
// 2) A parser result - not sure which gets picked if multiple.
// #2 May take a while to "percolate" through to become a "guess".
var guess = Cache.ServiceLocator.ObjectRepository.GetObject(hvo);
if (guess != null && guess is IAnalysis)
occ.Segment.AnalysesRS[occ.Index] = (IAnalysis) guess;
else
{
occ.Segment.AnalysesRS[occ.Index] = occAn.Wordform.AnalysesOC.FirstOrDefault();
}
}
/* else if (occAn.HasWordform && occAn.Wordform.ParserCount > 0)
{ // this doesn't seem to be needed (and may not be correct) - always caught above
bool isHumanNoOpinion = occAn.Wordform.HumanNoOpinionParses.Cast<IWfiWordform>().Any(wf => wf.Hvo == occAn.Hvo);
if (isHumanNoOpinion)
{
occ.Segment.AnalysesRS[occ.Index] = occAn.Wordform.AnalysesOC.FirstOrDefault();
}
} */
}
}
});
}
);
// MoveFocusBoxIntoPlace();
if (focusedWf != null)
SelectOccurrence(focusedWf);
else if (helper != null)
helper.SetSelection(true, true);
Update();
}
public override void SelectOccurrence(AnalysisOccurrence selected)
{
// when we change wordforms we should create a new Analysis Tree, so we don't
// overwrite the last state of one we may have saved during the tests.
if (m_sandbox != null && selected != SelectedOccurrence)
(m_sandbox as MockSandbox).NewAnalysisTree = new AnalysisTree();
base.SelectOccurrence(selected);
}
/// <summary>
/// Move the sandbox to the AnalysisOccurrence, (which may be a WfiWordform, WfiAnalysis, or WfiGloss).
/// </summary>
/// <param name="target"></param>
/// <param name="fSaveGuess">if true, saves guesses; if false, skips guesses but still saves edits.</param>
/// <param name="fMakeDefaultSelection">true to make the default selection within the new sandbox.</param>
public virtual void TriggerAnalysisSelected(AnalysisOccurrence target, bool fSaveGuess, bool fMakeDefaultSelection)
{
TriggerAnalysisSelected(target, fSaveGuess, fMakeDefaultSelection, true);
}
void IAnalysisControlInternal.SwitchWord(AnalysisOccurrence selected)
{
CurrentAnalysisTree.Analysis = selected.Analysis;
NewAnalysisTree.Analysis = selected.Analysis;
}
/// <summary>
/// Something about the display of the AnalysisOccurrence has changed...perhaps it has become or ceased to
/// be the current annotation displayed using the Sandbox, or the Sandbox changed size. Produce
/// a PropChanged that makes the system think it has been replaced (with itself) to refresh the
/// relevant part of the display.
/// </summary>
void SimulateReplaceAnalysis(AnalysisOccurrence occurrence)
{
UpdateDisplayForOccurrence(occurrence);
}
public override void SelectOccurrence(AnalysisOccurrence target)
{
InstallFocusBox();
FocusBox.SelectOccurrence(target);
}
/// <summary>
/// Get the next segment with either a non-null annotation that is configured or
/// a non-punctuation analysis.
/// It tries the next one after the SelectedOccurrence.Segment
/// then tries the next paragraph, etc..
/// </summary>
/// <param name="paraIndex"></param>
/// <param name="segIndex"></param>
/// <param name="upward">true if moving up and left, false otherwise</param>
/// <param name="realAnalysis">the first or last real analysis found in the next segment</param>
/// <returns>A segment meeting the criteria or null if not found.</returns>
internal ISegment GetNextSegment(int paraIndex, int segIndex, bool upward, out AnalysisOccurrence realAnalysis)
{
var currentPara = (IStTxtPara)RootStText.ParagraphsOS[paraIndex];
Debug.Assert(currentPara != null, "Tried to use a null paragraph ind=" + paraIndex);
ISegment currentSeg = currentPara.SegmentsOS[segIndex];
Debug.Assert(currentSeg != null, "Tried to use a null segment ind=" + segIndex + " in para " + paraIndex);
return GetNextSegment(currentPara, currentSeg, upward, out realAnalysis);
}
internal override IAnalysisControlInternal CreateNewSandbox(AnalysisOccurrence selected)
{
var sandbox = new MockSandbox();
sandbox.CurrentAnalysisTree.Analysis = selected.Analysis;
sandbox.NewAnalysisTree.Analysis = selected.Analysis;
return sandbox;
}