public void TryItOut() { var filter = new WordsUsedOnlyElsewhereFilter(); filter.Init(Cache, null); var sda = new FakeDecorator((ISilDataAccessManaged)Cache.DomainDataByFlid); filter.DataAccess = sda; UndoableUnitOfWorkHelper.Do("undo", "redo", m_actionHandler, () => { var wfTry = MakeWordform("try"); ISegment seg1; var text1 = MakeText("try it out", out seg1); seg1.AnalysesRS.Add(wfTry); Assert.That(wfTry.FullConcordanceCount, Is.EqualTo(1)); ManyOnePathSortItem itemTry = new ManyOnePathSortItem(wfTry); // Here the global count is non-zero but the corpus count is zero. Assert.That(filter.Accept(itemTry), Is.False, "should not accept an item which occurs elsewhere but not in corpus"); sda.HvoToOccurrenceCount[wfTry.Hvo] = 1; Assert.That(filter.Accept(itemTry), Is.True, "should accept an item in an included text"); sda.HvoToOccurrenceCount[wfTry.Hvo] = 5; Assert.That(filter.Accept(itemTry), Is.True, "should accept an item in an included text, even if there are other occurrences"); var wfNowhere = MakeWordform("nowhere"); ManyOnePathSortItem itemNowhere = new ManyOnePathSortItem(wfNowhere); Assert.That(filter.Accept(itemNowhere), Is.True,"should accept an item that occurs nowhere at all."); }); }
///// <summary> ///// Initialize the filter ///// </summary> ///// <param name="cache"></param> ///// <param name="configuration"></param> // public override void Init(FdoCache cache,XmlNode filterNode) // { //// m_cache = cache; //// int hvo = m_cache.LangProject.MorphologicalDataOA.TestSetsOC.HvoArray[0]; //// m_wordSet= WfiWordSet.CreateFromDBObject(m_cache, hvo); // } /// ------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------ public override bool Accept(ManyOnePathSortItem item) { int hvo = item.KeyObject; for (int i = m_hvos.Length - 1; i >= 0; i--) { if (m_hvos[i] == hvo) { return(true); } } return(false); }
public override void TestSetup() { base.TestSetup(); IManyOnePathSortItem mopsi = new ManyOnePathSortItem(Cache.LangProject); m_list = new ArrayList(); m_list.Add(mopsi); var leFactory = Cache.ServiceLocator.GetInstance <ILexEntryFactory>(); UndoableUnitOfWorkHelper.Do("undoit", "redoit", Cache.ActionHandlerAccessor, () => { m_le1 = leFactory.Create(); m_le2 = leFactory.Create(); }); mopsi = new ManyOnePathSortItem(Cache.LangProject.LexDbOA.Hvo, new int[] { m_le1.Hvo, m_le2.Hvo }, new int[] { 2, 3 }); m_list.Add(mopsi); }
public void PersistMopsiList() { var mopsi = (IManyOnePathSortItem)m_list[m_list.Count - 1]; using (var stream = new MemoryStream()) { var objRepo = Cache.ServiceLocator.ObjectRepository; var originalPersistData = mopsi.PersistData(objRepo); using (var writer = new StreamWriter(stream)) { ManyOnePathSortItem.WriteItems(m_list, writer, objRepo, null); stream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(stream)) { string versionStamp; var items = ManyOnePathSortItem.ReadItems(reader, objRepo, out versionStamp); Assert.That(items.Count, Is.EqualTo(m_list.Count)); Assert.That(versionStamp, Is.Null); mopsi = (IManyOnePathSortItem)items[0]; Assert.That(mopsi.KeyObject, Is.EqualTo(Cache.LangProject.Hvo)); Assert.That(mopsi.PathLength, Is.EqualTo(0)); // Root object is key object, if no path. Assert.That(mopsi.RootObjectHvo, Is.EqualTo(Cache.LangProject.Hvo)); Assert.That(mopsi.RootObjectUsing(Cache), Is.EqualTo(Cache.LangProject)); // PathObject(0) is also the key, if no path. Assert.That(mopsi.PathObject(0), Is.EqualTo(Cache.LangProject.Hvo)); mopsi = (IManyOnePathSortItem)items[1]; Assert.That(mopsi.KeyObject, Is.EqualTo(Cache.LangProject.LexDbOA.Hvo)); Assert.That(mopsi.PathLength, Is.EqualTo(2)); Assert.That(mopsi.PathFlid(0), Is.EqualTo(2)); Assert.That(mopsi.PathFlid(1), Is.EqualTo(3)); Assert.That(mopsi.PathObject(0), Is.EqualTo(m_le1.Hvo)); Assert.That(mopsi.PathObject(1), Is.EqualTo(m_le2.Hvo)); Assert.That(mopsi.PathObject(2), Is.EqualTo(Cache.LangProject.LexDbOA.Hvo), "Index one too large yields key object."); Assert.That(mopsi.RootObjectHvo, Is.EqualTo(m_le1.Hvo)); Assert.That(mopsi.RootObjectUsing(Cache), Is.EqualTo(m_le1)); Assert.That(mopsi.KeyObjectUsing(Cache), Is.EqualTo(Cache.LangProject.LexDbOA)); Assert.That(mopsi.PersistData(objRepo), Is.EqualTo(originalPersistData)); } } } }
public void PersistMopsiList_BadGUID() { // Now make one containing a bad GUID. using (var stream = new MemoryStream()) { var objRepo = Cache.ServiceLocator.ObjectRepository; using (var writer = new StreamWriter(stream)) { ManyOnePathSortItem.WriteItems(m_list, writer, objRepo); writer.WriteLine(Convert.ToBase64String(Guid.NewGuid().ToByteArray())); // fake item, bad guid writer.Flush(); stream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(stream)) { var items = ManyOnePathSortItem.ReadItems(reader, objRepo); Assert.That(items, Is.Null); } } } }
/// <summary> /// Gets the sort key by traversing the part tree, calling the sort method at the leaves. /// </summary> /// <param name="layout">The layout.</param> /// <param name="cmo">The object.</param> /// <param name="item">The item.</param> /// <param name="pathIndex">Index of the path.</param> /// <param name="sortedFromEnd">if set to <c>true</c> [sorted from end].</param> /// <returns></returns> private string GetKey(XmlNode layout, ICmObject cmo, ManyOnePathSortItem item, int pathIndex, bool sortedFromEnd) { if (layout == null) return null; switch (layout.Name) { case "obj": { int flid = GetFlid(layout, cmo.Hvo); if (pathIndex != -1 && (pathIndex == item.PathLength || flid != item.PathFlid(pathIndex))) // we are now off of the path pathIndex = -1; int objHvo = m_cache.GetObjProperty(cmo.Hvo, flid); if (objHvo != 0) { if (pathIndex != -1 && (pathIndex < item.PathLength - 1 && objHvo == item.PathObject(pathIndex + 1)) || (pathIndex == item.PathLength - 1 && objHvo == item.KeyObject)) { return GetChildObjKey(layout, objHvo, item, pathIndex + 1, sortedFromEnd); } // we are off of the path return GetChildObjKey(layout, objHvo, item, -1, sortedFromEnd); } } break; case "seq": { int flid = GetFlid(layout, cmo.Hvo); if (pathIndex != -1 && (pathIndex == item.PathLength || flid != item.PathFlid(pathIndex))) // we are now off of the path pathIndex = -1; int size = m_cache.GetVectorSize(cmo.Hvo, flid); StringBuilder sb = null; for (int i = 0; i < size; i++) { int objHvo = m_cache.GetVectorItem(cmo.Hvo, flid, i); if (pathIndex != -1 && (pathIndex < item.PathLength - 1 && objHvo == item.PathObject(pathIndex + 1)) || (pathIndex == item.PathLength - 1 && objHvo == item.KeyObject)) { return GetChildObjKey(layout, objHvo, item, pathIndex + 1, sortedFromEnd); } // if we are off of the path, we concatenate all vector keys to create an // aggregate key string childObjKey = GetChildObjKey(layout, objHvo, item, -1, sortedFromEnd); if (childObjKey != null) { if (sb == null) sb = new StringBuilder(); sb.Append(childObjKey); } } if (sb != null) return sb.ToString(); } break; case "layout": case "part": { string partref = XmlUtils.GetOptionalAttributeValue(layout, "ref"); if (partref != null) { XmlNode part = XmlVc.GetNodeForPart(cmo.Hvo, partref, true, m_sda, m_layouts); return GetKey(part, cmo, item, pathIndex, sortedFromEnd); } foreach (XmlNode child in layout.ChildNodes) { if (child is XmlComment) continue; string key = GetKey(child, cmo, item, pathIndex, sortedFromEnd); if (key != null) return key; } } break; } return null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// For most of these we want to return the same thing. /// </summary> /// <param name="item">The item.</param> /// <param name="sortedFromEnd">if set to <c>true</c> [sorted from end].</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public virtual string[] SortStrings(ManyOnePathSortItem item, bool sortedFromEnd) { CheckDisposed(); return Strings(item, sortedFromEnd); }
private Set<int> GetDescendents(int hvoCommonAncestor, int relativesFlid) { string listPropertyName = Cache.MetaDataCacheAccessor.GetFieldName(relativesFlid); string parentObjName = Cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(hvoCommonAncestor).ClassName; string xpathToPart = "./part[@id='" + parentObjName + "-Jt-" + listPropertyName + "']"; XmlNode pathSpec = m_parentToChildrenSpecs.SelectSingleNode(xpathToPart); Debug.Assert(pathSpec != null, String.Format("You are experiencing a rare and difficult-to-reproduce error (LT- 11443 and linked issues). If you can add any information to the issue or fix it please do. If JohnT is available please call him over. Expected to find part ({0}) in ParentClassPathsToChildren", xpathToPart)); if (pathSpec == null) return new Set<int>(); // This just means we don't find a related object. Better than crashing, but not what we intend. // get the part spec that gives us the path from obsolete current (parent) list item object // to the new one. var vc = new XmlBrowseViewBaseVc(m_cache, null); var parentItem = new ManyOnePathSortItem(hvoCommonAncestor, null, null); var collector = new XmlBrowseViewBaseVc.ItemsCollectorEnv(null, m_cache, hvoCommonAncestor); vc.DisplayCell(parentItem, pathSpec, hvoCommonAncestor, collector); if (collector.HvosCollectedInCell != null && collector.HvosCollectedInCell.Count > 0) { return collector.HvosCollectedInCell; } return new Set<int>(); }
public override void TestSetup() { base.TestSetup(); IManyOnePathSortItem mopsi = new ManyOnePathSortItem(Cache.LangProject); m_list = new ArrayList(); m_list.Add(mopsi); var leFactory = Cache.ServiceLocator.GetInstance<ILexEntryFactory>(); UndoableUnitOfWorkHelper.Do("undoit", "redoit", Cache.ActionHandlerAccessor, () => { m_le1 = leFactory.Create(); m_le2 = leFactory.Create(); }); mopsi = new ManyOnePathSortItem(Cache.LangProject.LexDbOA.Hvo, new int[] { m_le1.Hvo, m_le2.Hvo }, new int[] { 2, 3 }); m_list.Add(mopsi); }
///// <summary> ///// Initialize the filter ///// </summary> ///// <param name="cache"></param> ///// <param name="configuration"></param> // public override void Init(FdoCache cache,XmlNode filterNode) // { //// m_cache = cache; //// int hvo = m_cache.LangProject.MorphologicalDataOA.TestSetsOC.HvoArray[0]; //// m_wordSet= WfiWordSet.CreateFromDBObject(m_cache, hvo); // } /// ------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------ public override bool Accept (ManyOnePathSortItem item) { int hvo = item.KeyObject; for(int i = m_hvos.Length-1; i>=0; i--) { if(m_hvos[i] == hvo) return true; } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// For most of these we want to return the same thing. /// </summary> /// <param name="item"></param> /// <returns></returns> public string[] SortStrings(ManyOnePathSortItem item, bool sortedFromEnd) { return Strings(item, sortedFromEnd); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Checks if we are sorted by column of the given flid, and if so returns the hvo for that item. /// </summary> /// <param name="flid">The flid.</param> /// <param name="iPathFlid">The i path flid.</param> /// <param name="item">The item.</param> /// <param name="hvo">The hvo.</param> /// <returns> /// <c>true</c> if [is sorted by field] [the specified flid]; otherwise, <c>false</c>. /// </returns> /// ------------------------------------------------------------------------------------ static internal bool IsSortedByField(int flid, int iPathFlid, ManyOnePathSortItem item, out int hvo) { hvo = 0; if (item.PathLength > iPathFlid && item.PathFlid(iPathFlid) == flid) { if ((item.PathLength > 1) && (item.PathLength != (iPathFlid + 1))) hvo = item.PathObject(1); else hvo = item.KeyObject; return true; } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// We want to display the object bvi.KeyObject, or one of its pathobjects, in a /// column specified by colSpec. /// Determine the hvo and XmlNode that we should use as the root for the cell. /// By default, we display the first object in the path, using the base node /// derived from the colSpec. /// However, if the colSpec begins with a path compatible with bvi.PathFlid(0), /// we can use bvi.PathObject(1) and the appropriate derived node. /// If all flids match we can use bvi.KeyObject itself. /// If collectOuterStructParts is non-null, it accumulates containing parts /// that are structural, like para, span, div. /// </summary> /// <param name="bvi">The bvi.</param> /// <param name="colSpec">The col spec.</param> /// <param name="mdc">The MDC.</param> /// <param name="sda">The sda.</param> /// <param name="layouts">The layouts.</param> /// <param name="hvo">The hvo.</param> /// <param name="collectOuterStructParts">The collect outer struct parts.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public static XmlNode GetNodeToUseForColumn(ManyOnePathSortItem bvi, XmlNode colSpec, IFwMetaDataCache mdc, ISilDataAccess sda, LayoutCache layouts, out int hvo, List<XmlNode> collectOuterStructParts) { return GetDisplayCommandForColumn(bvi, colSpec, mdc, sda, layouts, out hvo, collectOuterStructParts).Node; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Gets the items. /// </summary> /// <param name="item">The item.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ protected abstract int[] GetItems(ManyOnePathSortItem item);
/// <summary> /// return all the hvos for this column in the row identified by the sort item. /// </summary> /// <param name="rowItem"></param> /// <returns></returns> protected override int[] GetItems(ManyOnePathSortItem rowItem) { int hvoRootObj = rowItem.RootObject.Hvo; XmlBrowseViewBaseVc.ItemsCollectorEnv collector = new XmlBrowseViewBaseVc.ItemsCollectorEnv(null, m_cache, hvoRootObj); if (Vc != null && m_colSpec != null) this.Vc.DisplayCell(rowItem, m_colSpec, hvoRootObj, collector); return collector.HvosCollectedInCell.ToArray(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------ public override bool Accept(ManyOnePathSortItem item) { int[] values = GetItems(item); if (m_mode == ListMatchOptions.All || m_mode == ListMatchOptions.Exact) { Set<int> matches = new Set<int>(m_targets.Count); foreach (int hvo in values) { if (m_targets.Contains(hvo)) { matches.Add(hvo); if (m_mode == ListMatchOptions.All && matches.Count == m_targets.Count) return true; } else if (m_mode == ListMatchOptions.Exact) return false; // found one that isn't present. } return matches.Count == m_targets.Count; // success if we found them all. } else { // any or none: look for first match foreach (int hvo in values) { if (m_targets.Contains(hvo)) { // If we wanted any, finding one is a success; if we wanted none, finding any is a failure. return m_mode == ListMatchOptions.Any; } } // If we wanted any, not finding any is failure; if we wanted none, not finding any is success. return m_mode != ListMatchOptions.Any; } }
/// <summary> /// This returns a NodeDisplayCommand containing thd node for GetNodeToUseForColumn. However, it distinguishes whether to /// display the children of this node or the node itself by returning the appropriate kind of NodeDisplayCommand. /// </summary> /// <param name="bvi"></param> /// <param name="colSpec"></param> /// <param name="mdc"></param> /// <param name="sda"></param> /// <param name="layouts"></param> /// <param name="hvo"></param> /// <param name="collectOuterStructParts"></param> /// <returns></returns> public static NodeDisplayCommand GetDisplayCommandForColumn(ManyOnePathSortItem bvi, XmlNode colSpec, IFwMetaDataCache mdc, ISilDataAccess sda, LayoutCache layouts, out int hvo, List<XmlNode> collectOuterStructParts) { XmlNode topNode = XmlBrowseViewBaseVc.GetColumnNode(colSpec, bvi.PathObject(0), sda, layouts); return GetDisplayCommandForColumn1(bvi, topNode, mdc, sda, layouts, 0, out hvo, collectOuterStructParts); }
private Set<int> GetDescendents(int hvoCommonAncestor, int relativesFlid) { string listPropertyName = Cache.MetaDataCacheAccessor.GetFieldName((uint)relativesFlid); string parentObjName = Cache.MetaDataCacheAccessor.GetClassName((uint)m_cache.GetClassOfObject(hvoCommonAncestor)); string xpathToPart = "./part[@id='" + parentObjName + "-Jt-" + listPropertyName + "']"; XmlNode pathSpec = m_parentToChildrenSpecs.SelectSingleNode(xpathToPart); if (pathSpec == null) throw new ArgumentException("Expected to find part ({0}) in ParentClassPathsToChildren", xpathToPart); // get the part spec that gives us the path from obsolete current (parent) list item object // to the new one. using (XmlBrowseViewBaseVc vc = new XmlBrowseViewBaseVc(m_cache, null)) { ManyOnePathSortItem parentItem = new ManyOnePathSortItem(hvoCommonAncestor, null, null); XmlBrowseViewBaseVc.ItemsCollectorEnv collector = new XmlBrowseViewBaseVc.ItemsCollectorEnv(null, m_cache, hvoCommonAncestor); vc.DisplayCell(parentItem, pathSpec, hvoCommonAncestor, collector); if (collector.HvosCollectedInCell != null && collector.HvosCollectedInCell.Count > 0) { return collector.HvosCollectedInCell; } } return new Set<int>(); }
private string GetChildObjKey(XmlNode layout, int hvo, ManyOnePathSortItem item, int pathIndex, bool sortedFromEnd) { ICmObject childObj = CmObject.CreateFromDBObject(m_cache, hvo); string layoutName = XmlUtils.GetManditoryAttributeValue(layout, "layout"); XmlNode part = XmlVc.GetNodeForPart(hvo, layoutName, true, m_sda, m_layouts); string key = GetKey(part, childObj, item, pathIndex, sortedFromEnd); if (key != null) return key; return CallSortMethod(childObj, sortedFromEnd); }
/// ------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------ public abstract bool Accept(ManyOnePathSortItem item);
/// <summary> /// Get a key from the item. /// </summary> /// <param name="item">The item.</param> /// <param name="sortedFromEnd">if set to <c>true</c> [sorted from end].</param> /// <returns></returns> public override string[] SortStrings(ManyOnePathSortItem item, bool sortedFromEnd) { CheckDisposed(); if (item.KeyCmObject == null) return new string[0]; // traverse the part tree from the root, the root object and the root layout node should // be compatible XmlNode layout = XmlVc.GetNodeForPart(item.RootObject.Hvo, m_layoutName, true, m_sda, m_layouts); string key = GetKey(layout, item.RootObject, item, 0, sortedFromEnd); if (key == null) { // the root object sort method is not tried in GetKey key = CallSortMethod(item.RootObject, sortedFromEnd); if (key == null) { // try calling the sort method on the key object key = CallSortMethod(item.KeyCmObject, sortedFromEnd); if (key == null) { // Try the default fallback if we can't find the method. key = item.KeyCmObject.SortKey ?? ""; if (sortedFromEnd) key = StringUtils.ReverseString(key); key = key + " " + item.KeyCmObject.SortKey2Alpha; } } } return new string[] {key}; }
/// ------------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------------ public override bool Accept(ManyOnePathSortItem item) { foreach (RecordFilter f in m_filters) if (!f.Accept(item)) return false; return true; }
/// <summary> /// Default is to return the strings for the key object. /// </summary> /// <param name="item"></param> /// <returns></returns> public string[] Strings(ManyOnePathSortItem item, bool sortedFromEnd) { string[] result = Strings(item.KeyObject); if (sortedFromEnd) for(int i = 0; i < result.Length; i++) result[i] = StringUtils.ReverseString(result[i]); return result; }
/// ------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item"></param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------ public override bool Accept (ManyOnePathSortItem item) { ICmObject obj = item.KeyCmObject; if (!(obj is ICmBaseAnnotation)) return false;//it's not a base annotation ICmBaseAnnotation annotation = (ICmBaseAnnotation)obj; if (annotation.BeginObjectRAHvo <= 0) return false; int cls = obj.Cache.GetClassOfObject(annotation.BeginObjectRAHvo); bool x = m_classIds.Contains(cls); foreach(uint i in m_classIds) { if ( i == cls) return true; } return false; }
public ITsString Key(ManyOnePathSortItem item) { throw new NotImplementedException("Don't have new Key function implemented on class " + this.GetType()); }
/// <summary> /// Recursive implementation method for GetDisplayCommandForColumn. /// </summary> /// <param name="bvi"></param> /// <param name="node"></param> /// <param name="mdc"></param> /// <param name="sda"></param> /// <param name="layouts"></param> /// <param name="depth"></param> /// <param name="hvo"></param> /// <param name="collectOuterStructParts"></param> /// <returns></returns> static NodeDisplayCommand GetDisplayCommandForColumn1(ManyOnePathSortItem bvi, XmlNode node, IFwMetaDataCache mdc, ISilDataAccess sda, LayoutCache layouts, int depth, out int hvo, List<XmlNode> collectOuterStructParts) { hvo = bvi.PathObject(depth); // default switch(node.Name) { case "obj": case "seq": { // These two cases are the same here, because if the field matches, the object // that determines the next step comes from the bvi, not from one or many items // in the property. if (bvi.PathLength == depth) { // No more path, we display the final object using the node we've deduced is // appropriate for it. // (We could put this test outside the switch. But then we don't dig into // layout, para, span, etc elements at the end of the chain. It's more // consistent if we always dig as deep as we can. hvo = bvi.KeyObject; return new NodeDisplayCommand(node); } int clsid = sda.get_IntProp(bvi.PathObject(depth), (int)CmObjectFields.kflidCmObject_Class); int flid = (int)mdc.GetFieldId2((uint)clsid, XmlUtils.GetManditoryAttributeValue(node, "field"), true); if (flid != bvi.PathFlid(depth)) return new NodeDisplayCommand(node); // different field, can't dig deeper. int hvoDst = bvi.PathObject(depth + 1); // If the path object has been deleted, fall back to displaying whatever the property currently holds. if (sda.get_IntProp(hvoDst, (int)CmObjectFields.kflidCmObject_Class) == 0) return new NodeDisplayCommand(node); // different field, can't dig deeper. // At this point we have to mimic the process that XmlVc uses to come up with the // node that will be used to process the destination item. XmlNode dstNode = GetNodeForRelatedObject(hvoDst, null, node, layouts, sda); return GetDisplayCommandForColumn1(bvi, dstNode, mdc, sda, layouts, depth + 1, out hvo, collectOuterStructParts); } case "para": case "span": case "div": case "concpara": case "innerpile": { XmlNode mainChild = FindMainChild(node); if (mainChild == null) return new NodeDisplayCommand(node); // can't usefully go further. if (collectOuterStructParts != null) collectOuterStructParts.Add(node); return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts); } // Review JohnT: In XmlVc, "part" is the one thing that calls ProcessChildren with non-null caller. // this should make some difference here, but I can't figure what yet, or come up with a test that fails. // We may need a "caller" argument to pass this down so it can be used in GetNodeForRelatedObject. case "part": { string layoutName = XmlUtils.GetOptionalAttributeValue(node, "ref"); if (layoutName != null) { // It's actually a part ref, in a layout, not a part looked up by one! // Get the node it refers to, and make a command to process its children. XmlNode part = XmlVc.GetNodeForPart(hvo, layoutName, false, sda, layouts); if (part != null) return new NodeChildrenDisplayCommand(part); // display this object using the children of the part referenced. else return new NodeDisplayCommand(node); // no matching part, do default. } // These are almost the same, but are never added to collectOuterStructParts. // Also, expecially in the case of 'layout', they may result from unification, and be meaningless // except for their children; in any case, the children are all we want to process. // This is the main reason we return a command, not just a node: this case has to return the subclass. XmlNode mainChild = FindMainChild(node); if (mainChild == null) return new NodeChildrenDisplayCommand(node); // can't usefully go further. return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts); } case "column": case "layout": { // These are almost the same as para, span, etc, but are never added to collectOuterStructParts. // Also, expecially in the case of 'layout', they may result from unification, and be meaningless // except for their children; in any case, the children are all we want to process. // This is the main reason we return a command, not just a node: this case has to return the subclass. XmlNode mainChild = FindMainChild(node); if (mainChild == null) return new NodeChildrenDisplayCommand(node); // can't usefully go further. return GetDisplayCommandForColumn1(bvi, mainChild, mdc, sda, layouts, depth, out hvo, collectOuterStructParts); } default: // If we can't find anything clever to do, we display the object at the // current level using the current node. return new NodeDisplayCommand(node); } }
/// ------------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------------ public override bool Accept(ManyOnePathSortItem item) { return Matcher.Accept(m_finder.Key(item)); }
const int maxDigits = 10; // Int32.MaxValue.ToString().Length;, but that is not 'const'! /// ------------------------------------------------------------------------------------ /// <summary> /// Get a key from the item for sorting. Add enough leading zeros so string comparison works. /// Note: negative number case not tested, for lack of a current example where it is possible. /// </summary> /// <param name="item">The item.</param> /// <param name="sortedFromEnd">if set to <c>true</c> [sorted from end].</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public override string[] SortStrings(ManyOnePathSortItem item, bool sortedFromEnd) { CheckDisposed(); string[] baseResult = base.SortStrings(item, sortedFromEnd); if (sortedFromEnd) return baseResult; // what on earth would it mean?? if (baseResult.Length != 1) return baseResult; string sVal = baseResult[0]; if (sVal.Length == 0) return new string[] { new String('0', maxDigits) }; string prefix = sVal.Substring(0,1); if (prefix == "-") sVal = sVal.Substring(1); // strip off the minus else prefix = ""; // not negated, no prefix needed. if (sVal.Length == maxDigits) return new string[] { prefix + sVal }; else return new string[] { prefix + new String('0', maxDigits - sVal.Length) + sVal }; }
/// ------------------------------------------------------------------------------------------ /// <summary> /// decide whether this object should be included /// </summary> /// <param name="item">The item.</param> /// <returns>true if the object should be included</returns> /// ------------------------------------------------------------------------------------------ public override bool Accept(ManyOnePathSortItem item) { return true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Figure the node and hvo that correspond to the particular sort item, /// and generate its key. This figures out the XML needed for the particular /// key object, and interprets it to make a key. /// </summary> /// <param name="item">The item.</param> /// <param name="sortedFromEnd"></param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public string[] Strings(ManyOnePathSortItem item, bool sortedFromEnd) { CheckDisposed(); string result = Key(item, true).Text; if (result == null) return new string[0]; else { if (sortedFromEnd) result = StringUtils.ReverseString(result); return new string[] { result }; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Keys the specified item. /// </summary> /// <param name="item">The item.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public ITsString Key(ManyOnePathSortItem item) { CheckDisposed(); return Key(item, false); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Keys the specified item. /// </summary> /// <param name="item">The item.</param> /// <param name="fForSorting">if set to <c>true</c> [f for sorting].</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public ITsString Key(ManyOnePathSortItem item, bool fForSorting) { CheckDisposed(); if (m_cache == null) throw new ApplicationException("There's no way the browse VC (m_vc) can get a string in its current state."); int hvo = item.RootObject.Hvo; TsStringCollectorEnv collector; if (fForSorting) { collector = new SortCollectorEnv(null, m_cache.MainCacheAccessor, hvo); } else { collector = new TsStringCollectorEnv(null, m_cache.MainCacheAccessor, hvo); } // This will check to see if the VC is either null or disposed. The disposed check is neccesary because // there are several instances where we can have a reference to an instance that was disposed, which will // cause problems later on. // Enhance CurtisH/EricP: If this VC gets used in other places, rather than adding more checks like this one, // it may be better to refactor XWorksViewBase to cause it to reload the sorter and filter from persistence // every time the tool is changed if (m_vc == null || m_vc.IsDisposed) { m_vc = new XmlBrowseViewBaseVc(m_cache, m_stringTbl); } else { if (m_vc.Cache == null) m_vc.Cache = m_cache; if (m_vc.Cache == null) throw new ApplicationException("There's no way the browse VC (m_vc) can get a string in its current state."); if (m_vc.StringTbl == null) m_vc.StringTbl = m_stringTbl; } m_vc.DisplayCell(item, m_colSpec, hvo, collector); return collector.Result; }
/// <summary> /// Get the items to be compared against the filter. /// </summary> /// <param name="item"></param> /// <returns></returns> protected override int[] GetItems(ManyOnePathSortItem item) { ISilDataAccess sda = m_cache.MainCacheAccessor; List<int> results = new List<int>(); if (item.PathLength > 0 && item.PathFlid(0) == kflidMsas) { // sorted by MSA, match just the one MSA. // I don't think this path can occur with the current XML spec where this is used. int hvoMsa; if (item.PathLength > 1) hvoMsa = item.PathObject(1); else hvoMsa = item.KeyObject; GetItemsForMsaType(sda, ref results, hvoMsa); } else if (item.PathLength >= 1 && item.PathFlid(0) == kflidEntrySenses) { // sorted in a way that shows one sense per row, test that sense's MSA. int hvoSense; if (item.PathLength > 1) hvoSense = item.PathObject(1); else hvoSense = item.KeyObject; int hvoMsa = sda.get_ObjectProp(hvoSense, (int)LexSense.LexSenseTags.kflidMorphoSyntaxAnalysis); GetItemsForMsaType(sda, ref results, hvoMsa); } else { int hvoEntry = item.RootObject.Hvo; int cmsa = sda.get_VecSize(hvoEntry, kflidMsas); for (int imsa = 0; imsa < cmsa; imsa++) { int hvoMsa = sda.get_VecItem(hvoEntry, kflidMsas, imsa); GetItemsForMsaType(sda, ref results, hvoMsa); } } return results.ToArray(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Given a ManyOnePathSortItem that describes one of the rows in the view, and a node /// that configures one of the columns, make the required calls to the VwEnv to display the cell /// contents. This is also used by the LayoutFinder. /// </summary> /// <param name="item">The item.</param> /// <param name="node">The node.</param> /// <param name="hvo">The hvo.</param> /// <param name="vwenv">The vwenv.</param> /// ------------------------------------------------------------------------------------ public void DisplayCell(ManyOnePathSortItem item, XmlNode node, int hvo, IVwEnv vwenv) { CheckDisposed(); List<XmlNode> outerParts = new List<XmlNode>(); int hvoToDisplay; NodeDisplayCommand dispCommand = XmlViewsUtils.GetDisplayCommandForColumn(item, node, m_cache.MetaDataCacheAccessor, m_cache.MainCacheAccessor, m_layouts, out hvoToDisplay, outerParts); // See if the column has a writing system established for it. try { if (node.Name == "column") { SetForcedWs(node); } OpenOuterParts(outerParts, vwenv, hvoToDisplay); if (hvoToDisplay == hvo) dispCommand.PerformDisplay(this, 0, hvo, vwenv); else { int fragId = GetId(dispCommand, m_idToDisplayCommand, m_displayCommandToId); vwenv.AddObj(hvoToDisplay, this, fragId); } //ProcessChildren(nodeToProcess, vwenv, hvoToDisplay, null); CloseOuterParts(outerParts, vwenv); } finally { // reset the ws for next column in the row. WsForce = 0; } }