public bool OnPromoteReversalSubPOS(object cmd)
{
Slice slice = m_dataEntryForm.CurrentSlice;
Debug.Assert(slice != null, "No slice was current");
if (slice != null)
{
FdoCache cache = m_dataEntryForm.Cache;
ICmPossibility sliceObj = slice.Object as ICmPossibility;
int hvoNewOwner = cache.GetOwnerOfObject(sliceObj.OwnerHVO);
switch (cache.GetClassOfObject(hvoNewOwner))
{
default:
throw new ArgumentException("Illegal class.");
case PartOfSpeech.kclsidPartOfSpeech:
{
IPartOfSpeech pos = PartOfSpeech.CreateFromDBObject(cache, hvoNewOwner);
pos.SubPossibilitiesOS.Append(sliceObj);
break;
}
case CmPossibilityList.kclsidCmPossibilityList:
{
ICmPossibilityList posList = CmPossibilityList.CreateFromDBObject(cache, hvoNewOwner);
posList.PossibilitiesOS.Append(sliceObj);
break;
}
}
}
return(true);
}
internal FindPossibilityComboFiller(ICmPossibilityList list)
: base()
{
Debug.Assert(list != null);
m_possibilityList = list;
}
protected override FdoObjectSet <ICmObject> GetObjectSet()
{
ICmPossibilityList list = m_owningObject as ICmPossibilityList;
int[] items = list.PossibilitiesOS.HvoArray;
return(new FdoObjectSet <ICmObject>(m_cache, items, true));
}
/// <summary>
/// Will find a grammatical category (if one exists) with the given (analysis ws) name.
/// If not found, will create a grammatical category either as a possibility of a list,
/// or as a subpossibility of a category.
/// </summary>
/// <param name="catName"></param>
/// <param name="owningList"></param>
/// <param name="owningCategory"></param>
/// <returns></returns>
protected IPartOfSpeech GetGrammaticalCategoryOrCreateOne(string catName, ICmPossibilityList owningList,
IPartOfSpeech owningCategory)
{
Assert.True(m_posFact != null, "Fixture Initialization is not complete.");
Assert.True(m_window != null, "No window.");
var category = m_posRepo.AllInstances().Where(
someposs => someposs.Name.AnalysisDefaultWritingSystem.Text == catName).FirstOrDefault();
if (category != null)
{
return(category);
}
var ws = Cache.DefaultAnalWs;
if (owningList == null)
{
if (owningCategory == null)
{
throw new ArgumentException(
"Grammatical category not found and insufficient information given to create one.");
}
category = m_posFact.Create(new Guid(), owningCategory);
}
else
{
category = m_posFact.Create(new Guid(), owningList);
}
category.Name.set_String(ws, catName);
return(category);
}
private static XmlNode CreateCustomClerkNode(ICmPossibilityList curList)
{
var clerk = GetCustomListClerkName(curList);
var hierarchy = curList.Depth > 1 ? "true" : "false";
var includeAbbr = curList.DisplayOption == (int)PossNameType.kpntName ? false : true;
string ws = curList.GetWsString();
var xmlString =
"<clerk id=\"" + XmlUtils.MakeSafeXmlAttribute(clerk) + "\">"
+ "<recordList owner=\"unowned\" property=\"" + curList.Guid + "\">"
+ "<dynamicloaderinfo assemblyPath=\"xWorks.dll\" class=\"SIL.FieldWorks.XWorks.PossibilityRecordList\"/>"
+ "</recordList>";
xmlString +=
"<treeBarHandler assemblyPath=\"xWorks.dll\" expand=\"false\" hierarchical=\"" + hierarchy
+ "\" includeAbbr=\"" + includeAbbr + "\" ws=\"" + ws + "\" "
+ "class=\"SIL.FieldWorks.XWorks.PossibilityTreeBarHandler\"/>"
+ "<filters/>";
if (curList.IsSorted)
{
xmlString +=
"<sortMethods>"
+ "<sortMethod label=\"Default\" assemblyPath=\"Filters.dll\""
+ " class=\"SIL.FieldWorks.Filters.PropertyRecordSorter\" sortProperty=\"ShortName\"/>"
+ "</sortMethods>";
}
else
{
xmlString += "<sortMethods/>";
}
xmlString += "</clerk>";
var doc = new XmlDocument();
doc.LoadXml(xmlString);
return(doc.DocumentElement);
}
private void Init(LcmCache cache, Mediator mediator, XCore.PropertyTable propertyTable, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_mediator = mediator;
m_propertyTable = propertyTable;
if (parent == null)
{
if (m_propertyTable != null)
{
IApp app = m_propertyTable.GetValue <IApp>("App");
if (app != null)
{
parent = app.ActiveMainWindow;
}
if (parent == null)
{
parent = m_propertyTable.GetValue <Form>("window");
}
}
if (parent == null)
{
parent = Form.ActiveForm; // desperate for something...
}
}
m_cache = cache;
m_useAbbr = useAbbr;
m_parent = parent;
m_list = list;
m_ws = ws;
}
protected override ClassAndPropInfo GetMatchingClass(string className)
{
if (className != "PartOfSpeech")
{
return(null);
}
// A possibility list only allows one type of possibility to be owned in the list.
ICmPossibilityList pssl = (ICmPossibilityList)m_owningObject;
int possClass = pssl.ItemClsid;
string sPossClass = m_cache.DomainDataByFlid.MetaDataCache.GetClassName((int)possClass);
if (sPossClass != className)
{
return(null);
}
foreach (ClassAndPropInfo cpi in m_insertableClasses)
{
if (cpi.signatureClassName == className)
{
return(cpi);
}
}
return(null);
}
public void AtomicOwningPropertyAccessorTest_SetAndChange()
{
// GJM -- 22 June 2010:
// In order to implement FWR-133 Allow Custom Lists, ICmPossibilityListFactory needs
// to be able to create unowned lists. Hence the 2 lines commented out below.
ICmPossibilityListFactory possListFactory = Cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>();
ICmPossibilityList possList1 = possListFactory.Create();
//Assert.AreEqual((int)SpecialHVOValues.kHvoUninitializedObject, possList1.Hvo);
Cache.LanguageProject.LocationsOA = possList1;
Assert.AreEqual(possList1, Cache.LanguageProject.LocationsOA);
Assert.AreNotEqual((int)SpecialHVOValues.kHvoObjectDeleted, possList1.Hvo);
Assert.AreNotEqual((int)SpecialHVOValues.kHvoUninitializedObject, possList1.Hvo);
Assert.AreEqual(Cache.LanguageProject, possList1.Owner);
Assert.AreEqual(LangProjectTags.kflidLocations, possList1.OwningFlid);
ICmPossibilityList possList2 = possListFactory.Create();
//Assert.AreEqual((int)SpecialHVOValues.kHvoUninitializedObject, possList2.Hvo);
Cache.LanguageProject.LocationsOA = possList2;
Assert.AreEqual(possList2, Cache.LanguageProject.LocationsOA);
Assert.AreNotEqual((int)SpecialHVOValues.kHvoObjectDeleted, possList2.Hvo);
Assert.AreNotEqual((int)SpecialHVOValues.kHvoUninitializedObject, possList2.Hvo);
Assert.AreEqual((int)SpecialHVOValues.kHvoObjectDeleted, possList1.Hvo);
Cache.LanguageProject.LocationsOA = null;
Assert.IsNull(Cache.LanguageProject.LocationsOA);
Assert.AreEqual((int)SpecialHVOValues.kHvoObjectDeleted, possList2.Hvo);
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
foreach (TreeNode tn in m_nodes)
{
MasterCategory mc = tn.Tag as MasterCategory;
tn.Tag = null;
mc.Dispose();
}
if (components != null)
{
components.Dispose();
}
if (m_nodes != null)
{
m_nodes.Clear();
}
}
m_posList = null;
m_mediator = null;
m_cache = null;
m_selPOS = null;
m_nodes = null;
base.Dispose(disposing);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shows the Chooser dialog to allow the user to select a single possibility.
/// </summary>
/// <remarks>Used for filtering</remarks>
/// <param name="list">The possibility list used to populate the tree</param>
/// <param name="initialSelected">The possibility to check initially, or null to
/// show with no initial selection</param>
/// <returns>A single chosen CmPossibility, or null if user cancels or chooses
/// nothing.</returns>
/// ------------------------------------------------------------------------------------
public ICmPossibility GetPossibility(ICmPossibilityList list, ICmPossibility initialSelected)
{
//CheckDisposed();
//m_initiallySelectedHvos = new List<int>(1);
//m_initiallySelectedHvos.Add(hvoPoss);
//if (list != (CmPossibilityList)m_list)
//{
// m_list = list;
// SetTitle();
//}
//tvPossibilities.Load(m_list, m_initiallySelectedHvos);
//if (ShowDialog() != DialogResult.OK)
// return 0;
//List<int> newHvos = tvPossibilities.SelectedHvos;
//return (newHvos != null && newHvos.Count > 0 ? newHvos[0] : 0);
// REVIEW: Currently, the chooser tree doesn't allow the user to select
// only one possibility. If this method and single node selection is ever
// necessary, then this method will need to be rewritten.
return(null);
}
private void MakeAnnDefn(ICmPossibilityList defns, string guid)
{
CmAnnotationDefn defn = new CmAnnotationDefn();
defns.PossibilitiesOS.Append(defn);
Cache.VwCacheDaAccessor.CacheGuidProp(defn.Hvo, (int)CmObjectFields.kflidCmObject_Guid,
new Guid(guid));
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
Debug.WriteLineIf(!disposing, "****************** Missing Dispose() call for " + GetType().Name + ". ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
if (disposing)
{
if (components != null)
{
components.Dispose();
}
if (m_nodes != null)
{
m_nodes.Clear();
}
}
m_posList = null;
m_mediator = null;
m_cache = null;
m_selPOS = null;
m_nodes = null;
base.Dispose(disposing);
}
/// <summary>
///
/// </summary>
/// <param name="output"></param>
/// <param name="labelName"></param>
/// <param name="fieldName"></param>
/// <param name="customFieldId"></param>
/// <param name="className"></param>
protected void ReplaceParamsInAttributes(XmlNode output, string labelName, string fieldName, int customFieldId, string className)
{
SetupWsParams(output, customFieldId);
ReplaceSubstringInAttr visitorFn = new ReplaceSubstringInAttr("$fieldName", fieldName);
XmlUtils.VisitAttributes(output, visitorFn);
AppendClassAttribute(output, fieldName, className);
ReplaceSubstringInAttr visitorLab = new ReplaceSubstringInAttr("$label", labelName);
XmlUtils.VisitAttributes(output, visitorLab);
if (customFieldId != 0 && m_mdc is IFwMetaDataCacheManaged)
{
IFwMetaDataCacheManaged mdc = m_mdc as IFwMetaDataCacheManaged;
if (mdc.IsCustom(customFieldId) && mdc.GetDstClsId(customFieldId) != 0)
{
Guid guidList = (m_mdc as IFwMetaDataCacheManaged).GetFieldListRoot(customFieldId);
if (guidList != Guid.Empty)
{
string targetList;
ICmPossibilityList list = m_cache.ServiceLocator.GetInstance <ICmPossibilityListRepository>().GetObject(guidList);
if (list.Owner != null)
{
targetList = String.Format("{0}.{1}", list.Owner.ClassName, mdc.GetFieldName(list.OwningFlid));
}
else
{
targetList = String.Format("unowned.{0}", guidList.ToString());
}
ReplaceSubstringInAttr visitorTarg = new ReplaceSubstringInAttr("$targetList", targetList);
XmlUtils.VisitAttributes(output, visitorTarg);
}
}
}
}
public PossibilityAutoComplete(FdoCache cache, Mediator mediator, ICmPossibilityList list, Control control,
string displayNameProperty, string displayWs)
{
m_cache = cache;
m_mediator = mediator;
m_control = control;
m_displayNameProperty = displayNameProperty;
m_displayWs = displayWs;
m_listBox = new ComboListBox {DropDownStyle = ComboBoxStyle.DropDownList, ActivateOnShow = false};
m_listBox.SelectedIndexChanged += HandleSelectedIndexChanged;
m_listBox.SameItemSelected += HandleSameItemSelected;
m_listBox.StyleSheet = FontHeightAdjuster.StyleSheetFromMediator(mediator);
m_listBox.WritingSystemFactory = cache.WritingSystemFactory;
m_searcher = new StringSearcher<ICmPossibility>(SearchType.Prefix, cache.ServiceLocator.WritingSystemManager);
m_possibilities = new List<ICmPossibility>();
var stack = new Stack<ICmPossibility>(list.PossibilitiesOS);
while (stack.Count > 0)
{
ICmPossibility poss = stack.Pop();
m_possibilities.Add(poss);
foreach (ICmPossibility child in poss.SubPossibilitiesOS)
stack.Push(child);
}
m_control.KeyDown += HandleKeyDown;
m_control.KeyPress += HandleKeyPress;
}
public void AddToDatabase(LcmCache cache, ICmPossibilityList posList, MasterCategory parent, IPartOfSpeech subItemOwner)
{
// It's already in the database, so nothing more can be done.
if (InDatabase)
{
return;
}
UndoableUnitOfWorkHelper.Do(LexTextControls.ksUndoCreateCategory, LexTextControls.ksRedoCreateCategory,
cache.ServiceLocator.GetInstance <IActionHandler>(), () =>
{
DeterminePOSLocationInfo(cache, subItemOwner, parent, posList, out _, out _);
Debug.Assert(POS != null);
if (m_node == null)
{
// should not happen, but just in case... we still get something useful
var wsf = cache.WritingSystemFactory;
var termWs = wsf.GetWsFromStr(m_termWs);
var abbrevWs = wsf.GetWsFromStr(m_abbrevWs);
var defWs = wsf.GetWsFromStr(m_defWs);
POS.Name.set_String(termWs, TsStringUtils.MakeString(m_term, termWs));
POS.Abbreviation.set_String(abbrevWs, TsStringUtils.MakeString(m_abbrev, abbrevWs));
POS.Description.set_String(defWs, TsStringUtils.MakeString(m_def, defWs));
}
else
{
UpdatePOSStrings(cache, m_node, POS);
}
POS.CatalogSourceId = m_id;
});
}
/// ----------------------------------------------------------------------------------------
/// <summary>
/// Main entry point for deleting Custom Lists.
/// Needs to:
/// 1 - Make sure the given list really is a Custom List
/// 2 - Let the user know if any of the possibilities of this list are being referenced.
/// 3 - Delete the list (and its possibilities and subpossibilities) and, consequently,
/// any references to those possibilities.
/// </summary>
/// ----------------------------------------------------------------------------------------
public void Run(ICmPossibilityList curList)
{
m_listToDelete = curList;
// Make sure list is a CUSTOM list!
var owner = m_listToDelete.Owner; // Custom lists are unowned!
if (owner != null)
{
return; // Not a Custom list!
}
// Make sure user knows if any possibilities owned by this list are referenced
// by anything else!
GetCustomFieldsReferencingList(m_listToDelete.Guid);
ICmPossibility poss;
if (HasPossibilityReferences(out poss) > 0)
{
var name = poss.Name.BestAnalysisVernacularAlternative.Text;
// Warn user that possibilities in this list are in use.
if (CheckWithUser(name) != DialogResult.Yes)
{
return;
}
}
DeleteList(m_listToDelete);
}
private void DeleteList(ICmPossibilityList listToDelete)
{
// Delete any custom fields that reference this list
DeleteCustomFieldsReferencingList();
// Delete the Custom list
m_ddbf.DeleteObj(listToDelete.Hvo);
}
private void DeterminePOSLocationInfo(LcmCache cache, IPartOfSpeech subItemOwner,
MasterCategory parent, ICmPossibilityList posList,
out int newOwningFlid, out int insertLocation)
{
// The XML node is from a file shipped with FieldWorks. It is quite likely multiple users
// of a project could independently add the same items, so we create them with fixed guids
// so merge will recognize them as the same objects.
//// LT-14511 However, if the partOfSpeech is being added to a reversal index, a different guid needs to be used
//// than the ones in the file shipped with FieldWorks. In this case if two users add the same POS to the
//// reversal index at the same time and then do a Send/Receive operation, then a merge conflict report
//// will probably be created for this. This scenario is not likely to occur very often at all so having
//// a conflict report created for when this happens is something we can live with.
var guid = posList.Owner is IReversalIndex?Guid.NewGuid() : new Guid(XmlUtils.GetAttributeValue(m_node, "guid"));
var posFactory = cache.ServiceLocator.GetInstance <IPartOfSpeechFactory>();
if (subItemOwner != null)
{
newOwningFlid = CmPossibilityTags.kflidSubPossibilities;
insertLocation = subItemOwner.SubPossibilitiesOS.Count;
POS = posFactory.Create(guid, subItemOwner);
}
else if (parent?.POS != null)
{
newOwningFlid = CmPossibilityTags.kflidSubPossibilities;
insertLocation = parent.POS.SubPossibilitiesOS.Count;
POS = posFactory.Create(guid, parent.POS);
}
else
{
newOwningFlid = CmPossibilityListTags.kflidPossibilities;
insertLocation = posList.PossibilitiesOS.Count;
POS = posFactory.Create(guid, posList); // automatically adds to parent.
}
}
/// <summary>
/// Constructor.
/// </summary>
public MSAPopupTreeManager(PopupTree popupTree, FdoCache cache, ICmPossibilityList list,
int ws, bool useAbbr, Mediator mediator, Form parent)
: base(popupTree, cache, list, ws, useAbbr, parent)
{
m_mediator = mediator;
LoadStrings();
}
/// <summary>
///
/// </summary>
/// <param name="posList"></param>
/// <param name="mediator"></param>
/// <param name="launchedFromInsertMenu"></param>
/// <param name="subItemOwner"></param>
public void SetDlginfo(ICmPossibilityList posList, Mediator mediator, bool launchedFromInsertMenu, IPartOfSpeech subItemOwner)
{
CheckDisposed();
m_subItemOwner = subItemOwner; // May be null, which is fine.
m_posList = posList;
m_launchedFromInsertMenu = launchedFromInsertMenu;
m_mediator = mediator;
if (mediator != null)
{
// Reset window location.
// Get location to the stored values, if any.
object locWnd = m_mediator.PropertyTable.GetValue("masterCatListDlgLocation");
object szWnd = m_mediator.PropertyTable.GetValue("masterCatListDlgSize");
if (locWnd != null && szWnd != null)
{
Rectangle rect = new Rectangle((Point)locWnd, (Size)szWnd);
ScreenUtils.EnsureVisibleRect(ref rect);
DesktopBounds = rect;
StartPosition = FormStartPosition.Manual;
}
}
Debug.Assert(posList != null);
m_cache = posList.Cache;
LoadMasterCategories(posList.ReallyReallyAllPossibilities);
}
public void FindNextMatch_RequireNormalization()
{
IWritingSystem ws;
Cache.ServiceLocator.WritingSystemManager.GetOrSet("grc", out ws);
int wsGreek = ws.Handle;
TreeNode catNode = new TreeNode("Proper Names");
m_treeView.Nodes.Add(catNode);
TreeNode chkTermNode = new TreeNode("Abraham");
ICmPossibilityList list = Cache.ServiceLocator.GetInstance <ICmPossibilityListFactory>().Create();
Cache.LanguageProject.CheckListsOC.Add(list);
IChkTerm term = Cache.ServiceLocator.GetInstance <IChkTermFactory>().Create();
list.PossibilitiesOS.Add(term);
ITsString tssName = Cache.TsStrFactory.MakeString("Abraham".Normalize(NormalizationForm.FormD), Cache.DefaultUserWs);
const string abrahamGrk = "\u1F08\u03B2\u03C1\u03B1\u1F71\u03BC";
ITsString tssDesc = Cache.TsStrFactory.MakeString(abrahamGrk.Normalize(NormalizationForm.FormD), wsGreek);
ITsString tssSeeAlso = Cache.TsStrFactory.MakeString("", Cache.DefaultUserWs);
term.Name.set_String(Cache.DefaultUserWs, tssName);
term.Description.set_String(wsGreek, tssDesc);
term.SeeAlso.set_String(Cache.DefaultUserWs, tssName);
chkTermNode.Tag = term;
catNode.Nodes.Add(chkTermNode);
m_treeView.SelectedNode = catNode;
Assert.AreEqual(KeyTermsTree.FindResult.MatchFound, m_treeView.CallFindNextMatch(abrahamGrk.Normalize(NormalizationForm.FormC)));
Assert.AreEqual("Abraham", m_treeView.SelectedNode.Text);
}
public PossibilityAutoComplete(FdoCache cache, Mediator mediator, ICmPossibilityList list, Control control,
string displayNameProperty, string displayWs)
{
m_cache = cache;
m_mediator = mediator;
m_control = control;
m_displayNameProperty = displayNameProperty;
m_displayWs = displayWs;
m_listBox = new ComboListBox {
DropDownStyle = ComboBoxStyle.DropDownList, ActivateOnShow = false
};
m_listBox.SelectedIndexChanged += HandleSelectedIndexChanged;
m_listBox.SameItemSelected += HandleSameItemSelected;
m_listBox.StyleSheet = FontHeightAdjuster.StyleSheetFromMediator(mediator);
m_listBox.WritingSystemFactory = cache.WritingSystemFactory;
m_searcher = new StringSearcher <ICmPossibility>(SearchType.Prefix, cache.ServiceLocator.WritingSystemManager);
m_possibilities = new List <ICmPossibility>();
var stack = new Stack <ICmPossibility>(list.PossibilitiesOS);
while (stack.Count > 0)
{
ICmPossibility poss = stack.Pop();
m_possibilities.Add(poss);
foreach (ICmPossibility child in poss.SubPossibilitiesOS)
{
stack.Push(child);
}
}
m_control.KeyDown += HandleKeyDown;
m_control.KeyPress += HandleKeyPress;
}
public void ReferencesToDeletedWordformsShouldSwitch()
{
var wf1 = MakeWordform("wordXX");
var wf2 = MakeWordform("wordXX");
var wf3 = MakeWordform("wordXX");
var text = Cache.ServiceLocator.GetInstance <ITextFactory>().Create();
//Cache.LangProject.TextsOC.Add(text);
var stText = Cache.ServiceLocator.GetInstance <IStTextFactory>().Create();
text.ContentsOA = stText;
var para = Cache.ServiceLocator.GetInstance <IStTxtParaFactory>().Create();
stText.ParagraphsOS.Add(para);
var seg = Cache.ServiceLocator.GetInstance <ISegmentFactory>().Create();
para.SegmentsOS.Add(seg);
seg.AnalysesRS.Add(wf1);
seg.AnalysesRS.Add(wf2);
seg.AnalysesRS.Add(wf3);
seg.AnalysesRS.Add(wf2);
seg.AnalysesRS.Add(wf3);
var wordset = Cache.ServiceLocator.GetInstance <IWfiWordSetFactory>().Create();
Cache.LangProject.MorphologicalDataOA.TestSetsOC.Add(wordset);
wordset.CasesRC.Add(wf2);
ICmPossibilityList list = Cache.LangProject.KeyTermsList;
var term = Cache.ServiceLocator.GetInstance <IChkTermFactory>().Create();
list.PossibilitiesOS.Add(term);
var rendering = Cache.ServiceLocator.GetInstance <IChkRenderingFactory>().Create();
term.RenderingsOC.Add(rendering);
rendering.SurfaceFormRA = wf2;
var chkRef = Cache.ServiceLocator.GetInstance <IChkRefFactory>().Create();
term.OccurrencesOS.Add(chkRef);
chkRef.RenderingRA = wf2;
WfiWordformServices.FixDuplicates(Cache, m_progress);
// One but only one should survive.
var wf = Survivor(wf1, wf2, wf3);
Assert.That(seg.AnalysesRS.Count, Is.EqualTo(5));
Assert.That(seg.AnalysesRS[0], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[1], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[2], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[3], Is.EqualTo(wf));
Assert.That(seg.AnalysesRS[4], Is.EqualTo(wf));
// for several tests to prove anything, the wordform that survives must NOT be the
// one that was there already.
Assert.That(wf, Is.Not.EqualTo(wf2));
Assert.That(wordset.CasesRC, Has.Member(wf));
Assert.That(rendering.SurfaceFormRA, Is.EqualTo(wf));
Assert.That(chkRef.RenderingRA, Is.EqualTo(wf));
}
private ICmCustomItem CreateCustomItemAddToList(ICmPossibilityList owningList, string itemName)
{
var item = Cache.ServiceLocator.GetInstance <ICmCustomItemFactory>().Create();
owningList.PossibilitiesOS.Add(item);
item.Name.set_String(m_userWs, m_tsFact.MakeString(itemName, m_userWs));
return(item);
}
/// <summary>
/// Add a CmPossibilityList to the collection.
/// </summary>
/// <param name="pl">The CmPossibilityList to add.</param>
public ICmPossibilityList Add(ICmPossibilityList pl)
{
Debug.Assert(pl != null);
ICmPossibilityList plAdd = (ICmPossibilityList)ValidateObject(pl);
List.Add(plAdd);
return(plAdd);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:ConfigureListDlg"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public ConfigureListDlg(Mediator mediator, ICmPossibilityList possList) :
base(mediator)
{
m_curList = possList;
m_fchangesMade = false;
Text = xWorksStrings.ksConfigureList;
s_helpTopic = "khtpConfigureList";
}
public override void TestSetup()
{
base.TestSetup();
ICmPossibilityList dummyList = MockRepository.GenerateMock <ICmPossibilityList>();
dummyList.Stub(l => l.Cache).Return(Cache);
m_treeView = new DummyKeyTermsTree(dummyList);
}
/// <summary>
/// Constructor.
/// </summary>
public PopupTreeManager(PopupTree popupTree, FdoCache cache, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_popupTree = popupTree;
Init(cache, list, ws, useAbbr, parent);
popupTree.BeforeSelect += new TreeViewCancelEventHandler(m_treeCombo_BeforeSelect);
popupTree.AfterSelect += new TreeViewEventHandler(m_treeCombo_AfterSelect);
popupTree.PopupTreeClosed += new TreeViewEventHandler(popupTree_PopupTreeClosed);
}
/// <summary>
/// Constructor.
/// </summary>
public PopupTreeManager(PopupTree popupTree, FdoCache cache, Mediator mediator, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_popupTree = popupTree;
Init(cache, mediator, list, ws, useAbbr, parent);
popupTree.BeforeSelect += m_treeCombo_BeforeSelect;
popupTree.AfterSelect += m_treeCombo_AfterSelect;
popupTree.PopupTreeClosed += popupTree_PopupTreeClosed;
}
/// <summary>
/// Constructor.
/// </summary>
public PopupTreeManager(PopupTree popupTree, FdoCache cache, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_popupTree = popupTree;
Init(cache, list, ws, useAbbr, parent);
popupTree.BeforeSelect += new TreeViewCancelEventHandler(m_treeCombo_BeforeSelect);
popupTree.AfterSelect += new TreeViewEventHandler(m_treeCombo_AfterSelect);
popupTree.PopupTreeClosed += new TreeViewEventHandler(popupTree_PopupTreeClosed);
}
private void MakeListXml(ICmPossibilityList list, XmlElement root)
{
foreach (XmlNode item in root)
{
ICmPossibility poss = list.PossibilitiesOS.Append(new CmPossibility());
InitItem(item, poss);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Call the base class method
/// </summary>
/// ------------------------------------------------------------------------------------
public static void CallLoadKeyTerms(ICmPossibilityList oldKeyTermsList,
ICmPossibilityList newKeyTermsList, BiblicalTermsList terms,
List<BiblicalTermsLocalization> localizations)
{
IScripture scr = newKeyTermsList.Cache.LangProject.TranslatedScriptureOA;
new DummyTeKeyTermsInit(scr).LoadKeyTerms(null, oldKeyTermsList, newKeyTermsList,
terms, localizations);
}
private void MakeAnnDefn(ICmPossibilityList defns, string guid)
{
CmAnnotationDefn defn = new CmAnnotationDefn();
defns.PossibilitiesOS.Append(defn);
Cache.VwCacheDaAccessor.CacheGuidProp(defn.Hvo, (int)CmObjectFields.kflidCmObject_Guid,
new Guid(guid));
}
private ICmPossibility MakePossibility(ICmPossibilityList list, string name)
{
var result = Cache.ServiceLocator.GetInstance <ICmPossibilityFactory>().Create();
list.PossibilitiesOS.Add(result);
result.Name.AnalysisDefaultWritingSystem = AnalysisTss(name);
return(result);
}
public ConvertFdoToMongoOptionList ConvertOptionListFromFdo(ILfProject project, string listCode, ICmPossibilityList fdoOptionList, bool updateMongoList = true)
{
LfOptionList lfExistingOptionList = _conn.GetLfOptionListByCode(project, listCode);
var converter = new ConvertFdoToMongoOptionList(lfExistingOptionList, _wsEn, listCode, _env.Logger, _cache.WritingSystemFactory);
LfOptionList lfChangedOptionList = converter.PrepareOptionListUpdate(fdoOptionList);
if (updateMongoList)
_conn.UpdateRecord(project, lfChangedOptionList, listCode);
return new ConvertFdoToMongoOptionList(lfChangedOptionList, _wsEn, listCode, _env.Logger, _cache.WritingSystemFactory);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// create test data
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void CreateTestData()
{
base.CreateTestData();
m_xmlNote = new XmlNoteCategory();
// Initialize the annotation category possibility list.
m_possList = CreateCategories(Cache, m_wsSpanish);
}
private void CreateKnownPossibilityList()
{
// this list exists empty in the FdoTestBase.
m_testList = Cache.LangProject.ConfidenceLevelsOA;
Assert.AreEqual(0, m_testList.PossibilitiesOS.Count);
Assert.AreEqual("Possibilities", Cache.MetaDataCache.GetFieldName(possibilitiesFlid));
AppendTestItemToList("First"); // So tests automatically have one item.
}
private void Import(XmlReader xrdr)
{
xrdr.MoveToContent();
if (xrdr.Name != "Lists")
{
throw new Exception(String.Format("Unexpected outer element (expected <Lists>): {0}", xrdr.Name));
}
DateTime dateOfTranslation = ReadDateAttribute(xrdr);
if (!xrdr.ReadToDescendant("List"))
{
throw new Exception(String.Format("Unexpected second element (expected <List>): {0}", xrdr.Name));
}
while (xrdr.Name == "List")
{
ICmPossibilityList list = GetListFromAttributes(xrdr);
xrdr.MoveToElement();
string sItemClass;
int clid;
GetItemClassFromAttributes(xrdr, out sItemClass, out clid);
xrdr.MoveToElement();
xrdr.Read();
while (xrdr.Depth == 2)
{
xrdr.MoveToContent();
if (xrdr.Depth < 2)
{
break;
}
switch (xrdr.Name)
{
case "Description":
SetMultiStringFromXml(xrdr, list.Description);
break;
case "Name":
SetMultiUnicodeFromXml(xrdr, list.Name);
break;
case "Abbreviation":
SetMultiUnicodeFromXml(xrdr, list.Abbreviation);
break;
case "Possibilities":
// we know the list, but we don't have the map yet at this level.
ReadPossibilitiesFromXml(xrdr, list, sItemClass, "");
break;
default:
throw new Exception(String.Format("Unknown field element in <List>: {0}", xrdr.Name));
}
}
xrdr.ReadEndElement();
xrdr.MoveToContent(); // skip any trailing whitespace
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="KeyTermsTree"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public KeyTermsTree(ICmPossibilityList keyTermsList)
{
BorderStyle = BorderStyle.None;
HideSelection = false;
m_keyTermsList = keyTermsList;
m_cache = m_keyTermsList.Cache;
m_wsDefault = m_cache.DefaultUserWs;
GetFontForWs = (ws => Font); // By default, just use the control's font (from Designer)
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Loads the tree with the specified list of possibilities.
/// </summary>
/// ------------------------------------------------------------------------------------
public virtual void Load(ICmPossibilityList list, List<int> initiallySelectedHvos,
Label lblSelectedCategories)
{
m_lblSelectedCategories = lblSelectedCategories;
Nodes.Clear();
m_initiallySelectedHvos = (initiallySelectedHvos ?? new List<int>());
if (list != null)
{
foreach (ICmPossibility possibility in list.PossibilitiesOS)
Nodes.Add(CreateNode(possibility));
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Loads the tree with the specified list of possibilities.
/// </summary>
/// ------------------------------------------------------------------------------------
public virtual void Load(ICmPossibilityList list, List<int> initiallySelectedHvos,
Label lblSelectedCategories)
{
m_lblSelectedCategories = lblSelectedCategories;
Nodes.Clear();
StringUtils.InitIcuDataDir(); // used for normalizing strings to NFC
m_initiallySelectedHvos = (initiallySelectedHvos ?? new List<int>());
if (list != null)
{
foreach (ICmPossibility possibility in list.PossibilitiesOS)
Nodes.Add(CreateNode(possibility));
}
}
public override void Initialize()
{
CheckDisposed();
base.Initialize();
m_xmlNote = new XmlNoteCategory();
m_scrInMemoryCache.InitializeWritingSystemEncodings();
m_scrInMemoryCache.InitializeScripture();
m_scrInMemoryCache.SetupScriptureAnnotationCategories();
// Initialize the annotation category possibility list.
m_wsSpanish = InMemoryFdoCache.s_wsHvos.Es;
m_possList = CreateCategories(m_scrInMemoryCache.Cache, m_possList, m_wsSpanish);
}
private void Init(FdoCache cache, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
if (m_parent == null)
{
if (SIL.FieldWorks.Common.Framework.FwApp.App != null)
m_parent = SIL.FieldWorks.Common.Framework.FwApp.App.ActiveMainWindow;
if (m_parent == null)
m_parent = Form.ActiveForm; // desperate for something...
}
m_cache = cache;
m_useAbbr = useAbbr;
m_parent = parent;
m_list = list;
m_ws = ws;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates a text for testing.
/// </summary>
/// ------------------------------------------------------------------------------------
private void CreateTestText()
{
m_txt = m_servLoc.GetInstance<ITextFactory>().Create();
//Cache.LangProject.TextsOC.Add(m_txt);
m_possTagList = Cache.LangProject.GetDefaultTextTagList();
m_stTxt = m_servLoc.GetInstance<IStTextFactory>().Create();
m_txt.ContentsOA = m_stTxt;
m_txtPara = m_txt.ContentsOA.AddNewTextPara(null);
// 0 1 2 3 4 5 6 7 8
// This is a test string for ReferenceAdjusterService tests.
var hvoVernWs = Cache.DefaultVernWs;
m_txtPara.Contents = TsStringUtils.MakeTss("This is a test string for ReferenceAdjusterService tests.", hvoVernWs);
ParseText();
}
public override void Initialize()
{
CheckDisposed();
base.Initialize();
InstallVirtuals(@"Language Explorer\Configuration\Words\AreaConfiguration.xml",
new string[] { "SIL.FieldWorks.IText.ParagraphSegmentsVirtualHandler", "SIL.FieldWorks.IText.OccurrencesInTextsVirtualHandler" });
// Try moving this up to Fixture Setup, since we don't plan on changing the text here.
m_text1 = LoadTestText(@"LexText\Interlinear\ITextDllTests\ParagraphParserTestTexts.xml", 1, m_textsDefn);
m_hvoPara = m_text1.ContentsOA.ParagraphsOS[1].Hvo; // First paragraph contains no text!
ParseTestText();
m_tagChild = new TestTaggingChild(Cache);
// This could change, but at least it gives a reasonably stable list to test from.
m_textMarkupTags = m_tagChild.CreateDefaultListFromXML();
LoadTagListHvos();
}
public void Setup()
{
CheckDisposed();
base.Initialize();
m_scrInMemoryCache.InitializeWritingSystemEncodings();
m_scrInMemoryCache.InitializeAnnotationCategories();
m_scrInMemoryCache.InitializeAnnotationDefs();
m_scrInMemoryCache.SetupScriptureAnnotationCategories();
m_wsSpanish = InMemoryFdoCache.s_wsHvos.Es;
// Initialize the annotation category possibility list.
m_possList = XmlNoteCategoryTests.CreateCategories(m_scrInMemoryCache.Cache,
m_possList, m_wsSpanish);
ScrNoteImportManager.Initialize(m_scr, 1);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the categories.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="list">The possibility (category) list.</param>
/// <param name="ws">The writing system for setting the category names.</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
internal static ICmPossibilityList CreateCategories(FdoCache cache,
ICmPossibilityList list, int ws)
{
list = cache.LangProject.TranslatedScriptureOA.NoteCategoriesOA;
// Initialize text.
ITsPropsBldr ttpBldr = TsPropsBldrClass.Create();
ttpBldr.SetIntPropValues((int)FwTextPropType.ktptWs,
(int)FwTextPropVar.ktpvDefault, ws);
ITsStrBldr tsStrBldr = TsStrBldrClass.Create();
// Set possibilities on top level--"Level 1a"
CmPossibility possibility1a = new CmPossibility();
list.PossibilitiesOS.Append(possibility1a);
tsStrBldr.ReplaceRgch(0, 0, "Level 1a", 8, ttpBldr.GetTextProps());
possibility1a.Name.SetAlternative(tsStrBldr.GetString(), ws);
// Add another on top level--"Level 1b"
CmPossibility possibility1b = new CmPossibility();
list.PossibilitiesOS.Append(possibility1b);
tsStrBldr.ReplaceRgch(0, tsStrBldr.Length, "Level 1b", 8, ttpBldr.GetTextProps());
possibility1b.Name.SetAlternative(tsStrBldr.GetString(), ws);
// Add possibilities on second level under "Level 1b"--"Level 2a"
CmPossibility subPossibility2a = new CmPossibility();
possibility1b.SubPossibilitiesOS.Append(subPossibility2a);
tsStrBldr.ReplaceRgch(0, tsStrBldr.Length, "Level 2a, parent is 1b", 22, ttpBldr.GetTextProps());
subPossibility2a.Name.SetAlternative(tsStrBldr.GetString(), ws);
// Add "Level 2b" under "Level 1b"
CmPossibility subPossibility2b = new CmPossibility();
possibility1b.SubPossibilitiesOS.Append(subPossibility2b);
tsStrBldr.ReplaceRgch(0, tsStrBldr.Length, "Level 2b, parent is 1b", 22, ttpBldr.GetTextProps());
subPossibility2b.Name.SetAlternative(tsStrBldr.GetString(), ws);
// Add "Level 3" under "Level 2b"
CmPossibility subSubPossibility3 = new CmPossibility();
subPossibility2b.SubPossibilitiesOS.Append(subSubPossibility3);
tsStrBldr.ReplaceRgch(0, tsStrBldr.Length, "Level 3, parent is 2b", 21, ttpBldr.GetTextProps());
subSubPossibility3.Name.SetAlternative(tsStrBldr.GetString(), ws);
return list;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initialize this test fixture.
/// </summary>
/// ------------------------------------------------------------------------------------
public override void FixtureSetup()
{
base.FixtureSetup();
IWritingSystem wsEs;
Cache.ServiceLocator.WritingSystemManager.GetOrSet("es", out wsEs);
m_wsSpanish = wsEs.Handle;
NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () =>
{
Cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Add(wsEs);
// Initialize the annotation category possibility list.
m_possList = XmlNoteCategoryTests.CreateCategories(Cache, m_wsSpanish);
ScrNoteImportManager.Initialize(m_scr, 1);
});
}
private void Init(FdoCache cache, Mediator mediator, ICmPossibilityList list, int ws, bool useAbbr, Form parent)
{
m_mediator = mediator;
if (parent == null)
{
if (mediator != null)
{
IApp app = (IApp)mediator.PropertyTable.GetValue("App");
if (app != null)
parent = app.ActiveMainWindow;
}
if (parent == null)
parent = Form.ActiveForm; // desperate for something...
}
m_cache = cache;
m_useAbbr = useAbbr;
m_parent = parent;
m_list = list;
m_ws = ws;
}
/// ----------------------------------------------------------------------------------------
/// <summary>
/// Main entry point for deleting Custom Lists.
/// Needs to:
/// 1 - Make sure the given list really is a Custom List
/// 2 - Let the user know if any of the possibilities of this list are being referenced.
/// 3 - Delete the list (and its possibilities and subpossibilities) and, consequently,
/// any references to those possibilities.
/// </summary>
/// ----------------------------------------------------------------------------------------
public void Run(ICmPossibilityList curList)
{
m_listToDelete = curList;
// Make sure list is a CUSTOM list!
var owner = m_listToDelete.Owner; // Custom lists are unowned!
if (owner != null)
return; // Not a Custom list!
// Make sure user knows if any possibilities owned by this list are referenced
// by anything else!
GetCustomFieldsReferencingList(m_listToDelete.Guid);
ICmPossibility poss;
if (HasPossibilityReferences(out poss) > 0)
{
var name = poss.Name.BestAnalysisVernacularAlternative.Text;
// Warn user that possibilities in this list are in use.
if (CheckWithUser(name) != DialogResult.Yes)
return;
}
DeleteList(m_listToDelete);
}
public MasterCategoryListChooserLauncher(Form popupMgrParent, Mediator mediator,
ICmPossibilityList possibilityList, string fieldName, ILexSense sense)
{
m_parentOfPopupMgr = popupMgrParent;
m_mediator = mediator;
CategoryList = possibilityList;
m_sense = sense;
FieldName = fieldName;
Cache = m_sense.Cache;
Application.Idle += new EventHandler(LaunchChooseFromMasterCategoryListOnIdle);
}
/// <summary>
/// Constructor.
/// </summary>
public MSAPopupTreeManager(TreeCombo treeCombo, FdoCache cache, ICmPossibilityList list,
int ws, bool useAbbr, Mediator mediator, Form parent)
: base(treeCombo, cache, mediator, list, ws, useAbbr, parent)
{
LoadStrings();
}
/// <summary>
/// Return true if the specified list requires us to use a chooser dialog rather than putting a simple combo box
/// in the bulk edit bar. Currently we do this if the list is (actually, not just potentially) hierarchical,
/// or if it has more than 25 items.
/// Note that at least one unit test will break if this method causes the default Locations list to be treated
/// as hierarchical.
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
private bool RequiresDialogChooser(ICmPossibilityList list)
{
if (list.PossibilitiesOS.Count > 25)
return true;
foreach (var item in list.PossibilitiesOS)
{
if (item.SubPossibilitiesOS.Count > 0)
return true;
}
return false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
/// ------------------------------------------------------------------------------------
protected override void Dispose(bool disposing)
{
// Must not be run more than once.
if (IsDisposed)
return;
if (disposing)
{
// Dispose managed resources here.
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_textsDefn = null;
m_text1 = null;
m_textMarkupTags = null;
m_tagChild = null;
m_possTagHvos = null;
m_hvoWfics = null;
base.Dispose(disposing);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Shows the Chooser dialog to allow the user to select a single possibility.
/// </summary>
/// <remarks>Used for filtering</remarks>
/// <param name="list">The possibility list used to populate the tree</param>
/// <param name="initialSelected">The possibility to check initially, or null to
/// show with no initial selection</param>
/// <returns>A single chosen CmPossibility, or null if user cancels or chooses
/// nothing.</returns>
/// ------------------------------------------------------------------------------------
public ICmPossibility GetPossibility(ICmPossibilityList list, ICmPossibility initialSelected)
{
//CheckDisposed();
//m_initiallySelectedHvos = new List<int>(1);
//m_initiallySelectedHvos.Add(hvoPoss);
//if (list != (CmPossibilityList)m_list)
//{
// m_list = list;
// SetTitle();
//}
//tvPossibilities.Load(m_list, m_initiallySelectedHvos);
//if (ShowDialog() != DialogResult.OK)
// return 0;
//List<int> newHvos = tvPossibilities.SelectedHvos;
//return (newHvos != null && newHvos.Count > 0 ? newHvos[0] : 0);
// REVIEW: Currently, the chooser tree doesn't allow the user to select
// only one possibility. If this method and single node selection is ever
// necessary, then this method will need to be rewritten.
return null;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="FwChooserDlg"/> class.
/// </summary>
/// <param name="list">The possibility list used to populate the tree</param>
/// <param name="initiallySelectedHvos">The sequence of HVOs of initially selected
/// possibilities</param>
/// <param name="helptopicProvider">object that knows how to serve up help topics</param>
/// <param name="sHelpTopicKey">Topic to display if user clicks Help button (can be
/// specific to the possibility list being displayed)</param>
/// <param name="projSettingsKey">The project settings key.</param>
/// ------------------------------------------------------------------------------------
public FwChooserDlg(ICmPossibilityList list, int[] initiallySelectedHvos,
IHelpTopicProvider helptopicProvider, string sHelpTopicKey,
IProjectSpecificSettingsKeyProvider projSettingsKey) : this()
{
if (initiallySelectedHvos == null)
throw new ArgumentNullException("initiallySelectedHvos");
if (list == null)
throw new ArgumentNullException("list");
m_list = list;
m_cache = m_list.Cache;
m_initiallySelectedHvos = new List<int>(initiallySelectedHvos);
m_helptopicProvider = helptopicProvider;
m_helpTopicKey = sHelpTopicKey;
m_projSettingsKey = projSettingsKey;
SetTitle();
tvPossibilities.Load(m_list, m_initiallySelectedHvos, SelectedPossibilitiesLabel);
}
private void LoadPossibilitiesFromXml(XmlReader xrdr, ICmPossibilityList owner, string sItemClassName)
{
if (xrdr.ReadToDescendant(sItemClassName))
{
EnsureFactoryForClass(sItemClassName);
do
{
string sGuid = xrdr.GetAttribute("guid");
xrdr.MoveToElement();
Guid guid = Guid.Empty;
if (!String.IsNullOrEmpty(sGuid))
guid = new Guid(sGuid);
ICmPossibility poss = null;
switch (sItemClassName)
{
case "CmPossibility":
poss = m_factPoss.Create(EnsureGuid(guid), owner);
break;
case "CmAnthroItem":
poss = m_factAnthro.Create(EnsureGuid(guid), owner) as ICmPossibility;
break;
case "CmSemanticDomain":
poss = m_factSemDom.Create(EnsureGuid(guid), owner) as ICmPossibility;
break;
case "PartOfSpeech":
Debug.Assert(guid != Guid.Empty);
poss = m_factPOS.Create(guid, owner);
break;
default:
// TODO: implement other subclasses of CmPossibility?
break;
}
Debug.Assert(poss != null);
ReadPossItem(xrdr.ReadSubtree(), poss, sItemClassName);
} while (xrdr.ReadToNextSibling(sItemClassName));
}
xrdr.Read(); // reads end element.
}
protected void MakeContextMenu_AvailableTags(ContextMenuStrip menu, ICmPossibilityList list)
{
foreach (ICmPossibility tagList in list.PossibilitiesOS)
{
if (tagList.SubPossibilitiesOS.Count > 0)
AddListToMenu(menu, tagList);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Loads the tree with the specified list of possibilities.
/// </summary>
/// ------------------------------------------------------------------------------------
public virtual void Load(ICmPossibilityList list, List<int> initiallySelectedHvos)
{
Load(list, initiallySelectedHvos, null);
}