public void SenseTreeLexicalRelationName() { NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () => { ILexEntry entry1 = m_cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(m_cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>().GetObject(MoMorphTypeTags.kguidMorphStem), m_cache.TsStrFactory.MakeString("form1", m_cache.DefaultVernWs), "gloss1", new SandboxGenericMSA()); ILexEntry entry2 = m_cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(m_cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>().GetObject(MoMorphTypeTags.kguidMorphStem), m_cache.TsStrFactory.MakeString("form2", m_cache.DefaultVernWs), "gloss2", new SandboxGenericMSA()); ILexEntry entry3 = m_cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(m_cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>().GetObject(MoMorphTypeTags.kguidMorphStem), m_cache.TsStrFactory.MakeString("form3", m_cache.DefaultVernWs), "gloss3", new SandboxGenericMSA()); m_cache.LangProject.LexDbOA.ReferencesOA = m_cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>().Create(); ILexRefType senseLexRefType = m_cache.ServiceLocator.GetInstance <ILexRefTypeFactory>().Create(); m_cache.LangProject.LexDbOA.ReferencesOA.PossibilitiesOS.Add(senseLexRefType); senseLexRefType.MappingType = (int)LexRefTypeTags.MappingTypes.kmtSenseTree; senseLexRefType.Name.SetAnalysisDefaultWritingSystem("Part"); senseLexRefType.ReverseName.SetAnalysisDefaultWritingSystem("Whole"); ILexReference senseLexRef = m_cache.ServiceLocator.GetInstance <ILexReferenceFactory>().Create(); senseLexRefType.MembersOC.Add(senseLexRef); senseLexRef.TargetsRS.Add(entry1.SensesOS[0]); senseLexRef.TargetsRS.Add(entry2.SensesOS[0]); senseLexRef.TargetsRS.Add(entry3.SensesOS[0]); }); Lexeme lexeme = m_lexicon.FindMatchingLexemes("form1").Single(); Assert.That(lexeme.LexicalRelations.Select(lr => lr.Name), Is.EquivalentTo(new[] { "Part", "Part" })); lexeme = m_lexicon.FindMatchingLexemes("form2").Single(); Assert.That(lexeme.LexicalRelations.Select(lr => lr.Name), Is.EquivalentTo(new[] { "Whole", "Other" })); }
private void CreateLexReference(ILexRefType lrt, IEnumerable <ICmObject> sensesAndEntries, Guid lexRefGuid) { var lexRef = Cache.ServiceLocator.GetInstance <ILexReferenceFactory>().Create(lexRefGuid, lrt); foreach (var senseOrEntry in sensesAndEntries) { lexRef.TargetsRS.Add(senseOrEntry); } }
private ILexReference MakeLexReference(ILexRefType owner, ILexSense firstTarget) { ILexReference result = null; result = Cache.ServiceLocator.GetInstance <ILexReferenceFactory>().Create(); owner.MembersOC.Add(result); result.TargetsRS.Add(firstTarget); return(result); }
private string GetLexReferenceName(ILexEntry lexEntry, ILexReference lexRef, out ILexEntry parentEntry) { parentEntry = null; ILexRefType lexRefType = lexRef.OwnerOfClass <ILexRefType>(); string name = lexRefType.ShortName; if (string.IsNullOrEmpty(name)) { name = lexRefType.Abbreviation.BestAnalysisAlternative.Text; } var mappingType = (LexRefTypeTags.MappingTypes)lexRefType.MappingType; switch (mappingType) { case LexRefTypeTags.MappingTypes.kmtSenseTree: case LexRefTypeTags.MappingTypes.kmtEntryTree: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: // Sense Pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: // Entry Pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense Pair with different Forward/Reverse names if (lexRef.TargetsRS.Count > 0) { ICmObject firstObj = lexRef.TargetsRS[0]; ILexEntry firstEntry = null; switch (firstObj.ClassID) { case LexEntryTags.kClassId: firstEntry = (ILexEntry)firstObj; break; case LexSenseTags.kClassId: firstEntry = firstObj.OwnerOfClass <ILexEntry>(); break; } if (firstEntry != lexEntry) { name = lexRefType.ReverseName.BestAnalysisAlternative.Text; if (string.IsNullOrEmpty(name)) { name = lexRefType.ReverseAbbreviation.BestAnalysisAlternative.Text; } } if (mappingType == LexRefTypeTags.MappingTypes.kmtSenseTree || mappingType == LexRefTypeTags.MappingTypes.kmtEntryTree || mappingType == LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree) { parentEntry = firstEntry; } } break; } return(name.Normalize()); }
private ILexReference MakeLexRef(ILexRefType owner, ICmObject[] targets) { var result = m_lexRefFactory.Create(); owner.MembersOC.Add(result); foreach (var obj in targets) { result.TargetsRS.Add(obj); } return(result); }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, m_obj.OwnerHVO); LexRefType.MappingTypes type = (LexRefType.MappingTypes)lrt.MappingType; BaseGoDlg dlg = null; switch (type) { case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: // Sense pair with different Forward/Reverse names dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: // Entry pair with different Forward/Reverse names dlg = new GoDlg(); break; case LexRefType.MappingTypes.kmtEntryOrSensePair: case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; break; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); //on creating Pair Lexical Relation have an Add button and Add in the title bar if (TargetHvo == 0) { wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.Name.AnalysisDefaultWritingSystem); wp.m_btnText = LexEdStrings.ks_Add; } else //Otherwise we are Replacing the item { wp.m_title = String.Format(LexEdStrings.ksReplaceXEntry); wp.m_btnText = LexEdStrings.ks_Replace; } wp.m_label = LexEdStrings.ksFind_; dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { TargetHvo = dlg.SelectedID; } dlg.Dispose(); }
public void HandleMoreMenuItem(object sender, EventArgs ea) { CheckDisposed(); XCore.XMessageBoxExManager.Trigger("CreateNewLexicalReferenceType"); m_cache.DomainDataByFlid.BeginUndoTask(LexEdStrings.ksUndoInsertLexRefType, LexEdStrings.ksRedoInsertLexRefType); ICmPossibilityList list = m_cache.LanguageProject.LexDbOA.ReferencesOA; ILexRefType newKid = list.Services.GetInstance <ILexRefTypeFactory>().Create(); list.PossibilitiesOS.Add(newKid); m_cache.DomainDataByFlid.EndUndoTask(); ContainingDataTree.Mediator.SendMessage("FollowLink", new FwLinkArgs("lexRefEdit", newKid.Guid)); }
private ILexRefType MakeLexRefType(string name) { ILexRefType result = null; if (Cache.LangProject.LexDbOA.ReferencesOA == null) { Cache.LangProject.LexDbOA.ReferencesOA = Cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>().Create(); } result = Cache.ServiceLocator.GetInstance <ILexRefTypeFactory>().Create(); Cache.LangProject.LexDbOA.ReferencesOA.PossibilitiesOS.Add(result); result.MappingType = (int)LexRefTypeTags.MappingTypes.kmtSenseSequence; result.Name.AnalysisDefaultWritingSystem = TsStringUtils.MakeString(name, Cache.DefaultAnalWs); return(result); }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private ICmObject GetRootObject(ILexRefType lrt) { ICmObject first = null; EntryGoDlg dlg = null; try { switch ((LexRefTypeTags.MappingTypes)lrt.MappingType) { case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; default: Debug.Assert(lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree); return(null); } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.ReverseName.BestAnalysisAlternative.Text), m_btnText = LexEdStrings.ks_Add }; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { first = dlg.SelectedObject; } return(first); } finally { if (dlg != null) { dlg.Dispose(); } } }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private int GetRootObjectHvo(ILexRefType lrt) { int hvoFirst = 0; BaseEntryGoDlg dlg = null; switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseAsymmetricPair: case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefType.MappingTypes.kmtEntryAsymmetricPair: case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); break; case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; default: Debug.Assert(lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseTree); return(0); } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); //wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, // lrt.Name.AnalysisDefaultWritingSystem); wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.ReverseName.BestAnalysisAlternative.Text); wp.m_label = LexEdStrings.ksFind_; //wp.m_btnText = LexEdStrings.ks_Link; wp.m_btnText = LexEdStrings.ks_Add; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { hvoFirst = dlg.SelectedID; } dlg.Dispose(); return(hvoFirst); }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = (ILexRefType)m_obj.Owner; int type = lrt.MappingType; BaseGoDlg dlg = null; try { switch ((LexRefTypeTags.MappingTypes)type) { case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = String.Format(LexEdStrings.ksReplaceXEntry), m_btnText = LexEdStrings.ks_Replace }; //This method is only called when we are Replacing the //tree root of a Whole/Part lexical relation dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { if (dlg.SelectedObject != null) { AddItem(dlg.SelectedObject); } } } finally { if (dlg != null) { dlg.Dispose(); } } }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = (ILexRefType)m_obj.Owner; int type = lrt.MappingType; BaseGoDlg dlg = null; try { switch ((LexRefTypeTags.MappingTypes)type) { case LexRefTypeTags.MappingTypes.kmtSenseSequence: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefTypeTags.MappingTypes.kmtEntrySequence: dlg = new EntryGoDlg(); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseSequence: dlg = new LinkEntryOrSenseDlg(); break; } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.Name.BestAnalysisAlternative.Text), m_btnText = LexEdStrings.ks_Add }; dlg.SetDlgInfo(m_cache, wp, m_mediator, m_propertyTable); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { if (!(m_obj as ILexReference).TargetsRS.Contains(dlg.SelectedObject)) { AddItem(dlg.SelectedObject); } } } finally { if (dlg != null) { dlg.Dispose(); } } }
public ILexRefType Create(Guid guid, ILexRefType owner) { ILexRefType lexRefType; if(guid == Guid.Empty) { lexRefType = Create(); } else { var hvo = ((IDataReader)m_cache.ServiceLocator.GetInstance<IDataSetup>()).GetNextRealHvo(); lexRefType = new LexRefType(m_cache, hvo, guid); } if(owner != null) { owner.SubPossibilitiesOS.Add(lexRefType); } return lexRefType; }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, m_obj.OwnerHVO); LexRefType.MappingTypes type = (LexRefType.MappingTypes)lrt.MappingType; BaseGoDlg dlg = null; string sTitle = ""; switch (type) { case LexRefType.MappingTypes.kmtSenseCollection: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryCollection: dlg = new GoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryOrSenseCollection: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); wp.m_title = sTitle; wp.m_label = LexEdStrings.ksFind_; wp.m_btnText = LexEdStrings.ks_Add; //for collection relation of items always have an Add button dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { AddItem(dlg.SelectedID); } dlg.Dispose(); }
public void HandleMoreMenuItem(object sender, EventArgs ea) { CheckDisposed(); XCore.XMessageBoxExManager.Trigger("CreateNewLexicalReferenceType"); m_cache.BeginUndoTask(LexEdStrings.ksUndoInsertLexRefType, LexEdStrings.ksRedoInsertLexRefType); ICmPossibilityList list = m_cache.LangProject.LexDbOA.ReferencesOA; ILexRefType newKid = (ILexRefType)list.PossibilitiesOS.Append(new LexRefType()); m_cache.EndUndoTask(); m_cache.MainCacheAccessor.PropChanged(null, (int)PropChangeType.kpctNotifyAll, list.Hvo, (int)CmPossibilityList.CmPossibilityListTags.kflidPossibilities, list.PossibilitiesOS.Count - 1, 1, 0); ContainingDataTree.Mediator.SendMessage("FollowLink", SIL.FieldWorks.FdoUi.FwLink.Create("lexRefEdit", m_cache.GetGuidFromId(newKid.Hvo), m_cache.ServerName, m_cache.DatabaseName)); }
private void GetOwnerAndWsCode(int ws, out ILexRefType lrtOwner, out SpecialWritingSystemCodes wsCode) { lrtOwner = m_lexRef.Owner as ILexRefType; wsCode = SpecialWritingSystemCodes.DefaultAnalysis; if (ws < 0) { switch (ws) { case WritingSystemServices.kwsAnal: wsCode = SpecialWritingSystemCodes.DefaultAnalysis; break; case WritingSystemServices.kwsVern: wsCode = SpecialWritingSystemCodes.DefaultVernacular; break; default: wsCode = (SpecialWritingSystemCodes)ws; break; } } }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, m_obj.OwnerHVO); int type = lrt.MappingType; BaseGoDlg dlg = null; switch ((LexRefType.MappingTypes)type) { case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); break; case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); //This method is only called when we are Replacing the //tree root of a Whole/Part lexical relation wp.m_title = String.Format(LexEdStrings.ksReplaceXEntry); wp.m_btnText = LexEdStrings.ks_Replace; wp.m_label = LexEdStrings.ksFind_; dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { TargetHvo = dlg.SelectedID; } dlg.Dispose(); }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, m_obj.OwnerHVO); int type = lrt.MappingType; BaseGoDlg dlg = null; switch ((LexRefType.MappingTypes)type) { case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); break; case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.Name.AnalysisDefaultWritingSystem); wp.m_label = LexEdStrings.ksFind_; wp.m_btnText = LexEdStrings.ks_Add; //for parts of a whole always have an Add button dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { AddItem(dlg.SelectedID); } dlg.Dispose(); }
public void HandleCreateMenuItem(object sender, EventArgs ea) { CheckDisposed(); if (!m_cache.VerifyValidObject(m_obj)) { return; } int itemIndex = (((ToolStripItem)(sender)).Owner as ContextMenuStrip).Items.IndexOf((ToolStripItem)sender); int hvoType = m_refTypesAvailable[itemIndex]; bool fReverseRef = m_rgfReversedRefType[itemIndex]; ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, hvoType); int hvoNew = 0; int hvoFirst = 0; if (fReverseRef) { // When creating a tree Lexical Relation and the user is choosing // the root of the tree, first see if the user selects a lexical entry. // If they do not select anything (hvoFirst==0) return and do not create the slice. hvoFirst = GetRootObjectHvo(lrt); if (hvoFirst == 0) { return; // the user cancelled out of the operation. } if (lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseTree || lrt.MappingType == (int)LexRefType.MappingTypes.kmtEntryTree || lrt.MappingType == (int)LexRefType.MappingTypes.kmtEntryOrSenseTree) { // Use an existing LexReference if one exists. foreach (ILexReference lr in lrt.MembersOC) { if (lr.TargetsRS.Count > 0 && lr.TargetsRS.HvoArray[0] == hvoFirst) { lr.TargetsRS.Append(m_obj.Hvo); hvoNew = lr.Hvo; break; } } } } else { // Launch the dialog that allows the user to choose a lexical entry. // If they choose an entry, it is returned in hvoFirst so go ahead and // create the lexical relation and add this lexical entry to that relation. hvoFirst = GetChildObjectHvo(lrt); if (hvoFirst == 0) { return; // the user cancelled out of the operation. } } if (hvoNew == 0) { hvoNew = m_cache.CreateObject((int)LexReference.kclsidLexReference, hvoType, (int)LexRefType.LexRefTypeTags.kflidMembers, 0); ILexReference lr = LexReference.CreateFromDBObject(m_cache, hvoNew); if (fReverseRef) { lr.TargetsRS.InsertAt(hvoFirst, 0); lr.TargetsRS.InsertAt(m_obj.Hvo, 1); } else { //When creating a lexical relation slice, //add the current lexical entry to the lexical relation as the first item lr.TargetsRS.InsertAt(m_obj.Hvo, 0); //then also add the lexical entry that the user selected in the chooser dialog. lr.TargetsRS.InsertAt(hvoFirst, 1); } } m_refs.Add(hvoNew); this.ExpandNewNode(); // update the cache through our virtual handler. if (m_vh != null) { IVwCacheDa cda = m_cache.VwCacheDaAccessor; int flid = m_vh.Tag; m_vh.Load(m_obj.Hvo, flid, 0, cda); m_cache.MainCacheAccessor.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_obj.Hvo, flid, 0, 1, 0); } (m_obj as CmObject).UpdateTimestampForVirtualChange(); if (hvoFirst != 0) { ICmObject cmoFirst = CmObject.CreateFromDBObject(m_cache, hvoFirst); (cmoFirst as CmObject).UpdateTimestampForVirtualChange(); } }
/// <summary> /// Override method to handle launching of a chooser for selecting lexical entries. /// </summary> protected override void HandleChooser() { ILexRefType lrt = (ILexRefType)m_obj.Owner; LexRefTypeTags.MappingTypes type = (LexRefTypeTags.MappingTypes)lrt.MappingType; BaseGoDlg dlg = null; try { switch (type) { case LexRefTypeTags.MappingTypes.kmtSensePair: case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: // Sense pair with different Forward/Reverse names dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefTypeTags.MappingTypes.kmtEntryPair: case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: // Entry pair with different Forward/Reverse names dlg = new EntryGoDlg(); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSensePair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; break; } Debug.Assert(dlg != null); var wp = new WindowParams(); //on creating Pair Lexical Relation have an Add button and Add in the title bar if (Target == null) { wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.Name.BestAnalysisAlternative.Text); wp.m_btnText = LexEdStrings.ks_Add; } else //Otherwise we are Replacing the item { wp.m_title = String.Format(LexEdStrings.ksReplaceXEntry); wp.m_btnText = LexEdStrings.ks_Replace; } dlg.SetDlgInfo(m_cache, wp, m_mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { if (dlg.SelectedObject != null) { AddItem(dlg.SelectedObject); // it is possible that the previous update has caused the data tree to refresh if (!IsDisposed) { m_atomicRefView.RootBox.Reconstruct(); // view is somehow too complex for auto-update. } } } } finally { if (dlg != null) { dlg.Dispose(); } } }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private int GetChildObjectHvo(ILexRefType lrt) { int hvoFirst = 0; BaseEntryGoDlg dlg = null; string sTitle = ""; switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtEntryOrSensePair: case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtSenseCollection: case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: // Sense pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtSenseSequence: case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryCollection: case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: // Entry pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntrySequence: case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryOrSenseCollection: case LexRefType.MappingTypes.kmtEntryOrSenseSequence: case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; default: Debug.Assert(lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseTree); return(0); } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); wp.m_title = sTitle; wp.m_label = LexEdStrings.ksFind_; wp.m_btnText = LexEdStrings.ks_Add; // Don't display the current entry in the list of matching entries. See LT-2611. ICmObject objEntry = this.Object; while (objEntry.ClassID == LexSense.kclsidLexSense) { objEntry = CmObject.CreateFromDBObject(m_cache, objEntry.OwnerHVO); } Debug.Assert(objEntry.ClassID == LexEntry.kclsidLexEntry); dlg.StartingEntry = objEntry as ILexEntry; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { hvoFirst = dlg.SelectedID; } dlg.Dispose(); return(hvoFirst); }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private ICmObject GetChildObject(ILexRefType lrt) { ICmObject first = null; EntryGoDlg dlg = null; string sTitle = string.Empty; try { switch ((LexRefTypeTags.MappingTypes)lrt.MappingType) { case LexRefTypeTags.MappingTypes.kmtEntryOrSensePair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtSenseCollection: case LexRefTypeTags.MappingTypes.kmtSensePair: case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: // Sense pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtSenseSequence: case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryCollection: case LexRefTypeTags.MappingTypes.kmtEntryPair: case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: // Entry pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtEntrySequence: case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseCollection: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseSequence: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; default: Debug.Assert(lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree); return null; } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = sTitle, m_btnText = LexEdStrings.ks_Add }; // Don't display the current entry in the list of matching entries. See LT-2611. ICmObject objEntry = this.Object; while (objEntry.ClassID == LexSenseTags.kClassId) objEntry = objEntry.Owner; Debug.Assert(objEntry.ClassID == LexEntryTags.kClassId); dlg.StartingEntry = objEntry as ILexEntry; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) first = dlg.SelectedObject; return first; } finally { if (dlg != null) dlg.Dispose(); } }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private int GetChildObjectHvo(ILexRefType lrt) { int hvoFirst = 0; BaseEntryGoDlg dlg = null; string sTitle = ""; switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtEntryOrSensePair: case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtSenseCollection: case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: // Sense pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtSenseSequence: case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryCollection: case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: // Entry pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntrySequence: case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefType.MappingTypes.kmtEntryOrSenseCollection: case LexRefType.MappingTypes.kmtEntryOrSenseSequence: case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; default: Debug.Assert(lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseTree); return 0; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); wp.m_title = sTitle; wp.m_label = LexEdStrings.ksFind_; wp.m_btnText = LexEdStrings.ks_Add; // Don't display the current entry in the list of matching entries. See LT-2611. ICmObject objEntry = this.Object; while (objEntry.ClassID == LexSense.kclsidLexSense) objEntry = CmObject.CreateFromDBObject(m_cache, objEntry.OwnerHVO); Debug.Assert(objEntry.ClassID == LexEntry.kclsidLexEntry); dlg.StartingEntry = objEntry as ILexEntry; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) hvoFirst = dlg.SelectedID; dlg.Dispose(); return hvoFirst; }
protected System.Windows.Forms.ContextMenuStrip SetupContextMenuStrip() { System.Windows.Forms.ContextMenuStrip contextMenuStrip = new System.Windows.Forms.ContextMenuStrip(); int[] refTypes = m_cache.LangProject.LexDbOA.ReferencesOA.PossibilitiesOS.HvoArray; m_refTypesAvailable.Clear(); m_rgfReversedRefType.Clear(); string formatName = Mediator.StringTbl.GetString("InsertSymmetricReference", "LexiconTools"); string formatNameWithReverse = Mediator.StringTbl.GetString("InsertAsymmetricReference", "LexiconTools"); for (int i = 0; i < refTypes.Length; i++) { ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, refTypes[i]); if (m_obj is ILexEntry) { switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseCollection: case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseTree: case LexRefType.MappingTypes.kmtSenseSequence: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: continue; default: break; } } else { switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtEntryCollection: case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntryTree: case LexRefType.MappingTypes.kmtEntrySequence: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: continue; default: break; } } string label = ""; string label2 = ""; string reverseName = LexRefType.BestAnalysisOrVernReverseName(lrt.Cache, lrt.Hvo).Text; // replaces lrt.ReverseName.AnalysisDefaultWritingSystem; if (reverseName == null || reverseName == string.Empty) { reverseName = LexEdStrings.ksStars; } string name = lrt.ShortName; if (name == null || name == string.Empty) { name = LexEdStrings.ksStars; } switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseCollection: case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseSequence: case LexRefType.MappingTypes.kmtEntryCollection: case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntrySequence: case LexRefType.MappingTypes.kmtEntryOrSenseCollection: case LexRefType.MappingTypes.kmtEntryOrSensePair: case LexRefType.MappingTypes.kmtEntryOrSenseSequence: label = string.Format(formatName, name); break; case LexRefType.MappingTypes.kmtSenseTree: case LexRefType.MappingTypes.kmtEntryTree: case LexRefType.MappingTypes.kmtEntryOrSenseTree: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: label = string.Format(formatNameWithReverse, name, reverseName); label2 = string.Format(formatNameWithReverse, reverseName, name); break; } int iInsert = contextMenuStrip.Items.Count; //This block of code commented out was set up to sort the items alphabetically. // Find the index to insert the menu items in sorted order. This is a simple // linear search of the existing items in the menu, which could be improved to // a binary search if this is a slowdown. I don't expect that to happen for // expected number of different lexical relation types. //for (int idx = 0; idx < contextMenuStrip.Items.Count; ++idx) //{ // if (String.Compare(label, contextMenuStrip.Items[idx].Text) < 0) // { // iInsert = idx; // break; // } //} // We could use the following method for inputing items if we want to go back to having them sorted. // This would also require making sure MergeIndex has the correct value when referenced in // HandleCreateMenuItem() //contextMenuStrip.Items.Insert(iInsert, new ToolStripMenuItem(label2, null, new EventHandler(this.HandleCreateMenuItem))); contextMenuStrip.Items.Add(new ToolStripMenuItem(label, null, new EventHandler(this.HandleCreateMenuItem))); m_refTypesAvailable.Insert(iInsert, refTypes[i]); m_rgfReversedRefType.Insert(iInsert, false); if (label2.Length > 0) { iInsert = contextMenuStrip.Items.Count; //This block of code commented out was set up to sort the items alphabetically //for (int idx = 0; idx < contextMenuStrip.Items.Count; ++idx) //{ // if (String.Compare(label2, contextMenuStrip.Items[idx].Text) < 0) // { // iInsert = idx; // break; // } //} // We could use the following method for inputing items if we want to go back to having them sorted. // This would also require making sure MergeIndex has the correct value when referenced in // HandleCreateMenuItem() //contextMenuStrip.Items.Insert(iInsert, new ToolStripMenuItem(label2, null, new EventHandler(this.HandleCreateMenuItem))); contextMenuStrip.Items.Add(new ToolStripMenuItem(label2, null, new EventHandler(this.HandleCreateMenuItem))); m_refTypesAvailable.Insert(iInsert, refTypes[i]); m_rgfReversedRefType.Insert(iInsert, true); } } AddFinalContextMenuStripOptions(contextMenuStrip); return(contextMenuStrip); }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private ICmObject GetChildObject(ILexRefType lrt) { ICmObject first = null; EntryGoDlg dlg = null; string sTitle = string.Empty; try { switch ((LexRefTypeTags.MappingTypes)lrt.MappingType) { case LexRefTypeTags.MappingTypes.kmtEntryOrSensePair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtSenseCollection: case LexRefTypeTags.MappingTypes.kmtSensePair: case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtSenseUnidirectional: // Sense pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtSenseSequence: case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryCollection: case LexRefTypeTags.MappingTypes.kmtEntryPair: case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryUnidirectional: // Entry pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtEntrySequence: case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseCollection: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseSequence: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseUnidirectional: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; default: Debug.Assert(lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree); return(null); } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = sTitle, m_btnText = LexEdStrings.ks_Add }; // Don't display the current entry in the list of matching entries. See LT-2611. ICmObject objEntry = this.Object; while (objEntry.ClassID == LexSenseTags.kClassId) { objEntry = objEntry.Owner; } Debug.Assert(objEntry.ClassID == LexEntryTags.kClassId); dlg.StartingEntry = objEntry as ILexEntry; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { first = dlg.SelectedObject; } return(first); } finally { if (dlg != null) { dlg.Dispose(); } } }
public override void FixtureSetup() { base.FixtureSetup(); m_entryFactory = Cache.ServiceLocator.GetInstance <ILexEntryFactory>(); m_senseFactory = Cache.ServiceLocator.GetInstance <ILexSenseFactory>(); m_exampleFactory = Cache.ServiceLocator.GetInstance <ILexExampleSentenceFactory>(); m_lexEntryRefFactory = Cache.ServiceLocator.GetInstance <ILexEntryRefFactory>(); m_lexRefTypeFactory = Cache.ServiceLocator.GetInstance <ILexRefTypeFactory>(); m_lexRefFactory = Cache.ServiceLocator.GetInstance <ILexReferenceFactory>(); m_possListFactory = Cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>(); m_flidReferringSenses = Cache.MetaDataCacheAccessor.GetFieldId2(CmSemanticDomainTags.kClassId, "ReferringSenses", false); UndoableUnitOfWorkHelper.Do("do", "undo", Cache.ActionHandlerAccessor, () => { m_domainBadWords = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>().Create(); m_domainTemperature = Cache.ServiceLocator.GetInstance <ICmSemanticDomainFactory>().Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainBadWords); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainTemperature); m_mainDict = Cache.LangProject.LexDbOA.PublicationTypesOA.PossibilitiesOS[0]; m_blank = MakeEntry("blank", "swear word", true); m_blank.SensesOS[0].SemanticDomainsRC.Add(m_domainBadWords); m_hot = MakeEntry("hot", "high temperature", false); m_hotTemp = m_hot.SensesOS[0]; m_hotTemp.SemanticDomainsRC.Add(m_domainTemperature); m_trouble = MakeSense(m_hot, "trouble"); m_trouble.DoNotPublishInRC.Add(m_mainDict); m_trouble.PicturesOS.Add(Cache.ServiceLocator.GetInstance <ICmPictureFactory>().Create()); m_desirable = MakeSense(m_hot, "desirable"); m_fastCar = MakeSense(m_desirable, "fast (car)"); m_badHot = MakeExample(m_hotTemp, "a hot pile of blank", true); m_goodHot = MakeExample(m_hotTemp, "a hot bath", false); m_water = MakeEntry("water", "H2O", false); m_waterH2O = m_water.SensesOS[0]; m_hotWater = MakeEntry("hot water", "trouble", false); m_hotWaterComponents = MakeEntryRef(m_hotWater, new ICmObject[] { m_trouble, m_waterH2O }, new[] { m_trouble, m_waterH2O }, LexEntryRefTags.krtComplexForm); m_blank2 = MakeEntry("blank", "vacant", false); m_blank3 = MakeEntry("blank", "erase", false); m_water2 = MakeEntry("water", "urinate", true); m_waterPrefix = MakeEntry("water", "aquatic", false); m_waterPrefix.LexemeFormOA.MorphTypeRA = Cache.ServiceLocator.GetInstance <IMoMorphTypeRepository>() .GetObject(MoMorphTypeTags.kguidMorphPrefix); m_synonym = MakeRefType("synonym", null, (int)LexRefTypeTags.MappingTypes.kmtSenseCollection); m_blip = MakeEntry("blip", "rude word", true); m_bother = MakeEntry("bother", "I'm annoyed by that", false); m_ouch = MakeEntry("ouch", "that hurt", false); m_blipOuch = MakeSense(m_blip.SensesOS[0], "rude ouch"); m_blankSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_blank, m_ouch.SensesOS[0], m_blip.SensesOS[0], m_blipOuch, m_bother }); m_problem = MakeEntry("problem", "difficulty", false); m_problemSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_problem, m_trouble }); m_body = MakeEntry("body", "body", true); m_arm = MakeEntry("arm", "arm", false); m_leg = MakeEntry("leg", "leg", false); m_belly = MakeEntry("belly", "belly", true); m_torso = MakeEntry("torso", "torso", false); m_partWhole = MakeRefType("partWhole", null, (int)LexRefTypeTags.MappingTypes.kmtEntryTree); m_bodyParts = MakeLexRef(m_partWhole, new ICmObject[] { m_body, m_arm, m_leg.SensesOS[0], m_torso, m_belly }); m_torsoParts = MakeLexRef(m_partWhole, new ICmObject[] { m_torso, m_arm, m_belly }); m_hotBlank = MakeEntry("hotBlank", "problem rude word", false); MakeEntryRef(m_hotBlank, new ICmObject[] { m_trouble, m_water2 }, new ICmObject[] { m_trouble, m_water2 }, LexEntryRefTags.krtComplexForm); m_blueColor = MakeEntry("blue", "color blue", false); m_blueCold = MakeEntry("blue", "cold", false); m_blueMusic = MakeEntry("blue", "jazzy", false); m_blueSad = MakeEntry("blue", "sad", false); m_blueMusic.HomographNumber = 2; // will duplicate blue cold; pathological, but should not crash. m_blueSad.HomographNumber = 3; // will conflict with renumbered blueMusic m_bluer = m_blueColor.SensesOS[0]; m_sky = MakeEntry("sky", "interface between atmosphere and space", false, true); // true excludes as headword m_skyReal = m_sky.SensesOS[0]; m_blueSky = MakeEntry("blue sky", "clear, huge potential", false, false); m_blueSkyComponents = MakeEntryRef(m_blueSky, new ICmObject[] { m_blueColor, m_skyReal }, new[] { m_bluer, m_skyReal }, LexEntryRefTags.krtComplexForm); m_ringBell = MakeEntry("ring", "bell", false, false); m_ringCircle = MakeEntry("ring", "circle", false, true); m_ringGold = MakeEntry("ring", "gold", false, false); m_blackVerb = MakeEntry("black", "darken", false, true); m_blackColor = MakeEntry("black", "dark", false, false); m_hotArm = MakeEntry("hotarm", "pitcher", false, false); m_hotArmComponents = MakeEntryRef(m_hotArm, new ICmObject[] { m_hot, m_arm }, new[] { m_hot, m_arm }, LexEntryRefTags.krtComplexForm); m_hotArm.DoNotPublishInRC.Add(m_mainDict); m_hotArmComponents.ShowComplexFormsInRS.Add(m_hot); m_nolanryan = MakeEntry("Nolan_Ryan", "pitcher", false, false); m_nolanryanComponents = MakeEntryRef(m_nolanryan, new ICmObject[] { m_hot }, new[] { m_hot }, LexEntryRefTags.krtVariant); m_nolanryanComponents.VariantEntryTypesRS.Add( (ILexEntryType)Cache.LangProject.LexDbOA.VariantEntryTypesOA.PossibilitiesOS[0]); m_nolanryan.DoNotPublishInRC.Add(m_mainDict); m_publisher = new MockPublisher((ISilDataAccessManaged)Cache.DomainDataByFlid, kmainFlid); m_publisher.SetOwningPropValue(Cache.LangProject.LexDbOA.Entries.Select(le => le.Hvo).ToArray()); m_decorator = new DictionaryPublicationDecorator(Cache, m_publisher, ObjectListPublisher.OwningFlid); }); }
private void ExportLexRefTypeFields(TextWriter w, ILexRefType item) { if (item != null) { ExportMultiUnicode(w, item.ReverseName); ExportMultiUnicode(w, item.ReverseAbbreviation); } }
private string GetLexReferenceName(ILexEntry lexEntry, ILexRefType lexRefType) { // The name we want to use for our lex reference is either the name or the reverse name // (depending on the direction of the relationship, if relevant) of the owning lex ref type. ITsString lexReferenceName = lexRefType.Name.BestVernacularAnalysisAlternative; if (lexRefType.MappingType == (int)MappingTypes.kmtEntryAsymmetricPair || lexRefType.MappingType == (int)MappingTypes.kmtEntryOrSenseAsymmetricPair || lexRefType.MappingType == (int)MappingTypes.kmtSenseAsymmetricPair || lexRefType.MappingType == (int)MappingTypes.kmtEntryTree || lexRefType.MappingType == (int)MappingTypes.kmtEntryOrSenseTree || lexRefType.MappingType == (int)MappingTypes.kmtSenseTree) { if (lexEntry.OwnOrd == 0 && lexRefType.Name != null) // the original code had a check for name length as well. lexReferenceName = lexRefType.ReverseName.BestAnalysisAlternative; } return lexReferenceName.Text; }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private int GetRootObjectHvo(ILexRefType lrt) { int hvoFirst = 0; BaseEntryGoDlg dlg = null; switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseAsymmetricPair: case LexRefType.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefType.MappingTypes.kmtEntryAsymmetricPair: case LexRefType.MappingTypes.kmtEntryTree: dlg = new GoDlg(); break; case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: case LexRefType.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; default: Debug.Assert(lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefType.MappingTypes.kmtSenseTree); return 0; } Debug.Assert(dlg != null); WindowParams wp = new WindowParams(); //wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, // lrt.Name.AnalysisDefaultWritingSystem); wp.m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.ReverseName.BestAnalysisAlternative.Text); wp.m_label = LexEdStrings.ksFind_; //wp.m_btnText = LexEdStrings.ks_Link; wp.m_btnText = LexEdStrings.ks_Add; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) hvoFirst = dlg.SelectedID; dlg.Dispose(); return hvoFirst; }
public override void FixtureSetup() { base.FixtureSetup(); m_entryFactory = Cache.ServiceLocator.GetInstance<ILexEntryFactory>(); m_senseFactory = Cache.ServiceLocator.GetInstance<ILexSenseFactory>(); m_exampleFactory = Cache.ServiceLocator.GetInstance<ILexExampleSentenceFactory>(); m_lexEntryRefFactory = Cache.ServiceLocator.GetInstance<ILexEntryRefFactory>(); m_lexRefTypeFactory = Cache.ServiceLocator.GetInstance<ILexRefTypeFactory>(); m_lexRefFactory = Cache.ServiceLocator.GetInstance<ILexReferenceFactory>(); m_possListFactory = Cache.ServiceLocator.GetInstance<ICmPossibilityListFactory>(); m_flidReferringSenses = Cache.MetaDataCacheAccessor.GetFieldId2(CmSemanticDomainTags.kClassId, "ReferringSenses", false); UndoableUnitOfWorkHelper.Do("do", "undo", Cache.ActionHandlerAccessor, () => { m_domainBadWords = Cache.ServiceLocator.GetInstance<ICmSemanticDomainFactory>().Create(); m_domainTemperature = Cache.ServiceLocator.GetInstance<ICmSemanticDomainFactory>().Create(); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainBadWords); Cache.LangProject.SemanticDomainListOA.PossibilitiesOS.Add(m_domainTemperature); m_mainDict = Cache.LangProject.LexDbOA.PublicationTypesOA.PossibilitiesOS[0]; m_blank = MakeEntry("blank", "swear word", true); m_blank.SensesOS[0].SemanticDomainsRC.Add(m_domainBadWords); m_hot = MakeEntry("hot", "high temperature", false); m_hotTemp = m_hot.SensesOS[0]; m_hotTemp.SemanticDomainsRC.Add(m_domainTemperature); m_trouble = MakeSense(m_hot, "trouble"); m_trouble.DoNotPublishInRC.Add(m_mainDict); m_trouble.PicturesOS.Add(Cache.ServiceLocator.GetInstance<ICmPictureFactory>().Create()); m_desirable = MakeSense(m_hot, "desirable"); m_fastCar = MakeSense(m_desirable, "fast (car)"); m_badHot = MakeExample(m_hotTemp, "a hot pile of blank", true); m_goodHot = MakeExample(m_hotTemp, "a hot bath", false); m_water = MakeEntry("water", "H2O", false); m_waterH2O = m_water.SensesOS[0]; m_hotWater = MakeEntry("hot water", "trouble", false); m_hotWaterComponents = MakeEntryRef(m_hotWater, new ICmObject[] { m_trouble, m_waterH2O }, new[] { m_trouble, m_waterH2O }, LexEntryRefTags.krtComplexForm); m_blank2 = MakeEntry("blank", "vacant", false); m_blank3 = MakeEntry("blank", "erase", false); m_water2 = MakeEntry("water", "urinate", true); m_waterPrefix = MakeEntry("water", "aquatic", false); m_waterPrefix.LexemeFormOA.MorphTypeRA = Cache.ServiceLocator.GetInstance<IMoMorphTypeRepository>() .GetObject(MoMorphTypeTags.kguidMorphPrefix); m_synonym = MakeRefType("synonym", null, (int)LexRefTypeTags.MappingTypes.kmtSenseCollection); m_blip = MakeEntry("blip", "rude word", true); m_bother = MakeEntry("bother", "I'm annoyed by that", false); m_ouch = MakeEntry("ouch", "that hurt", false); m_blipOuch = MakeSense(m_blip.SensesOS[0], "rude ouch"); m_blankSynonyms = MakeLexRef(m_synonym, new ICmObject[] {m_blank, m_ouch.SensesOS[0], m_blip.SensesOS[0], m_blipOuch, m_bother}); m_problem = MakeEntry("problem", "difficulty", false); m_problemSynonyms = MakeLexRef(m_synonym, new ICmObject[] { m_problem, m_trouble }); m_body = MakeEntry("body", "body", true); m_arm = MakeEntry("arm", "arm", false); m_leg = MakeEntry("leg", "leg", false); m_belly = MakeEntry("belly", "belly", true); m_torso = MakeEntry("torso", "torso", false); m_partWhole = MakeRefType("partWhole", null, (int)LexRefTypeTags.MappingTypes.kmtEntryTree); m_bodyParts = MakeLexRef(m_partWhole, new ICmObject[] {m_body, m_arm, m_leg.SensesOS[0], m_torso, m_belly}); m_torsoParts = MakeLexRef(m_partWhole, new ICmObject[] {m_torso, m_arm, m_belly}); m_hotBlank = MakeEntry("hotBlank", "problem rude word", false); MakeEntryRef(m_hotBlank, new ICmObject[] { m_trouble, m_water2 }, new ICmObject[] { m_trouble, m_water2 }, LexEntryRefTags.krtComplexForm); m_blueColor = MakeEntry("blue", "color blue", false); m_blueCold = MakeEntry("blue", "cold", false); m_blueMusic = MakeEntry("blue", "jazzy", false); m_blueSad = MakeEntry("blue", "sad", false); m_blueMusic.HomographNumber = 2; // will duplicate blue cold; pathological, but should not crash. m_blueSad.HomographNumber = 3; // will conflict with renumbered blueMusic m_bluer = m_blueColor.SensesOS[0]; m_sky = MakeEntry("sky", "interface between atmosphere and space", false, true); // true excludes as headword m_skyReal = m_sky.SensesOS[0]; m_blueSky = MakeEntry("blue sky", "clear, huge potential", false, false); m_blueSkyComponents = MakeEntryRef(m_blueSky, new ICmObject[] { m_blueColor, m_skyReal }, new[] { m_bluer, m_skyReal }, LexEntryRefTags.krtComplexForm); m_ringBell = MakeEntry("ring", "bell", false, false); m_ringCircle = MakeEntry("ring", "circle", false, true); m_ringGold = MakeEntry("ring", "gold", false, false); m_blackVerb = MakeEntry("black", "darken", false, true); m_blackColor = MakeEntry("black", "dark", false, false); m_hotArm = MakeEntry("hotarm", "pitcher", false, false); m_hotArmComponents = MakeEntryRef(m_hotArm, new ICmObject[] { m_hot, m_arm }, new[] { m_hot, m_arm }, LexEntryRefTags.krtComplexForm); m_hotArm.DoNotPublishInRC.Add(m_mainDict); m_hotArmComponents.ShowComplexFormsInRS.Add(m_hot); m_nolanryan = MakeEntry("Nolan_Ryan", "pitcher", false, false); m_nolanryanComponents = MakeEntryRef(m_nolanryan, new ICmObject[] { m_hot }, new[] { m_hot }, LexEntryRefTags.krtVariant); m_nolanryanComponents.VariantEntryTypesRS.Add( (ILexEntryType)Cache.LangProject.LexDbOA.VariantEntryTypesOA.PossibilitiesOS[0]); m_nolanryan.DoNotPublishInRC.Add(m_mainDict); m_edName = MakeEntry("ed", "someone called ed", false); m_edSuffix = MakeEntry("ed", "past", false, false, true); m_publisher = new MockPublisher((ISilDataAccessManaged)Cache.DomainDataByFlid, kmainFlid); m_publisher.SetOwningPropValue(Cache.LangProject.LexDbOA.Entries.Select(le => le.Hvo).ToArray()); m_decorator = new DictionaryPublicationDecorator(Cache, m_publisher, ObjectListPublisher.OwningFlid); }); }
private void CreateLexReference(ILexRefType lrt, IEnumerable <ICmObject> sensesAndEntries) { CreateLexReference(lrt, sensesAndEntries, Guid.Empty); }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private ICmObject GetRootObject(ILexRefType lrt) { ICmObject first = null; EntryGoDlg dlg = null; try { switch ((LexRefTypeTags.MappingTypes)lrt.MappingType) { case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; break; case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: dlg = new LinkEntryOrSenseDlg(); break; default: Debug.Assert(lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree); return null; } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = String.Format(LexEdStrings.ksIdentifyXEntry, lrt.ReverseName.BestAnalysisAlternative.Text), m_btnText = LexEdStrings.ks_Add }; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) first = dlg.SelectedObject; return first; } finally { if (dlg != null) dlg.Dispose(); } }
private void WriteLexRefType(TextWriter w, ILexRefType refer) { var liftId = refer.Name.BestAnalysisVernacularAlternative.Text; if (refer.Owner is ILexRefType) { var liftIdOwner = ((ILexRefType)refer.Owner).Name.BestAnalysisVernacularAlternative.Text; w.WriteLine("<range-element id=\"{0}\" guid=\"{1}\" parent=\"{2}\">", XmlUtils.MakeSafeXmlAttribute(liftId), refer.Guid, MakeSafeAndNormalizedAttribute(liftIdOwner)); } else { w.WriteLine("<range-element id=\"{0}\" guid=\"{1}\">", XmlUtils.MakeSafeXmlAttribute(liftId), refer.Guid); } WriteAllForms(w, "label", null, "form", refer.Name); WriteAllForms(w, "abbrev", null, "form", refer.Abbreviation); WriteAllForms(w, "description", null, "form", refer.Description); WriteAllForms(w, "field", "type=\"reverse-label\"", "form", refer.ReverseName); WriteAllForms(w, "field", "type=\"reverse-abbrev\"", "form", refer.ReverseAbbreviation); //Write out the MappingType as a 2 digit string without decimal points (currently only 1 digit is needed) WriteTrait(w, "referenceType", refer.MappingType.ToString("##")); w.WriteLine("</range-element>"); }
private ILexReference MakeLexRef(ILexRefType owner, ICmObject[] targets) { var result = m_lexRefFactory.Create(); owner.MembersOC.Add(result); foreach (var obj in targets) result.TargetsRS.Add(obj); return result; }
private ILexReference MakeLexReference(ILexRefType owner, ILexSense firstTarget) { ILexReference result = null; result = Cache.ServiceLocator.GetInstance<ILexReferenceFactory>().Create(); owner.MembersOC.Add(result); result.TargetsRS.Add(firstTarget); return result; }
private void GenerateChildNode(int iChild, XmlNode node, XmlNode caller, int indent, ref int insPos, ArrayList path, ObjSeqHashMap reuseMap) { ILexReference lr = LexReference.CreateFromDBObject(m_cache, (int)m_refs[iChild]); ILexRefType lrt = LexRefType.CreateFromDBObject(m_cache, lr.OwnerHVO); string sLabel = lrt.ShortName; if (sLabel == null || sLabel == string.Empty) { sLabel = lrt.Abbreviation.BestAnalysisAlternative.Text; } bool fTreeRoot = true; ISilDataAccess sda = m_cache.MainCacheAccessor; int chvoTargets = sda.get_VecSize(lr.Hvo, (int)LexReference.LexReferenceTags.kflidTargets); // change the label for a Tree relationship. switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseTree: case LexRefType.MappingTypes.kmtEntryTree: case LexRefType.MappingTypes.kmtEntryOrSenseTree: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: // Sense Pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntryAsymmetricPair: // Entry Pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense Pair with different Forward/Reverse names //int chvo = sda.get_VecSize(lr.Hvo, (int)LexReference.LexReferenceTags.kflidTargets); if (chvoTargets > 0) { int hvoFirst = sda.get_VecItem(lr.Hvo, (int)LexReference.LexReferenceTags.kflidTargets, 0); if (hvoFirst != m_obj.Hvo) { sLabel = lrt.ReverseName.BestAnalysisAlternative.Text; if (sLabel == null || sLabel == string.Empty) { sLabel = lrt.ReverseAbbreviation.BestAnalysisAlternative.Text; } fTreeRoot = false; } } break; } if (sLabel == null || sLabel == string.Empty) { sLabel = LexEdStrings.ksStars; } string sXml = "<slice label=\"" + sLabel + "\" field=\"Targets\"" + " editor=\"Custom\" assemblyPath=\"LexEdDll.dll\""; //string sMenu = "mnuDataTree-DeleteFromLexSenseReference"; we used to have distinct strings in the menu string sMenu = "mnuDataTree-DeleteAddLexReference"; // generate Xml for a specific slice matching this reference switch ((LexRefType.MappingTypes)lrt.MappingType) { case LexRefType.MappingTypes.kmtSenseCollection: sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceCollectionSlice\""; break; case LexRefType.MappingTypes.kmtSensePair: case LexRefType.MappingTypes.kmtSenseAsymmetricPair: // Sense Pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntryPair: case LexRefType.MappingTypes.kmtEntryAsymmetricPair: // Entry Pair with different Forward/Reverse names case LexRefType.MappingTypes.kmtEntryOrSensePair: case LexRefType.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense Pair with different forward/Reverse names sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferencePairSlice\""; sMenu = "mnuDataTree-DeleteReplaceLexReference"; break; case LexRefType.MappingTypes.kmtSenseTree: if (fTreeRoot) { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeBranchesSlice\""; sMenu = "mnuDataTree-DeleteAddLexReference"; } else { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeRootSlice\""; sMenu = "mnuDataTree-DeleteReplaceLexReference"; } break; case LexRefType.MappingTypes.kmtSenseSequence: case LexRefType.MappingTypes.kmtEntrySequence: case LexRefType.MappingTypes.kmtEntryOrSenseSequence: sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceSequenceSlice\""; break; case LexRefType.MappingTypes.kmtEntryCollection: sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceCollectionSlice\""; //sMenu = "mnuDataTree-DeleteFromLexEntryReference"; we used to have distinct strings in the menu sMenu = "mnuDataTree-DeleteAddLexReference"; break; case LexRefType.MappingTypes.kmtEntryTree: //sMenu = "mnuDataTree-DeleteFromLexEntryReference"; we used to have distinct strings in the menu sMenu = "mnuDataTree-DeleteAddLexReference"; if (fTreeRoot) { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeBranchesSlice\""; sMenu = "mnuDataTree-DeleteAddLexReference"; } else { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeRootSlice\""; sMenu = "mnuDataTree-DeleteReplaceLexReference"; } break; case LexRefType.MappingTypes.kmtEntryOrSenseCollection: sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceCollectionSlice\""; if (m_obj is LexEntry) { //sMenu = "mnuDataTree-DeleteFromLexEntryReference"; we used to have distinct strings in the menu sMenu = "mnuDataTree-DeleteAddLexReference"; } break; case LexRefType.MappingTypes.kmtEntryOrSenseTree: if (m_obj is LexEntry) { //sMenu = "mnuDataTree-DeleteFromLexEntryReference"; we used to have distinct strings in the menu sMenu = "mnuDataTree-DeleteAddLexReference"; } if (fTreeRoot) { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeBranchesSlice\""; sMenu = "mnuDataTree-DeleteAddLexReference"; } else { sXml += " class=\"SIL.FieldWorks.XWorks.LexEd.LexReferenceTreeRootSlice\""; } break; } sXml += " mappingType=\"" + lrt.MappingType + "\" hvoDisplayParent=\"" + m_obj.Hvo + "\"" + " menu=\"" + sMenu + "\"><deParams displayProperty=\"HeadWord\"/></slice>"; node.InnerXml = sXml; int firstNewSliceIndex = insPos; CreateIndentedNodes(caller, lr, indent, ref insPos, path, reuseMap, node); for (int islice = firstNewSliceIndex; islice < insPos; islice++) { Slice child = Parent.Controls[islice] as Slice; if (child is ILexReferenceSlice) { (child as ILexReferenceSlice).MasterSlice = this; } } node.InnerXml = ""; }