public List <IConversationTreeNode> Sort(IConversationTreeNode rootNode, ConversationTreeSortOrder sortOrder)
{
List <IConversationTreeNode> list = new List <IConversationTreeNode>();
PriorityQueue <IConversationTreeNode> priorityQueue = new PriorityQueue <IConversationTreeNode>();
this.AddNodeAndUnrelatedChildrenRecursively(priorityQueue, rootNode);
while (priorityQueue.Count() > 0)
{
IConversationTreeNode conversationTreeNode = priorityQueue.Dequeue();
if (conversationTreeNode.HasData)
{
conversationTreeNode.SortOrder = sortOrder;
list.Add(conversationTreeNode);
}
foreach (IConversationTreeNode conversationTreeNode2 in conversationTreeNode.ChildNodes)
{
if (conversationTreeNode.GetRelationTo(conversationTreeNode2) != ConversationTreeNodeRelation.Unrelated)
{
this.AddNodeAndUnrelatedChildrenRecursively(priorityQueue, conversationTreeNode2);
}
}
}
if (sortOrder == ConversationTreeSortOrder.TraversalChronologicalDescending)
{
list.Reverse();
}
return(list);
}
// Token: 0x06002E99 RID: 11929 RVA: 0x0010A31C File Offset: 0x0010851C
private void InternalExpandConversation(OwaStoreObjectId expId)
{
try
{
if (expId != null)
{
SortOrder sortOrder = SortOrder.Ascending;
ConversationPartsList2 conversationPartsList = new ConversationPartsList2(sortOrder, base.UserContext, base.SearchScope);
base.BindToFolder();
ConversationTreeSortOrder sortOrder2 = base.UserContext.UserOptions.ShowTreeInListView ? ConversationTreeSortOrder.DeepTraversalAscending : ConversationUtilities.GetConversationTreeSortOrder(base.UserContext.UserOptions.ConversationSortOrder);
conversationPartsList.ConversationPartsDataSource = new ConversationPartsDataSource(base.UserContext, conversationPartsList.Properties, base.DataFolder, expId, sortOrder2);
conversationPartsList.ConversationPartsDataSource.Load();
OwaStoreObjectId conversationId = expId;
if (base.IsFiltered)
{
conversationId = OwaStoreObjectId.CreateFromConversationId(expId.ConversationId, base.DataFolder, expId.InstanceKey);
}
conversationPartsList.RenderConversationParts(this.Writer, conversationId, base.ContextFolder, base.DataFolder);
}
}
finally
{
this.EndProcessEvent();
}
}
internal ConversationTree(ConversationTreeSortOrder sortOrder, IConversationTreeNode rootNode, IList <IConversationTreeNode> nodes, HashSet <PropertyDefinition> loadedProperties)
{
this.rootNode = rootNode;
this.nodes = nodes;
this.loadedProperties = loadedProperties;
this.sortOrder = sortOrder;
}
public IConversationTree GetNewestSubTree(IConversationTree conversationTree, int count)
{
if (count <= 0)
{
throw new ArgumentException("Count should be greater than 0", "count");
}
ExTraceGlobals.ConversationTracer.TraceDebug <int, int>((long)this.GetHashCode(), "ConversationTreeFactory.GetNewestSubTree: count: {0}, tree size: {1}", count, conversationTree.Count);
if (count >= conversationTree.Count)
{
return(conversationTree);
}
IConversationTree trimmedConversationTree = null;
ConversationTreeSortOrder sortOrder = ConversationTreeSortOrder.ChronologicalDescending;
conversationTree.ExecuteSortedAction(sortOrder, delegate(ConversationTreeSortOrder treeOriginalSortOrder)
{
List <IStorePropertyBag> list = new List <IStorePropertyBag>(count);
foreach (IConversationTreeNode conversationTreeNode in conversationTree)
{
if (count-- <= 0)
{
break;
}
list.AddRange(conversationTreeNode.StorePropertyBags);
}
trimmedConversationTree = this.Create(list, null);
trimmedConversationTree.Sort(treeOriginalSortOrder);
});
return(trimmedConversationTree);
}
public void ExecuteSortedAction(ConversationTreeSortOrder sortOrder, SortedActionDelegate action)
{
ConversationTreeSortOrder treeOriginalSortOrder = this.sortOrder;
this.Sort(sortOrder);
action(treeOriginalSortOrder);
this.Sort(treeOriginalSortOrder);
}
private List <IConversationTreeNode> CalculateFlatSortNodes(ConversationTreeSortOrder sortOrder)
{
if (ConversationTreeNodeBase.IsTraversalChronologicalSortOrder(sortOrder))
{
return(this.childNodeSorter.Sort(this, sortOrder));
}
return(this.FlatSortChildNodes(sortOrder));
}
private void TraversalSortChildNodes(ConversationTreeSortOrder sortOrder)
{
for (int i = 0; i < this.childNodes.Count; i++)
{
this.childNodes[i].SortChildNodes(sortOrder);
}
this.childNodes.Sort(delegate(IConversationTreeNode left, IConversationTreeNode right)
{
int num = ConversationTreeNodeBase.CompareNodesTraversal(left, right);
return((sortOrder == ConversationTreeSortOrder.DeepTraversalAscending) ? num : (-1 * num));
});
}
private IConversationTree BuildTree(IConversationTreeNode rootNode, IList <IConversationTreeNode> nodes = null, HashSet <PropertyDefinition> loadedProperties = null)
{
nodes = (nodes ?? new List <IConversationTreeNode>());
loadedProperties = (loadedProperties ?? new HashSet <PropertyDefinition>());
ConversationTreeSortOrder sortOrder = ConversationTreeSortOrder.DeepTraversalAscending;
foreach (IConversationTreeNode node in nodes)
{
rootNode.TryAddChild(node);
}
rootNode.SortChildNodes(sortOrder);
return(this.InternalInstantiate(sortOrder, rootNode, nodes, loadedProperties));
}
private List <IConversationTreeNode> FlatSortChildNodes(ConversationTreeSortOrder sortOrder)
{
List <IConversationTreeNode> flatSortNodes = new List <IConversationTreeNode>(0);
this.ApplyActionToChild(delegate(IConversationTreeNode treeNode)
{
treeNode.SortOrder = sortOrder;
if (treeNode.HasData)
{
flatSortNodes.Add(treeNode);
}
});
ConversationTreeNodeBase.SortByDate(flatSortNodes, sortOrder == ConversationTreeSortOrder.ChronologicalAscending);
return(flatSortNodes);
}
public void SortChildNodes(ConversationTreeSortOrder sortOrder)
{
if (this.SortOrder == sortOrder)
{
return;
}
if (ConversationTreeNodeBase.IsChronologicalSortOrder(sortOrder))
{
this.FlatSortNodes = this.CalculateFlatSortNodes(sortOrder);
}
else
{
this.TraversalSortChildNodes(sortOrder);
}
this.SortOrder = sortOrder;
}
internal ConversationPartsDataSource(UserContext context, Hashtable properties, Folder folder, OwaStoreObjectId conversationId, QueryFilter filter, ConversationTreeSortOrder sortOrder) : base(context, false, properties, folder, null, filter)
{
this.conversationId = conversationId;
this.sortOrder = sortOrder;
}
internal ConversationPartsDataSource(UserContext context, Hashtable properties, Folder folder, OwaStoreObjectId conversationId, ConversationTreeSortOrder sortOrder) : this(context, properties, folder, conversationId, null, sortOrder)
{
}
protected virtual IConversationTree InternalInstantiate(ConversationTreeSortOrder sortOrder, IConversationTreeNode rootNode, IList <IConversationTreeNode> nodes, HashSet <PropertyDefinition> loadedProperties)
{
return(new ConversationTree(sortOrder, rootNode, nodes, loadedProperties));
}
public void Sort(ConversationTreeSortOrder sortOrder)
{
EnumValidator.ThrowIfInvalid <ConversationTreeSortOrder>(sortOrder, "sortOrder");
this.sortOrder = sortOrder;
this.rootNode.SortChildNodes(sortOrder);
}
private static bool IsTraversalChronologicalSortOrder(ConversationTreeSortOrder sortOrder)
{
return(sortOrder == ConversationTreeSortOrder.TraversalChronologicalAscending || sortOrder == ConversationTreeSortOrder.TraversalChronologicalDescending);
}
