private void addButton_Click(object sender, System.EventArgs e) { if (optionsList.SelectedItem == null || !(optionsList.SelectedItem is LineOption)) { return; } int flid = (optionsList.SelectedItem as LineOption).Flid; int ws = 0; if (m_choices.IndexOf(flid) != -1) // i.e., if m_choices contains flid. { InterlinLineSpec existingSpec = m_choices[m_choices.IndexOf(flid)]; int prevWs = existingSpec.WritingSystem; foreach (WsComboItem item in WsComboItems(existingSpec.ComboContent)) { int newWs = getWsFromId(item.Id); if (newWs != prevWs && m_choices.IndexOf(flid, newWs, true) == -1) { ws = newWs; break; } } } int index = m_choices.Add(flid, ws); InitCurrentList(index); }
private int GetRealWsFromSpec(InterlinLineSpec spec) { if (!spec.IsMagicWritingSystem) { return(spec.WritingSystem); } // special case, the only few we support so far (and only for a few fields). if (spec.WritingSystem == WritingSystemServices.kwsFirstAnal) { return(Cache.LangProject.DefaultAnalysisWritingSystem.Handle); } if (spec.WritingSystem == WritingSystemServices.kwsVernInParagraph) { return(Cache.LangProject.DefaultVernacularWritingSystem.Handle); // REVIEW (Hasso) 2018.01: this is frequently the case, but not always } int ws = -50; try { ws = WritingSystemServices.InterpretWsLabel(Cache, spec.WsLabel(Cache).Text, null, 0, 0, null); } catch { Debug.Assert(ws != -50, "InterpretWsLabel was not able to interpret the Ws Label. The most likely cause for this is that a magic ws was passed in."); } return(ws); }
private void optionsList_DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e) { LineOption option = optionsList.Items[e.Index] as LineOption; InterlinLineSpec spec = m_choices.CreateSpec(option.Flid, 0); DrawItem(e, spec); }
private void DrawItem(System.Windows.Forms.DrawListViewItemEventArgs e, InterlinLineSpec spec) { Brush backBrush = SystemBrushes.ControlLightLight; if (e.Item.Selected) { backBrush = SystemBrushes.Highlight; } e.Graphics.FillRectangle(backBrush, e.Bounds); if (e.Item.Focused) { ControlPaint.DrawFocusRectangle(e.Graphics, e.Bounds); } SolidBrush textBrush = GetBrush(spec, e.Item.Selected) as SolidBrush; try { Font drawFont = e.Item.Font; ListViewItem item = e.Item as ListViewItem; // Draw the line label. e.Graphics.DrawString(item.Text, drawFont, textBrush, e.Bounds); // Now draw the WritingSystem info. e.Graphics.DrawString(item.SubItems[1].Text, item.SubItems[1].Font, e.Item.Selected ? textBrush : SystemBrushes.ControlText, item.SubItems[1].Bounds); } finally { if (!e.Item.Selected) { textBrush.Dispose(); } } }
/// <summary> /// Answer where line n should move up to (if it can move up). /// If it can't answer -1. /// </summary> /// <param name="n"></param> /// <returns></returns> internal int WhereToMoveUpTo(int n) { if (n == 0) { return(-1); // first line can't move up! } InterlinLineSpec spec = this[n]; // Can't move up at all if it's a freeform and the previous line is not. if (!spec.WordLevel && this[n - 1].WordLevel) { return(-1); } int newPos = n - 1; // default place to put it. // If it is not morpheme level and a morpheme-level precedes it, must move // past all of them. if (!spec.MorphemeLevel && this[newPos].MorphemeLevel) { for ( ; newPos > 0 && this[newPos - 1].MorphemeLevel; newPos--) { ; } } // If it can't go here it just can't move. if (newPos > 0 && !CanFollow(this[newPos - 1], spec)) { return(-1); } if (!CanFollow(spec, this[newPos])) { return(-1); } return(newPos); }
private void DrawItem(System.Windows.Forms.DrawItemEventArgs e, InterlinLineSpec spec) { bool selected = ((e.State & DrawItemState.Selected) != 0); Brush textBrush = GetBrush(spec, selected); Font drawFont = e.Font; e.DrawBackground(); e.Graphics.DrawString(optionsList.Items[e.Index].ToString(), drawFont, textBrush, e.Bounds); }
/// <summary> /// Call before calling Remove. True and null message indicates no problem to /// remove this field. /// If it returns a true, display a message box indicating the Remove is not /// possible, using the returned message. /// If it returns false and a message, there is a warning, display it and /// allow the user to possibly cancel. /// </summary> /// <param name="spec"></param> /// <returns></returns> public virtual bool OkToRemove(InterlinLineSpec spec, out string message) { if (m_specs.Count == 1) { message = ITextStrings.ksNeedOneField; return(false); } message = null; return(true); }
private void moveDownButton_Click(object sender, System.EventArgs e) { if (CurrentListIndex < 0 || !m_choices.OkToMoveDown(CurrentListIndex)) { return; } InterlinLineSpec spec = m_choices[CurrentListIndex]; m_choices.MoveDown(CurrentListIndex); InitCurrentList(spec); }
/// <summary> /// Overridden to prevent removing the Words line and to remove dependents of the line being removed /// (after warning the user). /// </summary> /// <param name="spec"></param> public override void Remove(InterlinLineSpec spec) { List <InterlinLineSpec> dependents = new List <InterlinLineSpec>(); dependents = FindDependents(spec); foreach (InterlinLineSpec depSpec in dependents) { m_specs.Remove(depSpec); } base.Remove(spec); }
private IEnumerable <WsComboItem> GetWsComboItems(InterlinLineSpec curSpec) { using (var dummyCombobox = new ComboBox()) { var dummyCachedBoxes = new Dictionary <ColumnConfigureDialog.WsComboContent, ComboBox.ObjectCollection>(); var comboObjects = ConfigureInterlinDialog.WsComboItemsInternal( Cache, dummyCombobox, dummyCachedBoxes, curSpec.ComboContent); var choices = new WsComboItem[comboObjects.Count]; comboObjects.CopyTo(choices, 0); return(choices); } }
private Brush GetBrush(InterlinLineSpec spec, bool selected) { Brush textBrush = SystemBrushes.ControlText; if (selected) { textBrush = SystemBrushes.HighlightText; } else { textBrush = new SolidBrush(m_choices.LabelColorFor(spec)); } return(textBrush); }
internal Color LabelColorFor(InterlinLineSpec spec) { if (spec.MorphemeLevel) { return(kMorphLevelColor); } else if (spec.WordLevel && spec.Flid != InterlinLineChoices.kflidWord) { return(kWordLevelColor); } else { return(SystemColors.ControlText); } }
public void GetActualWs_MorphBundleBehavesLikeMoForm() { var wsManager = new WritingSystemManager(); CoreWritingSystemDefinition enWs; wsManager.GetOrSet("en", out enWs); int wsEng = enWs.Handle; CoreWritingSystemDefinition frWs; wsManager.GetOrSet("fr", out frWs); int wsFrn = frWs.Handle; var choices = new InterlinLineChoices(m_lp, wsFrn, wsEng); MakeStandardState(choices); InterlinLineSpec spec = choices[1]; Assert.AreEqual(InterlinLineChoices.kflidMorphemes, spec.Flid); // The StringFlid for this line spec always corresponds to a MoForm Assert.AreEqual(MoFormTags.kflidForm, spec.StringFlid); IWfiWordform wf; IWfiAnalysis wag; ITsString str = TsStringUtils.MakeString("WordForm", spec.WritingSystem); IWfiMorphBundle wmb = Cache.ServiceLocator.GetInstance <IWfiMorphBundleFactory>().Create(); NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () => { wf = Cache.ServiceLocator.GetInstance <IWfiWordformFactory>().Create(str); wag = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(wf); wag.MorphBundlesOS.Add(wmb); ILexEntry entry = Cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(); IMoForm moForm = Cache.ServiceLocator.GetInstance <IMoStemAllomorphFactory>().Create(); entry.AlternateFormsOS.Add(moForm); moForm.Form.set_String(spec.WritingSystem, "Morph"); wmb.MorphRA = moForm; }); // The line spec for displaying the Morpheme must be able to handle getting the ws from both // MorphBundles or MoForms Assert.True(spec.Flid == InterlinLineChoices.kflidMorphemes); int wmbWs = spec.GetActualWs(Cache, wmb.Hvo, spec.WritingSystem); int mfWs = spec.GetActualWs(Cache, wmb.MorphRA.Hvo, spec.WritingSystem); Assert.True(wmbWs == spec.WritingSystem); Assert.True(mfWs == spec.WritingSystem); }
/// <summary> /// Get the writing system for the given flid. /// </summary> /// <param name="flid"></param> /// <param name="fGetDefaultForMissing">if true, provide the default writing system for the given flid.</param> /// <returns></returns> public List <int> WritingSystemsForFlid(int flid, bool fGetDefaultForMissing) { List <int> result = new List <int>(); foreach (InterlinLineSpec spec in m_specs) { if (spec.Flid == flid && result.IndexOf(spec.WritingSystem) < 0) { result.Add(spec.WritingSystem); } } if (fGetDefaultForMissing && result.Count == 0) { InterlinLineSpec newSpec = CreateSpec(flid, 0); result.Add(newSpec.WritingSystem); } return(result); }
/// <summary> /// Answer an array list of integers, the writing systems we care about for the specified flid, /// except the one specified. /// </summary> /// <param name="flid"></param> /// <param name="wsToOmit">the ws to omit. use 0 remove the default ws for this flid</param> /// <returns></returns> public List <int> OtherWritingSystemsForFlid(int flid, int wsToOmit) { if (wsToOmit == 0) { // eliminate the default writing system for this flid. InterlinLineSpec specDefault = CreateSpec(flid, 0); wsToOmit = specDefault.WritingSystem; } List <int> result = new List <int>(); foreach (InterlinLineSpec spec in m_specs) { if (spec.Flid == flid && result.IndexOf(spec.WritingSystem) < 0 && spec.WritingSystem != wsToOmit) { result.Add(spec.WritingSystem); } } return(result); }
public override bool OkToRemove(InterlinLineSpec spec, out string message) { if (!base.OkToRemove(spec, out message)) { return(false); } if (spec.Flid == kflidWord && spec.WritingSystem == m_wsDefVern && ItemsWithFlids(new int[] { kflidWord }, new int[] { m_wsDefVern }).Count < 2) { message = ITextStrings.ksNeedWordLine; return(false); } if (FindDependents(spec).Count > 0) { // Enhance JohnT: get the names and include them in the message. message = ITextStrings.ksHidesDependentLinesAlso; // OK to go ahead if the user wishes, return true. } return(true); }
public virtual int Add(InterlinLineSpec spec) { bool fGotMorpheme = HaveMorphemeLevel; for (int i = m_specs.Count - 1; i >= 0; i--) { if (this[i].Flid == spec.Flid) { // It's always OK (and optimal) to insert a new occurrence of the same // flid right after the last existing one. m_specs.Insert(i + 1, spec); return(i + 1); } } for (int i = m_specs.Count - 1; i >= 0; i--) { if (CanFollow(this[i], spec)) { int firstMorphemeIndex = FirstMorphemeIndex; // Even if otherwise OK, if we're inserting something morpheme level // and there's already morpheme-level stuff present it must follow // the existing morpheme-level stuff. if (fGotMorpheme && spec.MorphemeLevel && i >= firstMorphemeIndex && (!this[i].MorphemeLevel || spec.Flid == kflidMorphemes || spec.Flid == kflidLexEntries && this[i].Flid != kflidMorphemes)) { continue; } // And word-level annotations can't follow freeform ones. if (spec.WordLevel && !this[i].WordLevel) { continue; } m_specs.Insert(i + 1, spec); return(i + 1); } } m_specs.Insert(0, spec); // can't follow anything, put first. return(0); }
void UpdateWsComboValue() { try { m_fUpdatingWsCombo = true; int index = CurrentListIndex; if (index < 0 || index >= m_choices.Count) { wsCombo.SelectedIndex = -1; wsCombo.Enabled = false; return; } InterlinLineSpec spec = m_choices[index]; ComboBox.ObjectCollection comboObjects = WsComboItems(spec.ComboContent); object[] choices = new object[comboObjects.Count]; comboObjects.CopyTo(choices, 0); wsCombo.Items.Clear(); wsCombo.Items.AddRange(choices); int ws = spec.WritingSystem; wsCombo.Enabled = true; // JohnT: note that, because 'Default analysis' and 'Default Vernacular' // come first, the corresponding actual writing systems will never be // chosen by this algorithm. foreach (WsComboItem item in wsCombo.Items) { if (getWsFromId(item.Id) == ws) { wsCombo.SelectedItem = item; break; } } } finally { m_fUpdatingWsCombo = false; } }
private void wsCombo_SelectedIndexChanged(object sender, EventArgs e) { if (m_fUpdatingWsCombo) { return; } if (!(wsCombo.SelectedItem is WsComboItem)) { return; } int listIndex = CurrentListIndex; if (listIndex < 0) { return; } InterlinLineSpec spec = m_choices[listIndex]; spec.WritingSystem = getWsFromId(((WsComboItem)wsCombo.SelectedItem).Id); InitCurrentList(listIndex); }
private void removeButton_Click(object sender, System.EventArgs e) { int index = CurrentListIndex; if (index < 0) { return; } string message; InterlinLineSpec spec = m_choices[index]; if (!m_choices.OkToRemove(spec, out message)) { MessageBox.Show(this, message, ITextStrings.ksCannotHideField); return; } if (message != null && MessageBox.Show(this, message, ITextStrings.ksWarning, MessageBoxButtons.OKCancel) == DialogResult.Cancel) { return; } m_choices.Remove(spec); InitCurrentList(index); }
public void MoveUp(int n) { int dest = WhereToMoveUpTo(n); if (dest < 0) { return; } InterlinLineSpec spec = this[n]; // If this was the first morpheme field, move the others too. bool fMoveGroup = spec.MorphemeLevel && !this[n - 1].MorphemeLevel; m_specs.RemoveAt(n); m_specs.Insert(dest, spec); if (fMoveGroup) { for (int i = n + 1; i < Count && this[i].MorphemeLevel; i++) { InterlinLineSpec specT = this[i]; m_specs.RemoveAt(i); m_specs.Insert(dest + i - n, specT); } } }
public virtual int Add(InterlinLineSpec spec) { bool fGotMorpheme = HaveMorphemeLevel; for (int i = m_specs.Count - 1; i >= 0; i--) { if (this[i].Flid == spec.Flid) { // It's always OK (and optimal) to insert a new occurrence of the same // flid right after the last existing one. m_specs.Insert(i + 1, spec); return i + 1; } } for (int i = m_specs.Count - 1; i >= 0; i--) { if (CanFollow(this[i], spec)) { int firstMorphemeIndex = FirstMorphemeIndex; // Even if otherwise OK, if we're inserting something morpheme level // and there's already morpheme-level stuff present it must follow // the existing morpheme-level stuff. if (fGotMorpheme && spec.MorphemeLevel && i >= firstMorphemeIndex && (!this[i].MorphemeLevel || spec.Flid == kflidMorphemes || spec.Flid == kflidLexEntries && this[i].Flid != kflidMorphemes)) { continue; } // And word-level annotations can't follow freeform ones. if (spec.WordLevel && !this[i].WordLevel) continue; m_specs.Insert(i + 1, spec); return i + 1; } } m_specs.Insert(0, spec); // can't follow anything, put first. return 0; }
// Find where the spec is in your collection. public int IndexOf(InterlinLineSpec spec) { return(m_specs.IndexOf(spec)); }
/// <summary> /// Compare the public property getters to the given spec. /// </summary> /// <param name="spec"></param> /// <returns>true if all the public getter values match.</returns> public bool SameSpec(InterlinLineSpec spec) { return ReflectionHelper.HaveSamePropertyValues(this, spec); }
protected override int LabelRGBFor(InterlinLineSpec spec) { // In the print view these colors are plain black. return(0); }
private int GetRealWsFromSpec(InterlinLineSpec spec) { if (!spec.IsMagicWritingSystem) { return spec.WritingSystem; } // special case, the only few we support so far (and only for a few fields). if (spec.WritingSystem == WritingSystemServices.kwsFirstAnal) return Cache.LangProject.DefaultAnalysisWritingSystem.Handle; if (spec.WritingSystem == WritingSystemServices.kwsVernInParagraph) return Cache.LangProject.DefaultVernacularWritingSystem.Handle; int ws = -50; try { ws = WritingSystemServices.InterpretWsLabel(Cache, spec.WsLabel(Cache).Text, null, 0, 0, null); } catch { Debug.Assert(ws != -50, "InterpretWsLabel was not able to interpret the Ws Label. The most likely cause for this is that a magic ws was passed in."); } return ws; }
public override void Display(IVwEnv vwenv, int hvo, int frag) { CheckDisposed(); try { switch (frag) { case kfragBundle: // One annotated word bundle, in this case, the whole view. if (hvo == 0) { return; } vwenv.set_IntProperty((int)FwTextPropType.ktptSpellCheck, (int)FwTextPropVar.ktpvEnum, (int)SpellingModes.ksmDoNotCheck); vwenv.set_IntProperty((int)FwTextPropType.ktptBackColor, (int)FwTextPropVar.ktpvDefault, krgbBackground); vwenv.OpenDiv(); vwenv.OpenParagraph(); // Since embedded in a pile with context, we need another layer of pile here,. // It's an overlay sandbox: draw a box around it. vwenv.OpenInnerPile(); // Inside that division we need a paragraph which does not have any border // or background. This suppresses the 'infinite width' behavior for the // nested paragraphs that may have grey border. vwenv.OpenParagraph(); // This makes a little separation between left border and arrows. vwenv.set_IntProperty((int)FwTextPropType.ktptPadLeading, (int)FwTextPropVar.ktpvMilliPoint, 1000); if (m_fRtl) { // This must not be on the outer paragraph or we get infinite width behavior. vwenv.set_IntProperty((int)FwTextPropType.ktptRightToLeft, (int)FwTextPropVar.ktpvEnum, (int)FwTextToggleVal.kttvForceOn); vwenv.set_IntProperty((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)FwTextAlign.ktalRight); } vwenv.OpenInnerPile(); for (int ispec = 0; ispec < m_choices.Count;) { InterlinLineSpec spec = m_choices[ispec]; if (!spec.WordLevel) { break; } if (spec.MorphemeLevel) { DisplayMorphBundles(vwenv, hvo); ispec = m_choices.LastMorphemeIndex + 1; continue; } switch (spec.Flid) { case InterlinLineChoices.kflidWord: int ws = GetActualWs(hvo, spec.StringFlid, spec.WritingSystem); DisplayWordform(vwenv, ws, ispec); break; case InterlinLineChoices.kflidWordGloss: DisplayWordGloss(vwenv, hvo, spec.WritingSystem, ispec); break; case InterlinLineChoices.kflidWordPos: DisplayWordPOS(vwenv, hvo, spec.WritingSystem, ispec); break; } ispec++; } vwenv.CloseInnerPile(); vwenv.CloseParagraph(); vwenv.CloseInnerPile(); vwenv.CloseParagraph(); vwenv.CloseDiv(); break; case kfragFirstMorph: // first morpheme in word case kfragMorph: // The bundle of 4 lines representing a morpheme. vwenv.set_IntProperty((int)FwTextPropType.ktptMarginTrailing, (int)FwTextPropVar.ktpvMilliPoint, 10000); vwenv.OpenInnerPile(); for (int ispec = m_choices.FirstMorphemeIndex; ispec <= m_choices.LastMorphemeIndex; ispec++) { int tagLexEntryIcon = 0; if (m_choices.FirstLexEntryIndex == ispec) { tagLexEntryIcon = ktagMorphEntryIcon; } InterlinLineSpec spec = m_choices[ispec]; switch (spec.Flid) { case InterlinLineChoices.kflidMorphemes: DisplayMorphForm(vwenv, hvo, frag, spec.WritingSystem, ispec); break; case InterlinLineChoices.kflidLexEntries: AddOptionalNamedObj(vwenv, hvo, ktagSbMorphEntry, ktagMissingEntry, kfragMissingEntry, tagLexEntryIcon, spec.WritingSystem, ispec); break; case InterlinLineChoices.kflidLexGloss: AddOptionalNamedObj(vwenv, hvo, ktagSbMorphGloss, ktagMissingMorphGloss, kfragMissingMorphGloss, tagLexEntryIcon, spec.WritingSystem, ispec); break; case InterlinLineChoices.kflidLexPos: AddOptionalNamedObj(vwenv, hvo, ktagSbMorphPos, ktagMissingMorphPos, kfragMissingMorphPos, tagLexEntryIcon, spec.WritingSystem, ispec); break; } } vwenv.CloseInnerPile(); break; default: if (frag >= kfragNamedObjectNameChoices && frag < kfragNamedObjectNameChoices + m_choices.Count) { InterlinLineSpec spec = m_choices[frag - kfragNamedObjectNameChoices]; int wsActual = GetActualWs(hvo, ktagSbNamedObjName, spec.WritingSystem); vwenv.AddStringAltMember(ktagSbNamedObjName, wsActual, this); } else { throw new Exception("Bad fragment ID in SandboxVc.Display"); } break; } } catch { Debug.Assert(false, "Exception thrown in the display of the SandboxVc (About to be eaten)"); } }
private void DisplayWordGloss(InterlinLineSpec spec, int choiceIndex) { switch(m_defaultObj.ClassID) { case WfiWordformTags.kClassId: m_this.SetColor(m_vwenv, m_this.LabelRGBFor(choiceIndex)); // looks like missing word gloss. m_vwenv.AddString(m_this.m_tssMissingGloss); break; case WfiAnalysisTags.kClassId: if (m_hvoDefault != m_hvoWordBundleAnalysis) { // Real analysis isn't what we're displaying, so morph breakdown // is a guess. Is it a human-approved guess? bool isHumanGuess = m_this.Decorator.get_IntProp(m_hvoDefault, InterlinViewDataCache.OpinionAgentFlid) != (int)AnalysisGuessServices.OpinionAgent.Parser; m_this.SetGuessing(m_vwenv, isHumanGuess ? ApprovedGuessColor : MachineGuessColor); } var wa = (IWfiAnalysis) m_defaultObj; if (wa.MeaningsOC.Count == 0) { // There's no gloss, display something indicating it is missing. m_this.SetColor(m_vwenv, m_this.LabelRGBFor(choiceIndex)); m_vwenv.AddString(m_this.m_tssMissingGloss); } else { m_vwenv.AddObj(wa.MeaningsOC.First().Hvo, m_this, kfragLineChoices + choiceIndex); } break; case WfiGlossTags.kClassId: if (m_hvoWordBundleAnalysis == m_hvoDefault) { var wsActual = spec.WritingSystem; if (spec.IsMagicWritingSystem) wsActual = GetRealWs(m_cache, m_hvoWordBundleAnalysis, spec, m_this.m_wsAnalysis); // We're displaying properties of the current object, can do // straightforwardly m_this.FormatGloss(m_vwenv, wsActual); m_vwenv.set_IntProperty((int)FwTextPropType.ktptSpellCheck, (int)FwTextPropVar.ktpvEnum, (int)SpellingModes.ksmForceCheck); m_vwenv.AddObj(m_hvoWordBundleAnalysis, m_this, kfragLineChoices + choiceIndex); } else { m_this.SetGuessing(m_vwenv); m_vwenv.AddObj(m_hvoDefault, m_this, kfragLineChoices + choiceIndex); } break; default: throw new Exception("Invalid type found in Segment analysis"); } }
public bool IsDefaultSpec(InterlinLineSpec spec) { return spec.SameSpec(CreateSpec(spec.Flid, 0)); }
// Find where the spec is in your collection. public int IndexOf(InterlinLineSpec spec) { return m_specs.IndexOf(spec); }
internal Color LabelColorFor(InterlinLineSpec spec) { if (spec.MorphemeLevel) return kMorphLevelColor; else if (spec.WordLevel && spec.Flid != InterlinLineChoices.kflidWord) return kWordLevelColor; else return SystemColors.ControlText; }
internal int LabelRGBFor(InterlinLineSpec spec) { return (int)CmObjectUi.RGB(LabelColorFor(spec)); }
/// <summary> /// Remove the specified field (and any dependents, with warning). /// If there are dependents, this will interact with the user to ask whether to /// go ahead. /// </summary> /// <param name="spec"></param> public virtual void Remove(InterlinLineSpec spec) { m_specs.Remove(spec); Debug.Assert(m_specs.Count > 0); }
internal bool OkToRemove(InterlinLineSpec spec) { string message; return OkToRemove(spec, out message); }
/// <summary> /// Call before calling Remove. True and null message indicates no problem to /// remove this field. /// If it returns a true, display a message box indicating the Remove is not /// possible, using the returned message. /// If it returns false and a message, there is a warning, display it and /// allow the user to possibly cancel. /// </summary> /// <param name="spec"></param> /// <returns></returns> public virtual bool OkToRemove(InterlinLineSpec spec, out string message) { if (m_specs.Count == 1) { message = ITextStrings.ksNeedOneField; return false; } message = null; return true; }
/// <summary> /// /// </summary> /// <param name="flid"></param> /// <param name="wsRequested">If zero, supply the default ws for the field; otherwise /// use the one supplied.</param> /// <returns></returns> internal InterlinLineSpec CreateSpec(int flid, int wsRequested) { int ws = 0; bool fMorphemeLevel = false; bool fWordLevel = true; int flidString = 0; ColumnConfigureDialog.WsComboContent comboContent = ColumnConfigureDialog.WsComboContent.kwccAnalysis; // The usual choice switch (flid) { case kflidWord: comboContent = ColumnConfigureDialog.ChooseComboContent(m_wsDefVern, "vernacular"); ws = m_wsDefVern; break; // vern, not interlin, word case kflidLexEntries: case kflidMorphemes: fMorphemeLevel = true; comboContent = ColumnConfigureDialog.ChooseComboContent(m_wsDefVern, "vernacular"); flidString = (int)MoForm.MoFormTags.kflidForm; ws = m_wsDefVern; break; // vern, morpheme case kflidLexGloss: fMorphemeLevel = true; ws = LangProject.kwsFirstAnal; flidString = (int)LexSense.LexSenseTags.kflidGloss; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // analysis, morpheme case kflidLexPos: fMorphemeLevel = true; // getting to the string takes a couple of levels // so just do it when we have the actual hvos. flidString = -1; ws = LangProject.kwsFirstAnal; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // analysis, morpheme case kflidWordGloss: ws = m_wsDefAnal; break; // not morpheme-level case kflidWordPos: ws = LangProject.kwsFirstAnal; flidString = (int)CmPossibility.CmPossibilityTags.kflidAbbreviation; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // not morpheme-level case kflidFreeTrans: case kflidLitTrans: ws = m_wsDefAnal; fWordLevel = false; break; case kflidNote: comboContent = ColumnConfigureDialog.WsComboContent.kwccVernAndAnal; ws = m_wsDefAnal; fWordLevel = false; break; default: throw new Exception("Adding unknown field to interlinear"); } InterlinLineSpec spec = new InterlinLineSpec(); spec.ComboContent = comboContent; spec.Flid = flid; spec.WritingSystem = wsRequested == 0 ? ws : wsRequested; spec.MorphemeLevel = fMorphemeLevel; spec.WordLevel = fWordLevel; spec.StringFlid = flidString; return(spec); }
private void DisplayWord(InterlinLineSpec spec, int choiceIndex, IAnalysis wag) { var wsActual = m_this.GetRealWsOrBestWsForContext(m_hvoWordform, spec); var tssRealForm = GetRealForm(wsActual, choiceIndex); if (tssRealForm != null && tssRealForm.Length > 0) { m_this.IsDoingRealWordForm = true; // LT-12203 Text chart doesn't want multiple analyses highlighting if (m_fshowMultipleAnalyses) { //identify those words the user has yet to approve which have multiple possible //guesses user or machine, and set the background to a special color var word = wag as IWfiWordform; if (word != null) { //test if there are multiple analyses that a user might choose from if (SandboxBase.GetHasMultipleRelevantAnalyses(word)) { m_this.SetGuessing(m_vwenv, MultipleApprovedGuessColor); //There are multiple options, set the color } } } m_vwenv.AddString(tssRealForm); m_this.IsDoingRealWordForm = false; return; } switch (m_defaultObj.ClassID) { case WfiWordformTags.kClassId: case WfiAnalysisTags.kClassId: case WfiGlossTags.kClassId: m_vwenv.AddObj(m_hvoWordform, m_this, kfragLineChoices + choiceIndex); break; default: throw new Exception("Invalid type found in Segment analysis"); } }
/// <summary> /// /// </summary> /// <param name="flid"></param> /// <param name="wsRequested">If zero, supply the default ws for the field; otherwise /// use the one supplied.</param> /// <returns></returns> internal InterlinLineSpec CreateSpec(int flid, int wsRequested) { int ws = 0; bool fMorphemeLevel = false; bool fWordLevel = true; int flidString = 0; ColumnConfigureDialog.WsComboContent comboContent = ColumnConfigureDialog.WsComboContent.kwccAnalysis; // The usual choice switch (flid) { case kflidWord: comboContent = ColumnConfigureDialog.ChooseComboContent(m_cache, m_wsDefVern, "vernacular"); ws = m_wsDefVern; break; // vern, not interlin, word case kflidLexEntries: case kflidMorphemes: fMorphemeLevel = true; comboContent = ColumnConfigureDialog.ChooseComboContent(m_cache, m_wsDefVern, "vernacular"); flidString = MoFormTags.kflidForm; ws = m_wsDefVern; break; // vern, morpheme case kflidLexGloss: fMorphemeLevel = true; ws = WritingSystemServices.kwsFirstAnal; flidString = LexSenseTags.kflidGloss; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // analysis, morpheme case kflidLexPos: fMorphemeLevel = true; // getting to the string takes a couple of levels // so just do it when we have the actual hvos. flidString = -1; ws = WritingSystemServices.kwsFirstAnal; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // analysis, morpheme case kflidWordGloss: ws = m_wsDefAnal; break; // not morpheme-level case kflidWordPos: ws = WritingSystemServices.kwsFirstAnal; flidString = CmPossibilityTags.kflidAbbreviation; comboContent = ColumnConfigureDialog.WsComboContent.kwccBestAnalysis; break; // not morpheme-level case kflidFreeTrans: case kflidLitTrans: ws = m_wsDefAnal; fWordLevel = false; break; case kflidNote: comboContent = ColumnConfigureDialog.WsComboContent.kwccVernAndAnal; ws = m_wsDefAnal; fWordLevel = false; break; default: throw new Exception("Adding unknown field to interlinear"); } InterlinLineSpec spec = new InterlinLineSpec(); spec.ComboContent = comboContent; spec.Flid = flid; spec.WritingSystem = wsRequested == 0 ? ws : wsRequested; spec.MorphemeLevel = fMorphemeLevel; spec.WordLevel = fWordLevel; spec.StringFlid = flidString; return spec; }
virtual protected int LabelRGBFor(InterlinLineSpec spec) { return m_lineChoices.LabelRGBFor(spec); }
static private int GetRealWs(FdoCache cache, int hvo, InterlinLineSpec spec, int wsPreferred) { int ws = 0; switch (spec.WritingSystem) { case LangProject.kwsVernInParagraph: // we want to display the wordform using the twfic ws. ws = wsPreferred; break; default: ws = spec.GetActualWs(cache, hvo, wsPreferred); // ws = cache.LangProject.ActualWs(spec.WritingSystem, hvo, spec.StringFlid); break; } return ws; }
private IEnumerable<WsComboItem> GetWsComboItems(InterlinLineSpec curSpec) { using (var dummyCombobox = new ComboBox()) { var dummyCachedBoxes = new Dictionary<ColumnConfigureDialog.WsComboContent, ComboBox.ObjectCollection>(); var comboObjects = ConfigureInterlinDialog.WsComboItemsInternal( Cache, dummyCombobox, dummyCachedBoxes, curSpec.ComboContent); var choices = new WsComboItem[comboObjects.Count]; comboObjects.CopyTo(choices, 0); return choices; } }
public bool IsDefaultSpec(InterlinLineSpec spec) { return(spec.SameSpec(CreateSpec(spec.Flid, 0))); }
protected override int LabelRGBFor(InterlinLineSpec spec) { // In the print view these colors are plain black. return 0; }
private void currentList_DrawItem(object sender, DrawListViewItemEventArgs e) { InterlinLineSpec spec = m_choices[e.ItemIndex] as InterlinLineSpec; DrawItem(e, spec); }
// Init the list and select specified item void InitCurrentList(InterlinLineSpec spec) { InitCurrentList(m_choices.IndexOf(spec)); }
internal int LabelRGBFor(InterlinLineSpec spec) { return((int)CmObjectUi.RGB(LabelColorFor(spec))); }
private List<InterlinLineSpec> FindDependents(InterlinLineSpec spec) { List<InterlinLineSpec> dependents = new List<InterlinLineSpec>(); return dependents; }
/// <summary> /// Overridden to prevent removing the Words line and to remove dependents of the line being removed /// (after warning the user). /// </summary> /// <param name="spec"></param> public override void Remove(InterlinLineSpec spec) { List<InterlinLineSpec> dependents = new List<InterlinLineSpec>(); dependents = FindDependents(spec); foreach (InterlinLineSpec depSpec in dependents) m_specs.Remove(depSpec); base.Remove(spec); }
private void DrawItem(System.Windows.Forms.DrawListViewItemEventArgs e, InterlinLineSpec spec) { Brush backBrush = SystemBrushes.ControlLightLight; if (e.Item.Selected) backBrush = SystemBrushes.Highlight; e.Graphics.FillRectangle(backBrush, e.Bounds); if (e.Item.Focused) ControlPaint.DrawFocusRectangle(e.Graphics, e.Bounds); SolidBrush textBrush = GetBrush(spec, e.Item.Selected) as SolidBrush; try { Font drawFont = e.Item.Font; ListViewItem item = e.Item as ListViewItem; // Draw the line label. e.Graphics.DrawString(item.Text, drawFont, textBrush, e.Bounds); // Now draw the WritingSystem info. e.Graphics.DrawString(item.SubItems[1].Text, item.SubItems[1].Font, e.Item.Selected ? textBrush : SystemBrushes.ControlText, item.SubItems[1].Bounds); } finally { if (!e.Item.Selected) textBrush.Dispose(); } }
/// <summary> /// Answer true if it is valid for the field indicated in spec2 to immediately /// follow the one indicated in spec1. By default any order is OK. This routine is /// not responsible for the restrictions related to keeping word level stuff before /// freeforms and morpheme-level stuff together. /// </summary> /// <param name="spec1"></param> /// <param name="spec2"></param> /// <returns></returns> internal virtual bool CanFollow(InterlinLineSpec spec1, InterlinLineSpec spec2) { return true; }
private void DrawItem(System.Windows.Forms.DrawItemEventArgs e, InterlinLineSpec spec) { bool selected = ((e.State & DrawItemState.Selected) != 0); Brush textBrush = GetBrush(spec, selected); try { Font drawFont = e.Font; e.DrawBackground(); e.Graphics.DrawString(optionsList.Items[e.Index].ToString(), drawFont, textBrush, e.Bounds); } finally { if (!selected) textBrush.Dispose(); } }
public override bool OkToRemove(InterlinLineSpec spec, out string message) { if (!base.OkToRemove(spec, out message)) return false; if (spec.Flid == kflidWord && spec.WritingSystem == m_wsDefVern && ItemsWithFlids(new int[] {kflidWord}, new int[] {m_wsDefVern}).Count < 2) { message = ITextStrings.ksNeedWordLine; return false; } if (FindDependents(spec).Count > 0) { // Enhance JohnT: get the names and include them in the message. message = ITextStrings.ksHidesDependentLinesAlso; // OK to go ahead if the user wishes, return true. } return true; }
/// <summary> /// try to get the ws specified by spec.WritingSystem, otherwise /// get the default vernacular ws for the display (e.g. ws of paragraph). /// </summary> /// <param name="hvo"></param> /// <param name="spec"></param> /// <returns></returns> internal int GetRealWsOrBestWsForContext(int hvo, InterlinLineSpec spec) { if (spec != null && !spec.IsMagicWritingSystem && spec.WritingSystem > 0) return GetRealWs(m_cache, hvo, spec, spec.WritingSystem); return GetRealWs(m_cache, hvo, spec, m_wsVernForDisplay); }
static private int GetRealWs(FdoCache cache, int hvo, InterlinLineSpec spec, int wsPreferred) { int ws = 0; switch (spec.WritingSystem) { case WritingSystemServices.kwsVernInParagraph: // we want to display the wordform using its own ws. ws = wsPreferred; break; default: ws = spec.GetActualWs(cache, hvo, wsPreferred); break; } return ws; }
internal static bool TryGetLexGlossWithInflTypeTss(ILexEntry possibleVariant, ILexSense sense, InterlinLineSpec spec, InterlinLineChoices lineChoices, int vernWsContext, ILexEntryInflType inflType, out ITsString result) { FdoCache cache = possibleVariant.Cache; using (var vcLexGlossFrag = new InterlinVc(cache)) { vcLexGlossFrag.LineChoices = lineChoices; vcLexGlossFrag.PreferredVernWs = vernWsContext; result = null; var collector = new TsStringCollectorEnv(null, vcLexGlossFrag.Cache.MainCacheAccessor, possibleVariant.Hvo) { RequestAppendSpaceForFirstWordInNewParagraph = false }; if (vcLexGlossFrag.DisplayLexGlossWithInflType(collector, possibleVariant, sense, spec, inflType)) { result = collector.Result; return true; } return false; } }
private Brush GetBrush(InterlinLineSpec spec, bool selected) { Brush textBrush = SystemBrushes.ControlText; if (selected) { textBrush = SystemBrushes.HighlightText; } else { textBrush = new SolidBrush(m_choices.LabelColorFor(spec)); } return textBrush; }
/// <summary> /// NOTE: this routine is ignorant of calling context, so caller must provide NoteDependency to the possibleVariant and the sense /// (e.g. vwenv.NoteDependency(new[] { wfiMorphBundle.Hvo }, new[] { WfiMorphBundleTags.kflidSense }, 1); /// vwenv.NoteDependency(new[] { wfiMorphBundle.Hvo }, new[] { WfiMorphBundleTags.kflidInflType }, 1); /// </summary> /// <param name="vwenv"></param> /// <param name="possibleVariant"></param> /// <param name="sense"></param> /// <param name="spec"></param> /// <param name="inflType"></param> /// <returns>true if there was anything to display </returns> internal bool DisplayLexGlossWithInflType(IVwEnv vwenv, ILexEntry possibleVariant, ILexSense sense, InterlinLineSpec spec, ILexEntryInflType inflType) { int iLineChoice = m_lineChoices.IndexOf(spec); ILexEntryRef ler; if (possibleVariant.IsVariantOfSenseOrOwnerEntry(sense, out ler)) { var wsPreferred = GetRealWsOrBestWsForContext(sense.Hvo, spec); var wsGloss = Cache.ServiceLocator.WritingSystemManager.Get(wsPreferred); var wsUser = Cache.ServiceLocator.WritingSystemManager.UserWritingSystem; var testGloss = sense.Gloss.get_String(wsPreferred); // don't bother adding anything for an empty gloss. if (testGloss.Text != null && testGloss.Text.Length >= 0) { vwenv.OpenParagraph(); // see if we have an irregularly inflected form type reference var leitFirst = ler.VariantEntryTypesRS.Where( let => let.ClassID == LexEntryInflTypeTags.kClassId).FirstOrDefault(); // add any GlossPrepend info if (leitFirst != null) { vwenv.OpenInnerPile(); // TODO: add dependency to VariantType GlossPrepend/Append names vwenv.NoteDependency(new[] { ler.Hvo }, new[] { LexEntryRefTags.kflidVariantEntryTypes }, 1); vwenv.OpenParagraph(); ITsString tssPrepend = null; if (inflType != null) { tssPrepend = MorphServices.AddTssGlossAffix(null, inflType.GlossPrepend, wsGloss, wsUser); } else { ITsIncStrBldr sbPrepend; ITsIncStrBldr sbAppend; JoinGlossAffixesOfInflVariantTypes(ler, wsPreferred, out sbPrepend, out sbAppend); if (sbPrepend.Text != null) tssPrepend = sbPrepend.GetString(); } if (tssPrepend != null) vwenv.AddString(tssPrepend); vwenv.CloseParagraph(); vwenv.CloseInnerPile(); } // add gloss of main entry or sense { vwenv.OpenInnerPile(); // NOTE: remember to NoteDependency from OuterObject vwenv.AddObj(sense.Hvo, this, kfragLineChoices + iLineChoice); vwenv.CloseInnerPile(); } // now add variant type info if (leitFirst != null) { vwenv.OpenInnerPile(); // TODO: add dependency to VariantType GlossPrepend/Append names vwenv.NoteDependency(new[] { ler.Hvo }, new[] { LexEntryRefTags.kflidVariantEntryTypes }, 1); vwenv.OpenParagraph(); ITsString tssAppend = null; if (inflType != null) { tssAppend = MorphServices.AddTssGlossAffix(null, inflType.GlossAppend, wsGloss, wsUser); } else { ITsIncStrBldr sbPrepend; ITsIncStrBldr sbAppend; JoinGlossAffixesOfInflVariantTypes(ler, wsPreferred, out sbPrepend, out sbAppend); if (sbAppend.Text != null) tssAppend = sbAppend.GetString(); } { // Use AddProp/DisplayVariant to store GlossAppend with m_tssPendingGlossAffix // this allows InterlinearExporter to know to export a glsAppend item try { if (tssAppend != null) m_tssPendingGlossAffix = tssAppend; else m_tssPendingGlossAffix = m_tssMissingGlossAppend; vwenv.AddProp(ktagGlossAppend, this, 0); } finally { m_tssPendingGlossAffix = null; } } vwenv.CloseParagraph(); vwenv.CloseInnerPile(); } vwenv.CloseParagraph(); return true; } } return false; }
internal int GetRealWs(int hvo, InterlinLineSpec spec) { int wsPreferred = m_wsCurrentTwfic; if (wsPreferred == 0) wsPreferred = m_wsVernForDisplay; return GetRealWs(m_cache, hvo, spec, wsPreferred); }
/// <summary> /// Add the specified flid (in the appropriate default writing system). /// </summary> /// <param name="flid"></param> /// <param name="ws">If zero, supply the default ws for the field; otherwise /// use the one supplied.</param> /// <returns>the integer where inserted</returns> public int Add(int flid, int wsRequested) { InterlinLineSpec spec = CreateSpec(flid, wsRequested); return(Add(spec)); }