/// ------------------------------------------------------------------------------------ /// <summary> /// Called when cell value needed. /// </summary> /// ------------------------------------------------------------------------------------ protected override void OnCellValueNeeded(DataGridViewCellValueEventArgs e) { KeyTermRef keyTermRef = m_list[e.RowIndex] as KeyTermRef; if (keyTermRef == null) { e.Value = null; return; } switch (e.ColumnIndex) { case KeyTermRenderingsControl.kRefCol: e.Value = keyTermRef.Reference; break; case KeyTermRenderingsControl.kRenderingCol: e.Value = keyTermRef.Rendering; break; case KeyTermRenderingsControl.kStatusCol: e.Value = keyTermRef.RenderingStatus; break; case KeyTermRenderingsControl.kCommentCol: e.Value = keyTermRef.KeyWordString; break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Called when cell value needed. /// </summary> /// ------------------------------------------------------------------------------------ protected override void OnCellValueNeeded(DataGridViewCellValueEventArgs e) { Debug.Assert(m_list != null, "Why did OnCellValueNeeded get called without first setting KeyTermRefs?"); KeyTermRef keyTermRef = (m_list == null) ? null : m_list[e.RowIndex] as KeyTermRef; if (keyTermRef == null) { e.Value = null; return; } switch (e.ColumnIndex) { case KeyTermRenderingsControl.kRefCol: e.Value = keyTermRef.Reference; break; case KeyTermRenderingsControl.kRenderingCol: e.Value = keyTermRef.Rendering; break; case KeyTermRenderingsControl.kStatusCol: e.Value = keyTermRef.RenderingStatus; break; case KeyTermRenderingsControl.kCommentCol: e.Value = keyTermRef.KeyWordString; break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Constructor for the event args /// </summary> /// ------------------------------------------------------------------------------------ public ScrRefEventArgs(KeyTermRef keyTermRef) { if (keyTermRef != null && keyTermRef != KeyTermRef.Empty) { KeyTermRef = keyTermRef; RefBCV = keyTermRef.ChkRef.Ref; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Constructor for the event args /// </summary> /// ------------------------------------------------------------------------------------ public ScrRefEventArgs(KeyTermRef keyTermRef) { if (keyTermRef != null && keyTermRef != KeyTermRef.Empty) { KeyTermRef = keyTermRef; RefBCV = keyTermRef.Ref; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the enabled states of the buttons on the key terms tool strip. /// </summary> /// ------------------------------------------------------------------------------------ internal void UpdateToolStripButtons(KeyTermRef keyTermRef) { Debug.Assert(m_wrapper != null, "The key terms wrapper must be specified in KeyTermsToolStrip"); m_tbbUseAsVern.Enabled = m_wrapper.EnableUseAsRendering(keyTermRef); m_tbbVernNotAssigned.Enabled = m_wrapper.EnableIgnoreUnrendered(keyTermRef); m_tbbNotRendered.Enabled = m_wrapper.EnableRenderingNotAssigned(keyTermRef); m_tbbApplyFilter.Checked = m_wrapper.ApplyBookFilter; }
public void IsRangeInKtRef_OutOfRange_NoVerseBridge() { ScrReference[] refRange = new ScrReference[2]; refRange[0] = refRange[1] = new ScrReference(01001001, Paratext.ScrVers.English); int hvoKtRef = m_inMemoryCache.NewHvo(ChkRef.kClassId); KeyTermRef ktRef = new KeyTermRef(Cache, hvoKtRef); ktRef.Ref = 01001002; Assert.IsFalse(KeyTermsViewWrapper.IsRangeInKtRef(ktRef, refRange, refRange)); }
public void IsRangeInKtRef_OutOfRange_ConvertedVersification() { // Jonah 2:1 in Original != Jonah 2:1 in English ScrReference[] refRange = new ScrReference[2]; refRange[0] = refRange[1] = new ScrReference(32002001, Paratext.ScrVers.English); int hvoKtRef = m_inMemoryCache.NewHvo(ChkRef.kClassId); KeyTermRef ktRefJonah2_1 = new KeyTermRef(Cache, hvoKtRef); ktRefJonah2_1.Ref = 32002001; Assert.IsFalse(KeyTermsViewWrapper.IsRangeInKtRef(ktRefJonah2_1, refRange, refRange)); }
public void IsRangeInKtRef_InAnchorButNotInEnd() { ScrReference[] anchorRefRange = new ScrReference[2]; anchorRefRange[0] = anchorRefRange[1] = new ScrReference(01001001, Paratext.ScrVers.English); ScrReference[] endRefRange = new ScrReference[2]; endRefRange[0] = endRefRange[1] = new ScrReference(01001002, Paratext.ScrVers.English); int hvoKtRef = m_inMemoryCache.NewHvo(ChkRef.kClassId); KeyTermRef ktRef = new KeyTermRef(Cache, hvoKtRef); ktRef.Ref = 01001001; Assert.IsFalse(KeyTermsViewWrapper.IsRangeInKtRef(ktRef, anchorRefRange, endRefRange)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Gets the index of the key term reference for the specified guid. If a key term /// reference for the guid cannot be found, then -1 is returned. /// </summary> /// ------------------------------------------------------------------------------------ private int GetKeyTermRef(Guid guid) { for (int i = 0; i < m_list.Count; i++) { KeyTermRef keyTermRef = m_list[i] as KeyTermRef; if (keyTermRef != null && keyTermRef.Guid == guid) { return(i); } } return(-1); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ public int FindIndexOfRefWithHvo(int hvo) { if (m_list != null && m_list.Count > 0) { for (int i = 0; i < m_list.Count; i++) { KeyTermRef keyTermRef = m_list[i] as KeyTermRef; if (keyTermRef != null && keyTermRef.Hvo == hvo) { return(i); } } } return(-1); }
/// ------------------------------------------------------------------------------------ /// <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); }
/// ------------------------------------------------------------------------------------ /// <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(IChkTerm keyTerm, List <int> filteredBookIds) { foreach (IChkRef chkRef in keyTerm.OccurrencesOS) { KeyTermRef keyRef = new KeyTermRef(chkRef); if (filteredBookIds == null || filteredBookIds.Contains(keyRef.RefInCurrVersification.Book)) { keyRef.PropertyChanged -= OnKeyTermRefPropertyChanged; keyRef.PropertyChanged += OnKeyTermRefPropertyChanged; m_list.Add(keyRef); } } foreach (IChkTerm kt in keyTerm.SubPossibilitiesOS) { PopulateKeyTermRefs(kt, filteredBookIds); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ protected override void OnSaveSettings(Microsoft.Win32.RegistryKey key) { CheckDisposed(); base.OnSaveSettings(key); KeyTermRef keyTermRef = SelectedReference; // Sometimes we get here when the cache has already been disposed but the ref. // is still an object. In that case referencing the guid will cause a crash, // therefore ignore exceptions. try { if (key != null && keyTermRef != null && keyTermRef != KeyTermRef.Empty) { key.SetValue("SelectedKeyTermRef", keyTermRef.Guid); } } catch { } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether or not there is a range selection consisting of at least one /// "word" (non-whitespace) in the draft view that is in the current check reference's /// reference. /// </summary> /// ------------------------------------------------------------------------------------ private bool ValidKtTextIsSelected(KeyTermRef ktRef) { if (!IsKeyTermInRangeSelection(ktRef)) return false; // The user is allowed to merely click on a word; they don't have to select it. // Therefore, we have to see if there is a range selection, and if not, see if // we can grow the selection into a word. ITsString tss = null; if (EditingHelper.CurrentSelection.Selection.IsRange) { EditingHelper.CurrentSelection.Selection.GetSelectionString(out tss, string.Empty); } else { IVwSelection sel = EditingHelper.CurrentSelection.Selection.GrowToWord(); if (sel != null) sel.GetSelectionString(out tss, string.Empty); } return IsValidTSS(tss); }
/// ------------------------------------------------------------------------------------ /// <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); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether or not there is a range selection in the draft view that is in /// the current check reference's reference. /// </summary> /// ------------------------------------------------------------------------------------ private bool IsRangeSelectionInKtRef(KeyTermRef keyTermRef) { CheckDisposed(); if (EditingHelper == null || EditingHelper.CurrentSelection == null) return false; // If the selection in the draft view is not a range selection, then there is // nothing to use. if (!EditingHelper.CurrentSelection.Selection.IsRange) return false; if (KeyTermRef.IsNullOrEmpty(keyTermRef)) return false; return IsSelectionInRef(keyTermRef); }
public void IsRangeInKtRef_InRange_VerseBridge() { ScrReference[] refRange = new ScrReference[2]; refRange[0] = new ScrReference(01001001, Paratext.ScrVers.English); refRange[1] = new ScrReference(01001003, Paratext.ScrVers.English); int hvoKtRef = m_inMemoryCache.NewHvo(ChkRef.kClassId); KeyTermRef ktRef = new KeyTermRef(Cache, hvoKtRef); ktRef.Ref = 01001002; Assert.IsTrue(KeyTermsViewWrapper.IsRangeInKtRef(ktRef, refRange, refRange)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determine if the "Ignore Unrendered" command should be enabled /// </summary> /// <returns>true to enable, false to disable</returns> /// ------------------------------------------------------------------------------------ public bool EnableIgnoreUnrendered(KeyTermRef keyTermRef) { CheckDisposed(); if (keyTermRef == null) keyTermRef = SelectedReference; // If there are no references displayed, or there is not a current reference, then // do not enable the command. if (!Visible || KeyTermReferenceCount == 0 || keyTermRef == KeyTermRef.Empty) return false; // If the current key term reference is unrendered, then enable. return (keyTermRef.RenderingStatus != KeyTermRenderingStatus.Ignored); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determine if the "Use As Rendering" command should be enabled /// </summary> /// <returns>true if it is valid to enable the command, false otherwise</returns> /// ------------------------------------------------------------------------------------ public bool EnableUseAsRendering(KeyTermRef keyTermRef) { CheckDisposed(); if (keyTermRef == null) keyTermRef = SelectedReference; // If there are no references displayed, or there is not a current reference, then // do not enable the command. if (!Visible || KeyTermReferenceCount == 0 || keyTermRef == KeyTermRef.Empty) return false; // If the focused window is not the renderings, or the draft view, then don't // enable the command. if (ActiveCheckingView != CheckView.Grid && ActiveCheckingView != CheckView.Draft) return false; return ValidKtTextIsSelected(keyTermRef); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether the specified key term reference falls within the given range of /// references. Normally this will only return <c>true</c> if the anchor and end are the /// same. That is to say, the selection represented by the given ranges must fall wholly /// within a single verse. (There is an anomalous case where it could succeed If the range crosses a verse number (or bridge) such that the end /// reference /// </summary> /// <param name="keyTermRef">The key term ref.</param> /// <param name="anchorRefRange">The anchor ref range (which is made up of two /// references to account for possible verse bridges).</param> /// <param name="endRefRange">The end ref range (which is made up of two /// references to account for possible verse bridges).</param> /// <returns> /// <c>true</c> if the specified key term ref falls within the given range; /// otherwise, <c>false</c>. /// </returns> /// ------------------------------------------------------------------------------------ public static bool IsRangeInKtRef(KeyTermRef keyTermRef, ScrReference[] anchorRefRange, ScrReference[] endRefRange) { ScrReference selectedKtRef = keyTermRef.RefInCurrVersification; return (anchorRefRange[0] <= selectedKtRef && anchorRefRange[1] >= selectedKtRef && endRefRange[0] == anchorRefRange[0] && endRefRange[1] == anchorRefRange[1]); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Return the guid of the current row. /// </summary> /// ------------------------------------------------------------------------------------ protected override object GetPreSortRow() { KeyTermRef keyTermRef = SelectedReference; return(keyTermRef != null && keyTermRef.IsValid ? keyTermRef.Guid : Guid.Empty); }
public void IsRangeInKtRef_InRangeButAnchorAndEndAreDifferent() { ScrReference[] anchorRefRange = new ScrReference[2]; ScrReference[] endRefRange = new ScrReference[2]; anchorRefRange[0] = endRefRange[0] = new ScrReference(01001001, Paratext.ScrVers.English); anchorRefRange[1] = new ScrReference(01001001, Paratext.ScrVers.English); endRefRange[1] = new ScrReference(01001003, Paratext.ScrVers.English); int hvoKtRef = m_inMemoryCache.NewHvo(ChkRef.kClassId); KeyTermRef ktRef = new KeyTermRef(Cache, hvoKtRef); ktRef.Ref = 01001001; Assert.IsFalse(KeyTermsViewWrapper.IsRangeInKtRef(ktRef, anchorRefRange, endRefRange)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether or not there is a range selection in the draft view that is in /// the current check reference's reference. /// </summary> /// ------------------------------------------------------------------------------------ private bool IsKeyTermInRangeSelection(KeyTermRef ktRef) { if (EditingHelper == null || EditingHelper.CurrentSelection == null) return false; // If the selection in the draft view is not a range selection, or cannot be grown // into one, then there is nothing to use. if (!EditingHelper.CurrentSelection.Selection.IsRange) { IVwSelection sel = EditingHelper.CurrentSelection.Selection.GrowToWord(); if (sel == null) return false; } // If the selection is not in the same Scripture reference as the selected key term // then don't enable the command. return IsSelectionInRef(ktRef); }
/// ------------------------------------------------------------------------------------ /// <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(IChkTerm keyTerm, List<int> filteredBookIds) { foreach (IChkRef chkRef in keyTerm.OccurrencesOS) { KeyTermRef keyRef = new KeyTermRef(chkRef); if (filteredBookIds == null || filteredBookIds.Contains(keyRef.RefInCurrVersification.Book)) { keyRef.PropertyChanged -= OnKeyTermRefPropertyChanged; keyRef.PropertyChanged += OnKeyTermRefPropertyChanged; m_list.Add(keyRef); } } foreach (IChkTerm kt in keyTerm.SubPossibilitiesOS) PopulateKeyTermRefs(kt, filteredBookIds); }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// ------------------------------------------------------------------------------------ public override void PropChanged(int hvo, int tag, int ivMin, int cvIns, int cvDel) { base.PropChanged(hvo, tag, ivMin, cvIns, cvDel); if (tag != (int)ChkRef.ChkRefTags.kflidRef && tag != (int)ChkRef.ChkRefTags.kflidRendering && tag != (int)ChkRef.ChkRefTags.kflidStatus && tag != (int)ChkRef.ChkRefTags.kflidKeyWord) { return; } int iKeyTermRef = FindIndexOfRefWithHvo(hvo); if (iKeyTermRef < 0) { return; } KeyTermRef keyTermRef = m_list[iKeyTermRef] as KeyTermRef; string propertyName = m_cache.MetaDataCacheAccessor.GetFieldName((uint)tag); keyTermRef.OnPropertyChanged(propertyName); // In the data grid view we are displaying some artifical properties, yet // we change the underlaying property. If it is one of those we do a prop // changed for our artifical ones as well. int invalidateColumn = -1; // column to invalidate switch (propertyName) { default: return; case "Status": propertyName = "RenderingStatus"; invalidateColumn = KeyTermRenderingsControl.kStatusCol; break; case "Ref": propertyName = "Reference"; invalidateColumn = KeyTermRenderingsControl.kRefCol; break; case "KeyWord": propertyName = "KeyWordString"; invalidateColumn = KeyTermRenderingsControl.kCommentCol; break; case "RenderingRA": propertyName = "Rendering"; invalidateColumn = KeyTermRenderingsControl.kRenderingCol; break; } // TE-6621: In some cases (which developers nor JAARS testers can reproduce), the // column index is invalid for the datagrid, so we confirm that the index is // within the proper range. if (invalidateColumn >= 0 && invalidateColumn < ColumnCount) { InvalidateColumn(invalidateColumn); } keyTermRef.OnPropertyChanged(propertyName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns whether the specified kt ref is null or empty. /// </summary> /// <param name="ktRef">The key terms reference.</param> /// ------------------------------------------------------------------------------------ internal static bool IsNullOrEmpty(KeyTermRef ktRef) { return(ktRef == null || ktRef == Empty); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns whether or not the current selection in the draft view is entirely contained /// in the verse which is the given reference. /// </summary> /// <param name="ktRef">The key terms reference.</param> /// ------------------------------------------------------------------------------------ private bool IsSelectionInRef(KeyTermRef ktRef) { CheckDisposed(); if (KeyTermRef.IsNullOrEmpty(ktRef)) throw new ArgumentException("Parameter must not be null or empty", "ktRef"); return IsRangeInKtRef(ktRef, EditingHelper.GetCurrentAnchorRefRange(), EditingHelper.GetCurrentEndRefRange()); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns whether the specified kt ref is null or empty. /// </summary> /// <param name="ktRef">The key terms reference.</param> /// ------------------------------------------------------------------------------------ internal static bool IsNullOrEmpty(KeyTermRef ktRef) { return (ktRef == null || ktRef == Empty); }
/// ------------------------------------------------------------------------------------ /// <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; IChkTerm parent = (IChkTerm)assignedRef.Owner; foreach (IChkRef autoAssignRef in parent.OccurrencesOS) { KeyTermRef ktRef = new KeyTermRef(autoAssignRef); if (ktRef.RenderingStatus != KeyTermRenderingStatus.Unassigned) continue; if (TeEditingHelper.FindTextInVerse(m_scr, wordForm.Form.get_String(wordForm.Cache.DefaultVernWs), ktRef.RefInCurrVersification, true, out iDummy, out iDummy, out iDummy, out iDummy)) { // TODO: update the local view constructor cache ktRef.RenderingStatus = KeyTermRenderingStatus.AutoAssigned; ktRef.ChkRef.RenderingRA = wordForm; } } }