static int partition(SharpTreeNodeCollection array, int top, int bottom, Comparison <SharpTreeNode> comparison)
{
SharpTreeNode x = array[top];
int i = top - 1;
int j = bottom + 1;
do
{
do
{
j--;
} while (comparison(x, array[j]) > 0);
do
{
i++;
} while (comparison(x, array[i]) < 0);
if (i < j)
{
if (comparison(array[j], array[i]) != 0)
{
Swap(array, i, j);
}
}
} while (i < j);
return(j);
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, TypeDefinition type)
{
if (type.BaseType != null)
children.Add(new BaseTypesEntryNode(type.BaseType, false));
foreach (TypeReference i in type.Interfaces) {
children.Add(new BaseTypesEntryNode(i, true));
}
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, TypeDef type) {
if (type.BaseType != null)
children.Add(new BaseTypesEntryNode(type.BaseType, false));
foreach (var i in type.Interfaces) {
if (i.Interface != null)
children.Add(new BaseTypesEntryNode(i.Interface, true));
}
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, TypeReference type)
{
var def = type.Resolve();
if (def.BaseType != null)
children.Add(new BaseTypesEntryNode(ResolveWithTypes(def.BaseType, type), false));
foreach (TypeReference i in def.Interfaces)
children.Add(new BaseTypesEntryNode(ResolveWithTypes(i, type), true));
}
/// <summary>
/// Makes sure that every child in this collection is ready
/// </summary>
/// <param name="coll"></param>
/// <returns></returns>
public static IEnumerable <SharpTreeNode> EnsureLazyChildren(this SharpTreeNodeCollection coll)
{
foreach (var x in coll)
{
x.EnsureLazyChildren();
yield return(x);
}
}
static void quicksort(SharpTreeNodeCollection num, int top, int bottom, Comparison <SharpTreeNode> comparison)
{
int middle;
if (top < bottom)
{
middle = partition(num, top, bottom, comparison);
quicksort(num, top, middle, comparison);
quicksort(num, middle + 1, bottom, comparison);
}
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, TypeDefinition type)
{
if (type.BaseType != null)
{
children.Add(new BaseTypesEntryNode(type.BaseType, false));
}
foreach (var i in type.Interfaces)
{
children.Add(new BaseTypesEntryNode(i.InterfaceType, true));
}
}
static void Swap(SharpTreeNodeCollection array, int i, int j)
{
SwapCount++;
Debug.Assert(i < j);
SharpTreeNode temp = array[i];
SharpTreeNode tmp = array[j];
array.RemoveAt(j);
array[i] = tmp;
array.Insert(j, temp);
//array.Swap(i, j);
}
internal static TestMethodWrapperContainer GetContainer(this SharpTreeNodeCollection treeNodeCollection, TestType testType)
{
TestMethodWrapperContainer container = null;
foreach (var node in treeNodeCollection)
{
var testContainer = node as TestMethodWrapperContainer;
if (null != testContainer && testContainer.TestType == testType)
{
container = testContainer;
}
}
return(container);
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, PEFile module, ITypeDefinition typeDefinition)
{
TypeDefinitionHandle handle = (TypeDefinitionHandle)typeDefinition.MetadataToken;
DecompilerTypeSystem typeSystem = new DecompilerTypeSystem(module, module.GetAssemblyResolver(),
TypeSystemOptions.Default | TypeSystemOptions.Uncached);
var t = typeSystem.MainModule.ResolveEntity(handle) as ITypeDefinition;
foreach (var td in t.GetAllBaseTypeDefinitions().Reverse().Skip(1))
{
if (t.Kind != TypeKind.Interface || t.Kind == td.Kind)
{
children.Add(new BaseTypesEntryNode(td));
}
}
}
static void ExchangeSort(SharpTreeNodeCollection num, Comparison <SharpTreeNode> comparison)
{
int i, j;
int numLength = num.Count;
for (i = 0; i < (numLength - 1); i++)
{
for (j = (i + 1); j < numLength; j++)
{
if (comparison(num[i], num[j]) < 0)
{
Swap(num, i, j);
}
}
}
}
static public void Sort(SharpTreeNodeCollection Children, string sortMember, ListSortDirection direction)
{
Comparison <SharpTreeNode> comparison = (This, That) =>
{
var L = (typeof(TreeItem).GetProperty(sortMember).GetValue(This, null) as IComparable);
var R = (typeof(TreeItem).GetProperty(sortMember).GetValue(That, null) as IComparable);
int ret;
if (L == null && R == null)
{
ret = 0;
}
else if (L == null)
{
ret = 1;
}
else if (R == null)
{
ret = -1;
}
else
{
ret = L.CompareTo(R);
}
if (direction == ListSortDirection.Ascending)
{
return(-ret);
}
return(ret);
};
SwapCount = 0;
var watch = System.Diagnostics.Stopwatch.StartNew();
Sort(Children, sortMember, direction, comparison);
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
#if DEBUG
if (elapsedMs > 100)
{
AppLog.Debug("TreeView Sorting took very log: {0} ms and required {1} swaps", elapsedMs, SwapCount);
}
#endif
}
static void BubbleSort(SharpTreeNodeCollection num, Comparison <SharpTreeNode> comparison)
{
int i, j;
bool flag = true;
int numLength = num.Count;
for (i = 1; (i <= numLength) && flag; i++)
{
flag = false;
for (j = 0; j < (numLength - 1); j++)
{
if (comparison(num[j + 1], num[j]) > 0)
{
Swap(num, j, j + 1);
flag = true;
}
}
}
}
static void Sort(SharpTreeNodeCollection Children, string sortMember, ListSortDirection direction, Comparison <SharpTreeNode> comparison)
{
if (Children.Count == 0)
{
return;
}
QuickSort(Children, comparison);
//SelectionSort(Children, comparison);
//BubbleSort(Children, comparison);
//ShellSort(Children, comparison);
//ExchangeSort(Children, comparison);
//InsertionSort(Children, comparison);
foreach (var child in Children.OfType <TreeItem>())
{
Sort(child.Children, sortMember, direction, comparison);
}
}
/*static void InsertionSort(SharpTreeNodeCollection num, Comparison<SharpTreeNode> comparison)
* {
* int i, j, key, numLength = num.Count;
* for (j = 1; j < numLength; j++) // Start with 1 (not 0)
* {
* key = num[j];
* for (i = j - 1; (i >= 0) && (num[i] < key); i--) // Smaller values move up
* {
* num[i + 1] = num[i];
* }
* num[i + 1] = key; //Put key into its proper location
* }
* }*/
static void ShellSort(SharpTreeNodeCollection num, Comparison <SharpTreeNode> comparison)
{
int i, numLength = num.Count;
bool flag = true;
int d = numLength;
while (flag || (d > 1))
{
flag = false;
d = (d + 1) / 2;
for (i = 0; i < (numLength - d); i++)
{
if (comparison(num[i + d], num[i]) > 0)
{
Swap(num, i, i + d);
flag = true;
}
}
}
}
internal static void AddBaseTypes(SharpTreeNodeCollection children, PEFile module, ITypeDefinition typeDefinition)
{
var typeDef = module.Metadata.GetTypeDefinition((TypeDefinitionHandle)typeDefinition.MetadataToken);
var baseTypes = typeDefinition.DirectBaseTypes.ToArray();
int i = 0;
if (typeDefinition.Kind == TypeKind.Interface)
{
i++;
}
else if (!typeDef.BaseType.IsNil)
{
children.Add(new BaseTypesEntryNode(module, typeDef.BaseType, baseTypes[i], false));
i++;
}
foreach (var h in typeDef.GetInterfaceImplementations())
{
var impl = module.Metadata.GetInterfaceImplementation(h);
children.Add(new BaseTypesEntryNode(module, impl.Interface, baseTypes[i], true));
i++;
}
}
static void SelectionSort(SharpTreeNodeCollection num, Comparison <SharpTreeNode> comparison)
{
int i, j, first;
int numLength = num.Count;
for (i = numLength - 1; i > 0; i--)
{
first = 0;
for (j = 1; j <= i; j++)
{
if (comparison(num[j], num[first]) < 0)
{
first = j;
}
}
if (first != i)
{
Swap(num, first, i);
}
}
return;
}
static void QuickSort(SharpTreeNodeCollection num, Comparison <SharpTreeNode> comparison)
{
quicksort(num, 0, num.Count - 1, comparison);
}
public SharpTreeNode()
{
Children = new SharpTreeNodeCollection(this);
}
public bool GoToEntity(IEntity entity)
{
// Try to find assembly in workspace
var entityAssembly = entity.ParentAssembly;
if (entityAssembly != null)
{
ITypeDefinition entityType = null;
if (entity is ITypeDefinition)
{
entityType = (ITypeDefinition)entity;
}
else
{
entityType = entity.DeclaringTypeDefinition;
}
SharpTreeNodeCollection namespaceChildren = null;
var root = this.Root as WorkspaceTreeNode;
// Try to find assembly of passed entity among open projects in solution
var solutionTreeNode = this.Root.Children.OfType <SolutionTreeNode>().FirstOrDefault();
if (solutionTreeNode != null)
{
// Ensure that we have children
solutionTreeNode.EnsureLazyChildren();
var projectTreeNode = solutionTreeNode.Children.FirstOrDefault(
node => {
if (node is ProjectTreeNode)
{
var treeNode = (ProjectTreeNode)node;
if (node.Model is IProject)
{
var projectModel = (IProject)node.Model;
return(projectModel.AssemblyModel.FullAssemblyName == entityAssembly.FullAssemblyName);
}
}
return(false);
});
if (projectTreeNode != null)
{
projectTreeNode.EnsureLazyChildren();
namespaceChildren = projectTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Try to find assembly of passed entity among additional assemblies
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
if (namespaceChildren == null)
{
// Add assembly to workspace (unpinned), if not available in ClassBrowser
IAssemblyParserService assemblyParser = SD.GetService <IAssemblyParserService>();
IClassBrowser classBrowser = SD.GetService <IClassBrowser>();
if (assemblyParser != null && classBrowser != null)
{
IAssemblyModel unpinnedAssemblyModel = assemblyParser.GetAssemblyModel(new FileName(entityAssembly.UnresolvedAssembly.Location));
if (unpinnedAssemblyModel != null)
{
classBrowser.UnpinnedAssemblies.Assemblies.Add(unpinnedAssemblyModel);
var assemblyTreeNode = FindAssemblyTreeNode(entityAssembly.FullAssemblyName);
if (assemblyTreeNode != null)
{
assemblyTreeNode.EnsureLazyChildren();
namespaceChildren = assemblyTreeNode.Children;
}
}
}
}
if (namespaceChildren != null)
{
var nsTreeNode = namespaceChildren.FirstOrDefault(
node =>
(node is NamespaceTreeNode) &&
(((NamespaceTreeNode)node).Model is INamespaceModel) &&
(((INamespaceModel)((NamespaceTreeNode)node).Model).FullName == entityType.Namespace)
) as ModelCollectionTreeNode;
if (nsTreeNode != null)
{
// Ensure that we have children
nsTreeNode.EnsureLazyChildren();
SharpTreeNode entityTypeNode = null;
// Search in namespace node recursively
var foundEntityNode = nsTreeNode.FindChildNodeRecursively(
node => {
var treeNode = node as SharpTreeNode;
if (treeNode != null)
{
var treeNodeTypeModel = treeNode.Model as ITypeDefinitionModel;
if (treeNodeTypeModel != null)
{
var modelFullTypeName = treeNodeTypeModel.FullTypeName;
if (modelFullTypeName == entityType.FullTypeName)
{
// This is the TypeDefinitionModel of searched entity (the type itself or its member)
entityTypeNode = treeNode;
if (entity is ITypeDefinition)
{
// We are looking for the type itself
return(true);
}
}
}
if ((entity is IMember) && (treeNode.Model is IMemberModel))
{
// Compare parent types and member names
IMemberModel memberModel = (IMemberModel)treeNode.Model;
IMember member = (IMember)entity;
bool isSymbolOfTypeAndName =
(member.DeclaringType.FullName == memberModel.UnresolvedMember.DeclaringTypeDefinition.FullName) &&
(member.Name == memberModel.Name) &&
(member.SymbolKind == memberModel.SymbolKind);
if (isSymbolOfTypeAndName)
{
var parametrizedEntityMember = member as IParameterizedMember;
var parametrizedTreeNodeMember = memberModel.UnresolvedMember as IUnresolvedParameterizedMember;
if ((parametrizedEntityMember != null) && (parametrizedTreeNodeMember != null))
{
// For methods and constructors additionally check the parameters and their types to handle overloading properly
int treeNodeParamsCount = parametrizedTreeNodeMember.Parameters != null ? parametrizedTreeNodeMember.Parameters.Count : 0;
int entityParamsCount = parametrizedEntityMember.Parameters != null ? parametrizedEntityMember.Parameters.Count : 0;
if (treeNodeParamsCount == entityParamsCount)
{
for (int i = 0; i < entityParamsCount; i++)
{
// Compare full type names or at least only type names without namespace
// This is not precise, but sufficient in most cases.
var entityParamType = parametrizedEntityMember.Parameters[i].Type;
var treeNodeParamType = parametrizedTreeNodeMember.Parameters[i].Type.Resolve(
new SimpleTypeResolveContext(entityAssembly));
if ((entityParamType.FullName != treeNodeParamType.FullName) &&
(entityParamType.Name != treeNodeParamType.Name))
{
return(false);
}
}
// All parameters were equal
return(true);
}
}
else
{
return(true);
}
}
}
}
return(false);
});
// Special handling for default constructors: If not found, jump to type declaration instead
if ((foundEntityNode == null) && (entity.SymbolKind == SymbolKind.Constructor))
{
foundEntityNode = entityTypeNode;
}
if (foundEntityNode != null)
{
this.FocusNode(foundEntityNode);
this.SelectedItem = foundEntityNode;
return(true);
}
}
}
}
return(false);
}
