void ClearDescendants(SharpTreeNode node)
 {
     var index = List.IndexOf(node);
     while (index + 1 < List.Count && List[index + 1].Level > node.Level) {
         RemoveAt(index + 1);
     }
 }

		internal static SharpTreeNode GetNodeByVisibleIndex(SharpTreeNode root, int index)
		{
			root.GetTotalListLength(); // ensure all list lengths are calculated
			Debug.Assert(index >= 0);
			Debug.Assert(index < root.totalListLength);
			SharpTreeNode node = root;
			Debug.Assert(node != null);
			while (true) {
				if (node.left != null && index < node.left.totalListLength) {
					Debug.Assert(node.left != null);
					node = node.left;
				} else {
					if (node.left != null) {
						index -= node.left.totalListLength;
					}
					if (node.isVisible) {
						if (index == 0)
							return node;
						index--;
					}
					Debug.Assert(node.right != null);
					node = node.right;
				}
			}
		}

		public override IDataObject Copy(SharpTreeNode[] nodes)
		{
			var data = new DataObject();
			var paths = SharpTreeNode.ActiveNodes.Cast<FileSystemNode>().Select(n => n.FullPath).ToArray();
			data.SetData(typeof(string[]), paths);
			return data;
		}

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            //Cast
            var node = (ILSpyTreeNode)selectedNodes[0];

            //Checks if the selected node is an assembly
            if (node is AssemblyTreeNode)
            {
                //Forces lazy-loading
                node.EnsureLazyChildren();

                //Checks if it's a multi-module assembly
                if (node.Children.Count > 1)
                {
                    MessageBox.Show("In a multi-module assembly select a specific module", "Select module", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                //Takes the first (and only) module
                node = (ILSpyTreeNode)node.Children[0];
            }

            //Shows the injection window
            new Injection.InjectWindow(node, 0, new InjectExistingEntry().IsVisible(selectedNodes)).ShowDialog();
        }

		public override void DeleteCore(SharpTreeNode[] nodes)
		{
			foreach (var node in nodes.ToArray())
			{
				node.Parent.Children.Remove(node);
			}
		}

		public override void Delete(SharpTreeNode[] nodes)
		{
			if (MessageBox.Show("Sure?", "Delete", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
			{
				DeleteCore(nodes);
			}
		}

		public void Execute(SharpTreeNode[] selectedNodes)
		{
			// TODO: figure out when equivalent nodes are already present
			// and focus those instead.
			foreach (IMemberTreeNode node in selectedNodes) {
				Analyze(node.Member);
			}
		}

		public bool IsEnabled(SharpTreeNode[] selectedNodes)
		{
			foreach (IMemberTreeNode node in selectedNodes) {
				if (!(node.Member is FieldDefinition || node.Member is MethodDefinition))
					return false;
			}
			return true;
		}

 public TreeFlattener(SharpTreeNode modelRoot, bool includeRoot)
 {
     this.root = modelRoot;
     while (root.listParent != null)
         root = root.listParent;
     root.treeFlattener = this;
     this.includeRoot = includeRoot;
 }

        protected override IMetadataTokenProvider ImportCore(MemberImportingOptions options, SharpTreeNode node)
        {
            //Checks that the task hasn't been canceled
            options.CancellationToken.ThrowIfCancellationRequested();

            //Imports and returns
            return Session.DestinationModule.Import((TypeReference)Member);
        }

 void Insert(int index, SharpTreeNode node)
 {
     List.Insert(index, node);
     node.PropertyChanged += node_PropertyChanged;
     if (node.IsExpanded) {
         node.Children.CollectionChanged += node_ChildrenChanged;
     }
 }

        public SharpTreeNode GoForward(SharpTreeNode oldNode)
        {
            if (oldNode != null)
                back.Add(oldNode);

            SharpTreeNode node = forward[forward.Count - 1];
            forward.RemoveAt(forward.Count - 1);
            return node;
        }

        public SharpTreeNode GoBack(SharpTreeNode oldNode)
        {
            if (oldNode != null)
                forward.Add(oldNode);

            SharpTreeNode node = back[back.Count - 1];
            back.RemoveAt(back.Count - 1);
            return node;
        }

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var types = selectedNodes
                .OfType<TypeTreeNode>()
                .Select(n => HAL.Converter.Type(n.TypeDefinition))
                .ToArray();

            Services.BrowseInteractions(types, true);
        }

		protected override bool IsVisible(SharpTreeNode node)
		{
			return node is EventTreeNode
			       || node is FieldTreeNode
			       || node is MethodTreeNode
			       || node is PropertyTreeNode
			       || node is TypeTreeNode
				   || node is AssemblyReferenceTreeNode
			       || node is ResourceTreeNode;
		}

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var assemblyDefinitions = selectedNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition)
                .ToList();

            var window = WindowManager.AssemblyBrowsers.Single();
            window.ViewModel.AddAssemblies(assemblyDefinitions);
        }

		protected override IDataObject GetDataObject(SharpTreeNode[] nodes)
		{
			string[] data = nodes
				.OfType<XamlOutlineNode>()
				.Select(item => item.GetMarkupText())
				.ToArray();
			var dataObject = new DataObject();
			dataObject.SetData(typeof(string[]), data);
			
			return dataObject;
		}

		public bool IsEnabled(SharpTreeNode[] selectedNodes)
		{
			foreach (IMemberTreeNode node in selectedNodes) {
				if (!(node.Member is FieldDefinition
					|| node.Member is MethodDefinition
					|| Analyzer.AnalyzedPropertyTreeNode.CanShow(node.Member)
					|| Analyzer.AnalyzedEventTreeNode.CanShow(node.Member)))
					return false;
			}
			return true;
		}

		internal static bool ActivateItem(SharpTreeNode node, TypeDefinition def)
		{
			if (def != null) {
				var assemblyListNode = node.Ancestors().OfType<AssemblyListTreeNode>().FirstOrDefault();
				if (assemblyListNode != null) {
					assemblyListNode.Select(assemblyListNode.FindTypeNode(def));
					return true;
				}
			}
			return false;
		}

        public void Execute(SharpTreeNode[] selectedNodes)
        {
            var assemblyDefinitions = selectedNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition);

            var window = new DependencyBrowserWindow(assemblyDefinitions.Select(HAL.Converter.Assembly))
            {
                Owner = Services.MainWindow
            };
            window.Show();
        }