protected override void HandleSelectionChange(IVwRootBox rootb, IVwSelection vwselNew)
{
CheckDisposed();
base.HandleSelectionChange(rootb, vwselNew);
// JohnT: it's remotely possible that the base, in calling commit, made this
// selection no longer useable.
if (!vwselNew.IsValid)
{
return;
}
IWfiWordform wordform;
if (!GetSelectedWordform(vwselNew, out wordform))
{
wordform = null;
}
m_mediator.PropertyTable.SetProperty("TextSelectedWord", wordform);
m_mediator.PropertyTable.SetPropertyPersistence("TextSelectedWord", false);
SelectionHelper helper = SelectionHelper.Create(vwselNew, this);
if (helper != null && helper.GetTextPropId(SelectionHelper.SelLimitType.Anchor) == RawTextVc.kTagUserPrompt)
{
vwselNew.ExtendToStringBoundaries();
EditingHelper.SetKeyboardForSelection(vwselNew);
}
}
private bool DisplayOption(object option)
{
RuleInsertType type = ((InsertOption)option).Type;
SelectionHelper sel = SelectionHelper.Create(m_view);
int cellId = GetCell(sel);
if (cellId == -1 || cellId == -2)
{
return(false);
}
switch (cellId)
{
case AffixRuleFormulaVc.ktagLeftEmpty:
case AffixRuleFormulaVc.ktagRightEmpty:
return(type != RuleInsertType.Index);
case MoAffixProcessTags.kflidOutput:
return(type == RuleInsertType.Index || type == RuleInsertType.Phoneme || type == RuleInsertType.MorphemeBoundary);
default:
var ctxtOrVar = m_cache.ServiceLocator.GetInstance <IPhContextOrVarRepository>().GetObject(cellId);
if (ctxtOrVar.ClassID == PhVariableTags.kClassId)
{
return(false);
}
return(type != RuleInsertType.Index);
}
}
/// <summary>
/// Try to find a WfiWordform object corresponding the the focus selection.
/// If successful return its guid, otherwise, return Guid.Empty.
/// </summary>
/// <returns></returns>
private ITsString ActiveWord()
{
if (InFriendliestTool)
{
// we should be able to get our info from the current record clerk.
// but return null if we can't get the info, otherwise we allow the user to
// bring up the change spelling dialog and crash because no wordform can be found (LT-8766).
var clerk = m_propertyTable.GetValue <RecordClerk>("ActiveClerk");
var tssVern = (clerk?.CurrentObject as IWfiWordform)?.Form?.BestVernacularAlternative;
return(tssVern);
}
var app = m_propertyTable.GetValue <IApp>("App");
var roots = (app?.ActiveMainWindow as FwXWindow)?.ActiveView?.AllRootBoxes();
if (roots == null || roots.Count < 1 || roots[0] == null)
{
return(null);
}
var tssWord = SelectionHelper.Create(roots[0].Site)?.SelectedWord;
if (tssWord != null)
{
// Check for a valid vernacular writing system. (See LT-8892.)
var ws = TsStringUtils.GetWsAtOffset(tssWord, 0);
var cache = m_propertyTable.GetValue <LcmCache>("cache");
CoreWritingSystemDefinition wsObj = cache.ServiceLocator.WritingSystemManager.Get(ws);
if (cache.ServiceLocator.WritingSystems.VernacularWritingSystems.Contains(wsObj))
{
return(tssWord);
}
}
return(null);
}
private bool CanAddWordBoundary(object option)
{
if (m_patternModel.Root.IsLeaf)
{
return(true);
}
SelectionHelper sel = SelectionHelper.Create(m_view);
if (sel.IsRange)
{
return(false);
}
ComplexConcPatternNode parent;
int index;
GetInsertionIndex(sel, out parent, out index);
if (parent.IsLeaf)
{
return(false);
}
if (index == 0)
{
return(parent.Children[index] is ComplexConcMorphNode);
}
if (index == parent.Children.Count)
{
return(parent.Children[index - 1] is ComplexConcMorphNode);
}
return(parent.Children[index - 1] is ComplexConcMorphNode && parent.Children[index] is ComplexConcMorphNode);
}
private bool DisplayColumnOption(object option)
{
SelectionHelper sel = SelectionHelper.Create(m_view);
if (sel.IsRange)
{
return(false);
}
int cellId = GetCell(sel);
if (cellId == -1 || cellId == -2)
{
return(false);
}
switch (cellId)
{
case AffixRuleFormulaVc.ktagLeftEmpty:
case AffixRuleFormulaVc.ktagRightEmpty:
case MoAffixProcessTags.kflidOutput:
return(false);
default:
return(GetColumnInsertIndex(sel) != -1);
}
}
public void MoveIPToStartOfNextFootnoteViaRightKey()
{
((IStTxtPara)m_Jude.FootnotesOS[1].ParagraphsOS[0]).Contents =
TsStringUtils.MakeTss(string.Empty, Cache.DefaultVernWs);
// Put IP at the beginning of the first footnote.
MakeFootnoteSelection(1, 0, 0);
// Use the End key to get the IP to the end of the first footnote.
m_footnoteView.OnKeyDown(new KeyEventArgs(Keys.End));
// Verify we're still in footnote zero.
SelectionHelper selHelper = SelectionHelper.Create(m_footnoteView);
Assert.AreEqual(0, selHelper.LevelInfo[1].ihvo, "Selection should still be in footnote 0");
// Now simulate pressing the Right key.
m_footnoteView.OnKeyDown(new KeyEventArgs(Keys.Right));
// Check results
selHelper = SelectionHelper.Create(m_footnoteView);
Assert.AreEqual(1, selHelper.LevelInfo[1].ihvo, "Selection should have moved to next footnote");
Assert.AreEqual(0, selHelper.IchAnchor, "IchAnchor should be at start of footnote");
Assert.AreEqual(0, selHelper.IchEnd, "IchEnd should be at start of footnote");
}
private bool CanAddConstraint(object option)
{
if (m_patternModel.Root.IsLeaf)
{
return(true);
}
SelectionHelper sel = SelectionHelper.Create(m_view);
ComplexConcPatternNode anchorNode = GetNode(sel, SelectionHelper.SelLimitType.Anchor);
ComplexConcPatternNode endNode = GetNode(sel, SelectionHelper.SelLimitType.End);
if (anchorNode == null || endNode == null || anchorNode.Parent != endNode.Parent)
{
return(false);
}
ComplexConcPatternNode parent;
int start, end;
if (!sel.IsRange)
{
int index;
GetInsertionIndex(sel, out parent, out index);
start = index - 1;
end = index;
}
else
{
parent = anchorNode.Parent;
start = (sel.Selection.EndBeforeAnchor ? GetNodeIndex(endNode) : GetNodeIndex(anchorNode)) - 1;
end = (sel.Selection.EndBeforeAnchor ? GetNodeIndex(anchorNode) : GetNodeIndex(endNode)) + 1;
}
return((start == -1 || !(parent.Children[start] is ComplexConcWordBdryNode)) && (end == parent.Children.Count || !(parent.Children[end] is ComplexConcWordBdryNode)));
}
public void GoToNextSection()
{
FdoOwningSequence <IScrBook> books = m_scr.ScriptureBooksOS;
// Start in the title of the second book.
m_draftView.TeEditingHelper.SetInsertionPoint((int)ScrBook.ScrBookTags.kflidTitle, 1, 0);
m_draftView.TeEditingHelper.GoToNextSection();
VerifySelection(4, 1, 0, (int)ScrSection.ScrSectionTags.kflidHeading, 0, 0);
// Start in the last section of the first book.
IScrBook book = books[0];
m_draftView.TeEditingHelper.SetInsertionPoint((int)ScrSection.ScrSectionTags.kflidContent,
0, book.SectionsOS.Count - 1);
m_draftView.TeEditingHelper.GoToNextSection();
VerifySelection(4, 1, 0, (int)ScrSection.ScrSectionTags.kflidHeading, 0, 0);
// Start in the last para of the contents of the last section of the last book.
int iBook = books.Count - 1;
book = books[iBook];
int iSection = book.SectionsOS.Count - 1;
IScrSection lastSection = book.SectionsOS[iSection];
int iPara = lastSection.ContentOA.ParagraphsOS.Count - 1;
m_draftView.TeEditingHelper.SetInsertionPoint(iBook, iSection, iPara, 2, true);
// Nothing should move
m_draftView.TeEditingHelper.GoToNextSection();
VerifySelection(4, iBook, iSection, (int)ScrSection.ScrSectionTags.kflidContent,
2, 2);
// Check the para
SelectionHelper selHelper = SelectionHelper.Create(m_draftView);
Assert.AreEqual(iPara, selHelper.LevelInfo[0].ihvo);
// Start with a multi-text range selection
IScrBook startBook = books[0];
m_draftView.TeEditingHelper.SetInsertionPoint((int)ScrSection.ScrSectionTags.kflidHeading,
0, startBook.SectionsOS.Count - 2);
IVwSelection vwsel1 = m_draftView.RootBox.Selection;
m_draftView.TeEditingHelper.SetInsertionPoint((int)ScrSection.ScrSectionTags.kflidContent,
0, startBook.SectionsOS.Count - 3);
IVwSelection vwsel2 = m_draftView.RootBox.Selection;
m_draftView.RootBox.MakeRangeSelection(vwsel1, vwsel2, true);
m_draftView.TeEditingHelper.GoToNextSection();
VerifySelection(4, 0, startBook.SectionsOS.Count - 1,
(int)ScrSection.ScrSectionTags.kflidHeading, 0, 0);
}
/// <summary>
/// Sets the alpha variables on the currently selected natural class simple context.
/// </summary>
public void SetContextVariables()
{
SelectionHelper sel = SelectionHelper.Create(m_view);
bool reconstruct = false;
using (new UndoRedoTaskHelper(m_cache, MEStrings.ksRegRuleUndoSetVariables, MEStrings.ksRegRuleRedoSetVariables))
{
using (FeatureConstraintChooserDlg featChooser = new FeatureConstraintChooserDlg())
{
IPhSimpleContextNC ctxt = new PhSimpleContextNC(m_cache, CurrentContextHvo);
featChooser.SetDlgInfo(m_cache, Mediator, new PhRegularRule(m_cache, RHS.OwnerHVO), ctxt);
DialogResult res = featChooser.ShowDialog();
if (res != DialogResult.Cancel)
{
featChooser.HandleJump();
}
reconstruct = res == DialogResult.OK;
}
}
m_view.Select();
if (reconstruct)
{
m_view.RootBox.Reconstruct();
sel.RestoreSelectionAndScrollPos();
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handle Mouse up
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void OnMouseUp(MouseEventArgs e)
{
if (e.Button != MouseButtons.Right)
{
base.OnMouseUp(e);
return;
}
NotesMainWnd notesMainWnd = TheMainWnd as NotesMainWnd;
if (notesMainWnd == null || notesMainWnd.TMAdapter == null)
{
return;
}
Rectangle rcSrcRoot;
Rectangle rcDstRoot;
GetCoordRects(out rcSrcRoot, out rcDstRoot);
Point pt = new Point(e.X, e.Y);
IVwSelection sel = m_rootb.MakeSelAt(pt.X, pt.Y, rcSrcRoot, rcDstRoot, false);
int noteHvo = 0;
if (sel != null)
{
SelectionHelper selHelper = SelectionHelper.Create(sel, this);
SelLevInfo annInfo = selHelper.GetLevelInfoForTag(m_currentNotesTag);
noteHvo = annInfo.hvo;
}
pt = PointToScreen(new Point(e.X, e.Y));
notesMainWnd.TMAdapter.PopupMenu("cmnuNotesDataEntryView", pt.X, pt.Y);
}
public void GetBookHvoWithFootnotes()
{
IScripture scr = Cache.LangProject.TranslatedScriptureOA;
IScrBook genesis = scr.ScriptureBooksOS[0];
// Add a footnote in the first book, first section, first paragraph
IScrSection section = genesis.SectionsOS[0];
IStFootnote footnote = AddFootnote(genesis,
(IStTxtPara)section.ContentOA.ParagraphsOS[0], 2, "A footnote");
m_ScrPubCtrl.CallRefreshDisplay();
m_ScrPubCtrl.CreatePages();
m_ScrPubCtrl.PrepareToDrawPages(0, m_ScrPubCtrl.AutoScrollMinSize.Height * 2);
// Simulate setting the IP at the beginning of the footnote
bool fFoundPageWithFootnotes = false;
foreach (DummyPage page in m_ScrPubCtrl.Pages)
{
if (page.DependentObjectsRootStream != null)
{
fFoundPageWithFootnotes = true;
((IVwRootBox)page.DependentObjectsRootStream).MakeSimpleSel(true, true, false, true);
m_ScrPubCtrl.FocusedStream = page.DependentObjectsRootStream;
break;
}
}
Assert.IsTrue(fFoundPageWithFootnotes, "Can't run this test without finding any footnotes");
SelectionHelper selHelper = SelectionHelper.Create(m_ScrPubCtrl);
IScrBook book = m_ScrPubCtrl.GetBook(selHelper, SelectionHelper.SelLimitType.Anchor);
Assert.AreEqual(genesis, book);
}
/// <summary>
/// Sets the alpha variables on the currently selected natural class simple context.
/// </summary>
public void SetContextVariables()
{
var sel = SelectionHelper.Create(m_view);
bool reconstruct = false;
UndoableUnitOfWorkHelper.Do(MEStrings.ksRegRuleUndoSetVariables, MEStrings.ksRegRuleRedoSetVariables, RHS, () =>
{
using (var featChooser = new FeatureConstraintChooserDlg())
{
var ctxt = CurrentContext as IPhSimpleContextNC;
featChooser.SetDlgInfo(m_cache, Mediator, RHS.OwningRule, ctxt);
DialogResult res = featChooser.ShowDialog();
if (res != DialogResult.Cancel)
{
featChooser.HandleJump();
}
reconstruct = res == DialogResult.OK;
}
});
m_view.Select();
if (reconstruct)
{
m_view.RootBox.Reconstruct();
sel.RestoreSelectionAndScrollPos();
}
}
private void InstallTextRangeSelection()
{
// create a new selection based off our Editable range and install it.
var sh = SelectionHelper.Create(Selection, m_site);
sh.SetSelection(m_site, true, true);
}
private bool DisplayVariableOption(object option)
{
SelectionHelper sel = SelectionHelper.Create(m_view);
int cellId = GetCell(sel);
if (cellId == -1 || cellId == -2)
{
return(false);
}
switch (cellId)
{
case AffixRuleFormulaVc.ktagLeftEmpty:
case AffixRuleFormulaVc.ktagRightEmpty:
return(true);
case MoAffixProcessTags.kflidOutput:
return(false);
default:
var ctxtOrVar = m_cache.ServiceLocator.GetInstance <IPhContextOrVarRepository>().GetObject(cellId);
if (ctxtOrVar.ClassID == PhSequenceContextTags.kClassId)
{
var seqCtxt = (IPhSequenceContext)ctxtOrVar;
if (seqCtxt.MembersRS.Count == 0)
{
return(true);
}
}
return(false);
}
}
void Tag_Item_Click(object sender, EventArgs e)
{
var item = sender as TagPossibilityMenuItem;
if (item == null)
{
return;
}
// save current selection info. (e.g. EnsureSelectedWordformsAndSegAreAllReal() can destroy it).
var sh = SelectionHelper.Create(this);
if (item.Checked)
{
UndoableUnitOfWorkHelper.Do(ITextStrings.ksUndoDeleteTextTag, ITextStrings.ksRedoDeleteTextTag,
Cache.ActionHandlerAccessor, () => RemoveTextTagInstance(item.Possibility));
}
else
{
UndoableUnitOfWorkHelper.Do(ITextStrings.ksUndoAddTextTag, ITextStrings.ksRedoAddTextTag,
Cache.ActionHandlerAccessor, () => MakeTextTagInstance(item.Possibility));
}
// We might try later to see if we can do without this! Nope.
if (sh != null)
{
sh.RestoreSelectionAndScrollPos();
}
}
/// <summary>
/// Try to keep the selection from including any of the characters in a writing system label.
/// See LT-8396.
/// </summary>
protected override void HandleSelectionChange(IVwRootBox prootb, IVwSelection vwselNew)
{
base.HandleSelectionChange(prootb, vwselNew);
// 1) We don't want to recurse into here.
// 2) If the selection is invalid we can't use it.
// 3) If the selection is entirely formattable ("IsSelectionInOneFormattableProp"), we don't need to do
// anything.
if (s_fProcessingSelectionChanged || !vwselNew.IsValid || EditingHelper.IsSelectionInOneFormattableProp())
{
return;
}
try
{
s_fProcessingSelectionChanged = true;
SelectionHelper hlpr = SelectionHelper.Create(vwselNew, this);
bool fRange = hlpr.IsRange;
bool fChangeRange = false;
if (fRange)
{
bool fAnchorEditable = vwselNew.IsEditable;
hlpr.GetIch(SelectionHelper.SelLimitType.Anchor);
int tagAnchor = hlpr.GetTextPropId(SelectionHelper.SelLimitType.Anchor);
hlpr.GetIch(SelectionHelper.SelLimitType.End);
int tagEnd = hlpr.GetTextPropId(SelectionHelper.SelLimitType.End);
bool fEndBeforeAnchor = vwselNew.EndBeforeAnchor;
if (fEndBeforeAnchor)
{
if (fAnchorEditable && tagAnchor > 0 && tagEnd < 0)
{
hlpr.SetTextPropId(SelectionHelper.SelLimitType.End, tagAnchor);
hlpr.SetIch(SelectionHelper.SelLimitType.End, 0);
fChangeRange = true;
}
}
else
{
if (!fAnchorEditable && tagAnchor < 0 && tagEnd > 0)
{
hlpr.SetTextPropId(SelectionHelper.SelLimitType.Anchor, tagEnd);
hlpr.SetIch(SelectionHelper.SelLimitType.Anchor, 0);
fChangeRange = true;
}
}
}
if (fChangeRange)
{
hlpr.SetSelection(true);
}
}
finally
{
s_fProcessingSelectionChanged = false;
}
}
private string DisplayNoOptsMsg()
{
SelectionHelper sel = SelectionHelper.Create(m_view);
int cellId = GetCell(sel);
if (cellId == -1 || cellId == 2)
{
return(null);
}
return(MEStrings.ksAffixRuleNoOptsMsg);
}
/// <summary>
/// Sets the number of occurrences of a context.
/// </summary>
/// <param name="min">The min.</param>
/// <param name="max">The max.</param>
public void SetContextOccurrence(int min, int max)
{
CheckDisposed();
SelectionHelper sel = SelectionHelper.Create(m_view);
int cellId = GetCell(sel);
ICmObject obj = GetCmObject(sel, SelectionHelper.SelLimitType.Anchor);
var ctxt = (IPhPhonContext)obj;
int index = -1;
UndoableUnitOfWorkHelper.Do(MEStrings.ksRegRuleUndoSetOccurrence, MEStrings.ksRegRuleRedoSetOccurrence, ctxt, () =>
{
if (ctxt.ClassID == PhIterationContextTags.kClassId)
{
// if there is an existing iteration context, just update it or remove it if it can occur only once
var iterCtxt = (IPhIterationContext)ctxt;
if (min == 1 && max == 1)
{
// We want to replace the iteration context with the original (simple?) context which it
// specifies repeat counts for. That is, we will replace the iterCtxt with its own MemberRA.
// Then we will delete the iteration context (false argument).
// We have to do this carefully, however, because when a PhIterationContext is deleted,
// it also deletes its MemberRA. So if the MemberRA is still linked to the simple context,
// both get deleted, and the replace unexpectedly fails (LT-13566).
// So, we must break the link before we do the replacement.
IPhPhonContext temp = iterCtxt.MemberRA;
iterCtxt.MemberRA = null;
index = OverwriteContext(temp, iterCtxt, cellId == PhSegRuleRHSTags.kflidLeftContext, false);
}
else
{
iterCtxt.Minimum = min;
iterCtxt.Maximum = max;
}
}
else if (min != 1 || max != 1)
{
// create a new iteration context
IPhIterationContext iterCtxt = m_cache.ServiceLocator.GetInstance <IPhIterationContextFactory>().Create();
index = OverwriteContext(iterCtxt, ctxt, cellId == PhSegRuleRHSTags.kflidLeftContext, true);
iterCtxt.MemberRA = ctxt;
iterCtxt.Minimum = min;
iterCtxt.Maximum = max;
}
});
if (index == -1)
{
IPhPhonContext envCtxt = cellId == PhSegRuleRHSTags.kflidLeftContext ? Rhs.LeftContextOA : Rhs.RightContextOA;
IPhSequenceContext seqCtxt;
index = GetIndex(ctxt, envCtxt, out seqCtxt);
}
ReconstructView(cellId, index, true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Deletes a footnote
/// </summary>
/// <param name="args"></param>
/// <returns><c>true</c> if we handle this</returns>
/// ------------------------------------------------------------------------------------
protected bool OnDeleteFootnote(object args)
{
if (DataUpdateMonitor.IsUpdateInProgress(DataAccess))
{
return(true); //discard this event
}
if (!ValidFootnoteSelection)
{
return(true);
}
string undo;
string redo;
TeResourceHelper.MakeUndoRedoLabels("kstidUndoDelFootnote", out undo, out redo);
using (new UndoTaskHelper(this, undo, redo, false))
using (new DataUpdateMonitor(this, RootBox.DataAccess, this, "DeleteFootnote"))
{
SelectionHelper helper = SelectionHelper.Create(this);
int fnLevel = helper.GetLevelForTag((int)ScrBook.ScrBookTags.kflidFootnotes);
if (helper.Selection.IsRange)
{
DeleteFootnoteRange(helper);
}
else
{
// There's no range selection, so delete only one footnote
ScrFootnote footnote = new ScrFootnote(m_fdoCache, helper.LevelInfo[fnLevel].hvo);
ScrFootnote.DeleteFootnoteAndMarker(footnote);
}
if (RootBox.Height <= 0)
{
DraftView.Focus();
}
else
{
int iBook = helper.LevelInfo[fnLevel + 1].ihvo;
ScrBook book = m_bookFilter.GetBook(iBook);
int iFootnote = helper.LevelInfo[fnLevel].ihvo;
// If the last footnote in the book was deleted find a footnote to move to
if (iFootnote >= book.FootnotesOS.Count)
{
FindNearestFootnote(ref iBook, ref iFootnote);
}
FootnoteEditingHelper.ScrollToFootnote(iBook, iFootnote, 0);
}
}
return(true);
}
public bool OnDisplayPatternNodeSetCriteria(object commandObject, ref UIItemDisplayProperties display)
{
CheckDisposed();
SelectionHelper sel = SelectionHelper.Create(m_view);
ComplexConcPatternNode[] nodes = CurrentNodes;
bool enable = sel.IsRange && nodes.Length == 1 && (nodes[0] is ComplexConcWordNode || nodes[0] is ComplexConcMorphNode || nodes[0] is ComplexConcTagNode);
display.Enabled = enable;
display.Visible = enable;
return(true);
}
public bool OnDisplayPatternNodeSetOccurrence(object commandObject, ref UIItemDisplayProperties display)
{
CheckDisposed();
SelectionHelper sel = SelectionHelper.Create(m_view);
ComplexConcPatternNode[] nodes = CurrentNodes;
bool enable = sel.IsRange && !(nodes[0] is ComplexConcOrNode) && !(nodes[nodes.Length - 1] is ComplexConcOrNode);
display.Enabled = enable;
display.Visible = enable;
return(true);
}
/// <summary>
/// Update the new selection. This is called by rule formula view when selection changes.
/// </summary>
/// <param name="vwselNew">The new selection.</param>
private void UpdateSelection(IVwSelection vwselNew)
{
CheckDisposed();
SelectionHelper sel = SelectionHelper.Create(vwselNew, this);
if (sel != null)
{
object ctxt = m_patternControl.GetContext(sel);
// if context is null then we are trying to select outside of a single context
if (ctxt == null)
{
if (sel.IsRange)
{
// ensure that a range selection only occurs within one context
object topCtxt = m_patternControl.GetContext(sel, SelectionHelper.SelLimitType.Top);
object bottomCtxt = m_patternControl.GetContext(sel, SelectionHelper.SelLimitType.Bottom);
var limit = SelectionHelper.SelLimitType.Top;
if (topCtxt != null)
{
limit = SelectionHelper.SelLimitType.Top;
ctxt = topCtxt;
}
else if (bottomCtxt != null)
{
limit = SelectionHelper.SelLimitType.Bottom;
ctxt = bottomCtxt;
}
if (ctxt != null)
{
IVwSelection newSel = SelectCell(ctxt, limit == SelectionHelper.SelLimitType.Bottom, false);
sel.ReduceToIp(limit);
IVwSelection otherSel = sel.SetSelection(this, false, false);
if (sel.Selection.EndBeforeAnchor)
{
RootBox.MakeRangeSelection(limit == SelectionHelper.SelLimitType.Top ? newSel : otherSel,
limit == SelectionHelper.SelLimitType.Top ? otherSel : newSel, true);
}
else
{
RootBox.MakeRangeSelection(limit == SelectionHelper.SelLimitType.Top ? otherSel : newSel,
limit == SelectionHelper.SelLimitType.Top ? newSel : otherSel, true);
}
}
}
}
else
{
AdjustSelection(sel);
}
}
}
public void MoveIPToStartOfCurrentFootnoteViaLeftKey()
{
// Put IP at the second editable character in the first footnote.
MakeFootnoteSelection(1, 0, 1);
m_footnoteView.OnKeyDown(new KeyEventArgs(Keys.Left));
// Check results
SelectionHelper selHelper = SelectionHelper.Create(m_footnoteView);
Assert.AreEqual(0, selHelper.IchAnchor, "IchAnchor should be at start of footnote");
Assert.AreEqual(0, selHelper.IchEnd, "IchEnd should be at start of footnote");
}
/// <summary>
/// Sets the phonological features for the currently selected natural class simple context with
/// a feature-based natural class.
/// </summary>
public void SetContextFeatures()
{
SelectionHelper sel = SelectionHelper.Create(m_view);
bool reconstruct;
using (var featChooser = new PhonologicalFeatureChooserDlg())
{
var ctxt = (IPhSimpleContextNC)CurrentContext;
var natClass = (IPhNCFeatures)ctxt.FeatureStructureRA;
featChooser.Title = MEStrings.ksRuleFeatsChooserTitle;
if (m_obj is IPhSegRuleRHS)
{
featChooser.ShowFeatureConstraintValues = true;
if (natClass.FeaturesOA != null)
{
var rule = m_obj as IPhSegRuleRHS;
featChooser.SetDlgInfo(m_cache, Mediator, m_propertyTable, rule.OwningRule, ctxt);
}
else
{
featChooser.SetDlgInfo(m_cache, Mediator, m_propertyTable, natClass, PhNCFeaturesTags.kflidFeatures);
}
}
else
{
if (natClass.FeaturesOA != null)
{
featChooser.SetDlgInfo(m_cache, Mediator, m_propertyTable, natClass.FeaturesOA);
}
else
{
featChooser.SetDlgInfo(m_cache, Mediator, m_propertyTable);
}
}
// FWR-2405: Setting the Help topic requires that the Mediator be already set!
featChooser.SetHelpTopic("khtpChoose-Grammar-PhonRules-SetPhonologicalFeatures");
DialogResult res = featChooser.ShowDialog();
if (res != DialogResult.Cancel)
{
featChooser.HandleJump();
}
reconstruct = res == DialogResult.OK;
}
m_view.Select();
if (reconstruct)
{
m_view.RootBox.Reconstruct();
sel.RestoreSelectionAndScrollPos();
}
}
protected int GetIndexOfLineChoice(IVwSelection selTest)
{
var helper = SelectionHelper.Create(selTest, this);
if (helper == null)
{
return(-1);
}
var props = helper.SelProps;
int dummyvar;
return(props.GetIntPropValues((int)FwTextPropType.ktptBulNumStartAt, out dummyvar));
}
/// <summary>
/// Try to find a WfiWordform object corresponding the the focus selection.
/// If successful return its guid, otherwise, return Guid.Empty.
/// </summary>
/// <returns></returns>
internal static Guid ActiveWordform(FdoCache cache, Mediator mediator)
{
IApp app = mediator.PropertyTable.GetValue("App") as IApp;
if (app == null)
{
return(Guid.Empty);
}
IFwMainWnd window = app.ActiveMainWindow as IFwMainWnd;
if (window == null)
{
return(Guid.Empty);
}
IRootSite activeView = window.ActiveView;
if (activeView == null)
{
return(Guid.Empty);
}
List <IVwRootBox> roots = activeView.AllRootBoxes();
if (roots.Count < 1)
{
return(Guid.Empty);
}
SelectionHelper helper = SelectionHelper.Create(roots[0].Site);
if (helper == null)
{
return(Guid.Empty);
}
ITsString word = helper.SelectedWord;
if (word == null || word.Length == 0)
{
return(Guid.Empty);
}
#if WANTPORT // FWR-2784
int hvoWordform = cache.LangProject.WordformInventoryOA.GetWordformId(word);
if (hvoWordform == 0 || cache.IsDummyObject(hvoWordform))
{
return(Guid.Empty);
}
return(cache.GetGuidFromId(hvoWordform));
#else
return(Guid.Empty);
#endif
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Performs a bunch of verifications in a draft view after a scripture book has been
/// inserted.
/// </summary>
/// <param name="sTitle">Book main title expected in the draft view.</param>
/// <param name="book">The ScrBook inserted in the draft view. The test assumes this
/// is canonically the first book in the view.</param>
/// ------------------------------------------------------------------------------------
private void VerifyInsertedBookInDraftView(string sTitle, IScrBook book)
{
bool fAssocPrev;
int ich, hvoObj, tag, enc;
ITsString tss;
SelectionHelper selHelper = SelectionHelper.Create(m_mainWnd.TheDraftView);
// Make sure that IP has been given appropriate properties for typing regular
// vernacular text (not continuing to enter text using "Chapter Number" style).
Assert.AreEqual(4, selHelper.NumberOfLevels);
// This better be the first book in the view.
Assert.AreEqual(0, selHelper.LevelInfo[3].ihvo);
// Since this book was just inserted, we should be in the first section.
Assert.AreEqual(0, selHelper.LevelInfo[2].ihvo);
// The InsertBook command should leave our insertion point in the Content of
// this section (as opposed to the section Heading).
Assert.AreEqual((int)ScrSection.ScrSectionTags.kflidContent,
selHelper.LevelInfo[1].tag);
// We should be in the first paragraph of that section's content.
Assert.AreEqual(0, selHelper.LevelInfo[0].ihvo);
// We should have a simple IP, not a range selection
IVwSelection sel = selHelper.Selection;
Assert.IsFalse(sel.IsRange);
Assert.AreEqual(1, selHelper.IchAnchor, "IP should follow chapter number");
// If the user starts typing, they should be entering regular vernacular text
Assert.AreEqual(StyleUtils.CharStyleTextProps(null, m_wsVern), selHelper.SelProps);
// Put cursor in the book title. If TestLangProj ever contains a book before sTitle
// (i.e., canonically), then this will no longer be the first book in the view.
m_mainWnd.TheDraftView.TeEditingHelper.GoToFirstBook();
sel = m_mainWnd.TheDraftView.RootBox.Selection;
sel.TextSelInfo(true, out tss, out ich, out fAssocPrev, out hvoObj, out tag, out enc);
Assert.IsNull(tss.Text, "book title has a title");
// Put the cursor in the empty section heading and verify stuff about the section
// heading.
m_mainWnd.TheDraftView.TeEditingHelper.GoToFirstSection();
sel = m_mainWnd.TheDraftView.RootBox.Selection;
sel.TextSelInfo(true, out tss, out ich, out fAssocPrev, out hvoObj, out tag, out enc);
AssertEx.RunIsCorrect(tss, 0, null, null, m_wsVern);
// Make sure the chapter number is set
m_mainWnd.TheDraftView.SetInsertionPoint(0, 0, 0, 0, true);
sel = m_mainWnd.TheDraftView.RootBox.Selection;
sel.TextSelInfo(true, out tss, out ich, out fAssocPrev, out hvoObj, out tag, out enc);
AssertEx.RunIsCorrect(tss, 0, "1", ScrStyleNames.ChapterNumber, m_wsVern);
}
// Insert an invisible space at the place clicked. Return true to suppress normal MouseDown processing.
private bool InsertInvisibleSpace(MouseEventArgs e)
{
var sel = GetSelectionAtViewPoint(e.Location, false);
if (sel == null)
{
return(false);
}
if (e.Button == MouseButtons.Right || (ModifierKeys & Keys.Shift) == Keys.Shift)
{
return(false); // don't interfere with right clicks or shifr-clicks.
}
var helper = SelectionHelper.Create(sel, this);
var text = helper.GetTss(SelectionHelper.SelLimitType.Anchor).Text;
if (string.IsNullOrEmpty(text))
{
return(false);
}
// We test for space (rather than zwsp) because when in this mode, the option to make the ZWS's visible
// is always on, which means they are spaces in the string we retrieve.
// If we don't want to suppress inserting one next to a regular space, we'll need to check the chararacter properties
// to distinguish the magic spaces from regular ones.
int ich = helper.GetIch(SelectionHelper.SelLimitType.Anchor);
if (ich > 0 && ich <= text.Length && text[ich - 1] == ' ')
{
return(false); // don't insert second ZWS following existing one (or normal space).
}
if (ich < text.Length && text[ich] == ' ')
{
return(false); // don't insert second ZWS before existing one (or normal space).
}
int nVar;
int ws = helper.GetSelProps(SelectionHelper.SelLimitType.Anchor).GetIntPropValues((int)FwTextPropType.ktptWs,
out nVar);
if (ws != 0)
{
UndoableUnitOfWorkHelper.Do(ITextStrings.ksUndoInsertInvisibleSpace, ITextStrings.ksRedoInsertInvisibleSpace,
Cache.ActionHandlerAccessor,
() => sel.ReplaceWithTsString(Cache.TsStrFactory.MakeString(AnalysisOccurrence.KstrZws, ws)));
}
helper.SetIch(SelectionHelper.SelLimitType.Anchor, ich + 1);
helper.SetIch(SelectionHelper.SelLimitType.End, ich + 1);
helper.SetSelection(true, true);
return(true); // we already made an appropriate selection.
}
public void SetMappingNaturalClass()
{
SelectionHelper.Create(m_view);
var natClasses = new HashSet <ICmObject>();
foreach (var nc in m_cache.LangProject.PhonologicalDataOA.NaturalClassesOS)
{
if (nc.ClassID == PhNCFeaturesTags.kClassId)
{
natClasses.Add(nc);
}
}
var selectedNc = DisplayChooser(MEStrings.ksRuleNCOpt, MEStrings.ksRuleNCChooserLink,
"naturalClassedit", "RuleNaturalClassFlatList", natClasses) as IPhNCFeatures;
m_view.Select();
if (selectedNc != null)
{
int index = -1;
UndoableUnitOfWorkHelper.Do(MEStrings.ksAffixRuleUndoSetNC,
MEStrings.ksAffixRuleRedoSetNC, m_cache.ActionHandlerAccessor, () =>
{
var curObj = CurrentObject;
switch (curObj.ClassID)
{
case MoCopyFromInputTags.kClassId:
var copy = (IMoCopyFromInput)curObj;
var newModify = m_cache.ServiceLocator.GetInstance <IMoModifyFromInputFactory>().Create();
Rule.OutputOS.Insert(copy.IndexInOwner, newModify);
newModify.ModificationRA = selectedNc;
newModify.ContentRA = copy.ContentRA;
index = newModify.IndexInOwner;
Rule.OutputOS.Remove(copy);
break;
case MoModifyFromInputTags.kClassId:
var modify = (IMoModifyFromInput)curObj;
modify.ModificationRA = selectedNc;
index = modify.IndexInOwner;
break;
}
});
ReconstructView(MoAffixProcessTags.kflidOutput, index, true);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Updates the saved selection to the selection that is currently in the view.
/// </summary>
/// ------------------------------------------------------------------------------------
internal void ResetSelection()
{
// If selHelper is not null, that means that the view probably just updated the
// values of the existing selection instead of requesting a new selection at the
// end of the UOW.
// NOTE: This will not work correctly if we don't destroy the selection in
// RequestSelectionAtEndOfUOW.
if (m_selHelper != null)
{
m_selHelper = SelectionHelper.Create(m_selHelper.Selection, m_selHelper.RootSite);
}
else if (m_rootSite != null)
{
m_selHelper = SelectionHelper.Create(m_rootSite);
}
}