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();
}
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;
}
}
}
void ClearDescendants(SharpTreeNode node)
{
var index = List.IndexOf(node);
while (index + 1 < List.Count && List[index + 1].Level > node.Level) {
RemoveAt(index + 1);
}
}
public override void Delete(SharpTreeNode[] nodes)
{
if (MessageBox.Show("Sure?", "Delete", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
{
DeleteCore(nodes);
}
}
public override void DeleteCore(SharpTreeNode[] nodes)
{
foreach (var node in nodes.ToArray())
{
node.Parent.Children.Remove(node);
}
}
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;
}
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);
}
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;
}
void Insert(int index, SharpTreeNode node)
{
List.Insert(index, node);
node.PropertyChanged += node_PropertyChanged;
if (node.IsExpanded) {
node.Children.CollectionChanged += node_ChildrenChanged;
}
}
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 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);
}
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 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 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;
}
private void treeView_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
{
if ((bool)e.NewValue == true && scrollToNodeOnTreeViewVisible != null)
{
treeView.FocusNode(scrollToNodeOnTreeViewVisible);
treeView.ScrollIntoView(scrollToNodeOnTreeViewVisible);
scrollToNodeOnTreeViewVisible = null;
}
}
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;
}
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 void Execute(SharpTreeNode[] selectedNodes)
{
var typeDefinition = selectedNodes
.OfType<TypeTreeNode>()
.Single().TypeDefinition;
var window = new AncestryBrowserWindow(typeDefinition)
{
Owner = MainWindow.Instance
};
window.Show();
}
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();
}
public bool IsVisible(SharpTreeNode[] selectedNodes)
{
var memberNode = selectedNodes[0] as IMemberTreeNode;
var nodeType = selectedNodes[0].GetType();
return
(
AllowedNodeTypes.Any(x => x.IsAssignableFrom(nodeType)) ||
(memberNode != null && memberNode.Member.MetadataToken.TokenType == Mono.Cecil.TokenType.TypeDef)
)
&&
!(selectedNodes[0] is ICSharpCode.ILSpy.TreeNodes.Analyzer.AnalyzerTreeNode);
}
void UpdateDataContext(SharpTreeNode oldNode, SharpTreeNode newNode)
{
if (newNode != null) {
newNode.PropertyChanged += Node_PropertyChanged;
if (Template != null) {
UpdateTemplate();
}
}
if (oldNode != null) {
oldNode.PropertyChanged -= Node_PropertyChanged;
}
}
public void Execute(SharpTreeNode[] selectedNodes)
{
// TODO: figure out when equivalent nodes are already present
// and focus those instead.
foreach (IMemberTreeNode node in selectedNodes) {
FieldDefinition field = node.Member as FieldDefinition;
if (field != null)
MainWindow.Instance.AddToAnalyzer(new AnalyzedFieldNode(field));
MethodDefinition method = node.Member as MethodDefinition;
if (method != null)
MainWindow.Instance.AddToAnalyzer(new AnalyzedMethodTreeNode(method));
}
}
public void Execute(SharpTreeNode[] selectedNodes)
{
AssemblyTreeNode node = (AssemblyTreeNode)selectedNodes[0];
AssemblyDefinition asm = node.LoadedAssembly.AssemblyDefinition as AssemblyDefinition;
if (asm != null) {
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = node.LoadedAssembly.FileName;
dlg.Filter = "Assembly|*.dll;*.exe";
if (dlg.ShowDialog(MainWindow.Instance) == true) {
asm.MainModule.Write(dlg.FileName);
}
}
}
protected override IMetadataTokenProvider ImportCore(MemberImportingOptions options, SharpTreeNode node)
{
//Checks that the task hasn't been canceled
options.CancellationToken.ThrowIfCancellationRequested();
//Adds the field to the destination type
((TypeDefinition)Destination).Fields.Add(fieldClone);
if (_createNode)
node.AddChildAndColorAncestors(new ILEditTreeNode(fieldClone, false));
//Returns the new field
return fieldClone;
}
static DnSpyFile GetDnSpyFile(SharpTreeNode node) {
var asmNode = node as AssemblyTreeNode;
if (asmNode == null)
return null;
var module = asmNode.DnSpyFile.ModuleDef as ModuleDefMD;
if (module == null)
return null;
if (!module.MetaData.PEImage.IsMemoryMappedIO)
return null;
return asmNode.DnSpyFile;
}
public void Execute(SharpTreeNode[] selectedNodes)
{
var types = selectedNodes
.OfType<TypeTreeNode>()
.Select(n => HAL.Converter.Type(n.TypeDefinition))
.ToArray();
var window = new InteractionBrowserWindow(types, true)
{
Owner = MainWindow.Instance
};
window.Show();
}
public void Execute(SharpTreeNode[] selectedNodes)
{
var assemblyDefinitions = selectedNodes
.OfType<AssemblyTreeNode>()
.Select(n => n.LoadedAssembly.AssemblyDefinition)
.ToList();
var window = new AssemblyBrowserWindow(assemblyDefinitions)
{
Owner = MainWindow.Instance
};
window.Show();
}
/// <summary>
/// Balances the subtree rooted in <paramref name="node"/> and recomputes the 'height' field.
/// This method assumes that the children of this node are already balanced and have an up-to-date 'height' value.
/// </summary>
/// <returns>The new root node</returns>
private static SharpTreeNode Rebalance(SharpTreeNode node)
{
Debug.Assert(node.left == null || Math.Abs(node.left.Balance) <= 1);
Debug.Assert(node.right == null || Math.Abs(node.right.Balance) <= 1);
// Keep looping until it's balanced. Not sure if this is stricly required; this is based on
// the Rope code where node merging made this necessary.
while (Math.Abs(node.Balance) > 1)
{
// AVL balancing
// note: because we don't care about the identity of concat nodes, this works a little different than usual
// tree rotations: in our implementation, the "this" node will stay at the top, only its children are rearranged
if (node.Balance > 1)
{
if (node.right.Balance < 0)
{
node.right = node.right.RotateRight();
}
node = node.RotateLeft();
// If 'node' was unbalanced by more than 2, we've shifted some of the inbalance to the left node; so rebalance that.
node.left = Rebalance(node.left);
}
else if (node.Balance < -1)
{
if (node.left.Balance > 0)
{
node.left = node.left.RotateLeft();
}
node = node.RotateRight();
// If 'node' was unbalanced by more than 2, we've shifted some of the inbalance to the right node; so rebalance that.
node.right = Rebalance(node.right);
}
}
Debug.Assert(Math.Abs(node.Balance) <= 1);
node.height = (byte)(1 + Math.Max(Height(node.left), Height(node.right)));
node.totalListLength = -1; // mark for recalculation
// since balancing checks the whole tree up to the root, the whole path will get marked as invalid
return(node);
}
public int IndexOf(object item)
{
SharpTreeNode node = item as SharpTreeNode;
if (node != null && node.IsVisible && node.GetListRoot() == root)
{
if (includeRoot)
{
return(SharpTreeNode.GetVisibleIndexForNode(node));
}
else
{
return(SharpTreeNode.GetVisibleIndexForNode(node) - 1);
}
}
else
{
return(-1);
}
}
private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName != "IsExpanded")
{
return;
}
SharpTreeNode node = sender as SharpTreeNode;
if (node == null || node.Children.Count == 0)
{
return;
}
bool newValue = node.IsExpanded;
bool oldValue = !newValue;
RaisePropertyChangedEvent(
ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty,
oldValue ? ExpandCollapseState.Expanded : ExpandCollapseState.Collapsed,
newValue ? ExpandCollapseState.Expanded : ExpandCollapseState.Collapsed);
}
void UpdateAdaptor(SharpTreeNode node)
{
if (nodeView == null)
{
return;
}
var doAdaptor = nodeView.DataContext as SharpTreeNodeProxy;
if (doAdaptor == null)
{
nodeView.DataContext = (doAdaptor = new SharpTreeNodeProxy(node));
}
else
{
doAdaptor.UpdateObject(node);
}
nodeView.UpdateTemplate();
}
internal static int GetVisibleIndexForNode(SharpTreeNode node)
{
int index = node.left != null?node.left.GetTotalListLength() : 0;
while (node.listParent != null)
{
if (node == node.listParent.right)
{
if (node.listParent.left != null)
{
index += node.listParent.left.GetTotalListLength();
}
if (node.listParent.isVisible)
{
index++;
}
}
node = node.listParent;
}
return(index);
}
public object this[int index] {
get {
if (index < 0 || index >= this.Count)
{
throw new ArgumentOutOfRangeException();
}
SharpTreeNode node;
if (nodeCache.TryGetValue(index, out node))
{
return(node);
}
node = SharpTreeNode.GetNodeByVisibleIndex(root, includeRoot ? index : index + 1);
nodeCache[index] = node;
return(node);
}
set {
throw new NotSupportedException();
}
}
static void InsertNodeAfter(SharpTreeNode pos, SharpTreeNode newNode)
{
// newNode might be the model root of a whole subtree, so go to the list root of that subtree:
newNode = newNode.GetListRoot();
if (pos.right == null)
{
pos.right = newNode;
newNode.listParent = pos;
}
else
{
// insert before pos.right's leftmost:
pos = pos.right;
while (pos.left != null)
{
pos = pos.left;
}
Debug.Assert(pos.left == null);
pos.left = newNode;
newNode.listParent = pos;
}
RebalanceUntilRoot(pos);
}
SharpTreeNode Successor()
{
if (right != null)
{
SharpTreeNode node = right;
while (node.left != null)
{
node = node.left;
}
return(node);
}
else
{
SharpTreeNode node = this;
SharpTreeNode oldNode;
do
{
oldNode = node;
node = node.listParent;
// loop while we are on the way up from the right part
} while (node != null && node.right == oldNode);
return(node);
}
}
SharpTreeNode RotateRight()
{
/* Rotate tree to the right
*
* this left
* / \ / \
* left C ===> A this
* / \ / \
* A B B C
*/
SharpTreeNode b = left.right;
SharpTreeNode newTop = left;
if (b != null)
{
b.listParent = this;
}
this.left = b;
newTop.right = this;
newTop.listParent = this.listParent;
this.listParent = newTop;
newTop.right = Rebalance(this);
return(newTop);
}
public void UpdateObject(SharpTreeNode obj)
{
if (Object == obj)
{
return;
}
if (Object != null)
{
Object.PropertyChanged -= OnPropertyChanged;
}
var oldNode = Object;
Object = obj;
if (obj == null)
{
IsNull = true;
}
else
{
IsNull = false;
obj.PropertyChanged += OnPropertyChanged;
foreach (var desc in descMap)
{
desc.Value.OnValueChanged(this);
}
}
if (ObjectChanged != null)
{
ObjectChanged(this, new ObjectChangedEventArgs(oldNode, obj));
}
}
/// <summary>
/// Handles the node expanding event in the tree view.
/// This method gets called only if the node is in the visible region (a SharpTreeNodeView exists).
/// </summary>
internal void HandleExpanding(SharpTreeNode node)
{
if (doNotScrollOnExpanding)
{
return;
}
// TODO: make sure node is materialized
return;
SharpTreeNode lastVisibleChild = node;
while (true)
{
SharpTreeNode tmp = lastVisibleChild.Children.LastOrDefault(c => c.IsVisible);
if (tmp != null)
{
lastVisibleChild = tmp;
}
else
{
break;
}
}
if (lastVisibleChild != node)
{
// Make the the expanded children are visible; but don't scroll down
// to much (keep node itself visible)
base.ScrollIntoView(lastVisibleChild);
// For some reason, this only works properly when delaying it...
Dispatcher.UIThread.InvokeAsync(new Action(
delegate {
base.ScrollIntoView(node);
}), DispatcherPriority.Loaded);
}
}
void Add(SharpTreeNode node)
{
Insert(List.Count, node);
}
static void DumpTree(SharpTreeNode node)
{
node.GetListRoot().DumpTree();
}
static int Height(SharpTreeNode node)
{
return(node != null ? node.height : 0);
}
public TreeFlattener(SharpTreeNode root, bool includeRoot)
{
this.root = root;
this.includeRoot = includeRoot;
List = new ObservableCollection <SharpTreeNode>();
}
public SharpTreeNodeProxy(SharpTreeNode obj)
{
UpdateObject(obj);
}
public ObjectChangedEventArgs(SharpTreeNode oldNode, SharpTreeNode newNode)
{
OldNode = oldNode;
NewNode = newNode;
}
private void UpdateIsVisible(bool parentIsVisible, bool updateFlattener)
{
bool newIsVisible = parentIsVisible && !this.isHidden;
if (this.isVisible != newIsVisible)
{
this.isVisible = newIsVisible;
// invalidate the augmented data
SharpTreeNode node = this;
while (node != null && node.totalListLength >= 0)
{
node.totalListLength = -1;
node = node.listParent;
}
// Remember the removed nodes:
List <SharpTreeNode> removedNodes = null;
if (updateFlattener && !newIsVisible)
{
removedNodes = this.VisibleDescendantsAndSelf().ToList();
}
// also update the model children:
this.UpdateChildIsVisible(false);
// Validate our invariants:
if (updateFlattener)
{
this.CheckRootInvariants();
}
// Tell the flattener about the removed nodes:
if (removedNodes != null)
{
var flattener = this.GetListRoot().treeFlattener;
if (flattener != null)
{
flattener.NodesRemoved(GetVisibleIndexForNode(this), removedNodes);
foreach (var n in removedNodes)
{
n.OnIsVisibleChanged();
}
}
}
// Tell the flattener about the new nodes:
if (updateFlattener && newIsVisible)
{
var flattener = this.GetListRoot().treeFlattener;
if (flattener != null)
{
flattener.NodesInserted(GetVisibleIndexForNode(this), this.VisibleDescendantsAndSelf());
foreach (var n in this.VisibleDescendantsAndSelf())
{
n.OnIsVisibleChanged();
}
}
}
}
}
internal protected virtual void OnChildrenChanged(NotifyCollectionChangedEventArgs e)
{
if (e.OldItems != null)
{
foreach (SharpTreeNode node in e.OldItems)
{
Debug.Assert(node.modelParent == this);
node.modelParent = null;
Debug.WriteLine("Removing {0} from {1}", node, this);
SharpTreeNode removeEnd = node;
while (removeEnd.modelChildren != null && removeEnd.modelChildren.Count > 0)
{
removeEnd = removeEnd.modelChildren.Last();
}
List <SharpTreeNode> removedNodes = null;
int visibleIndexOfRemoval = 0;
if (node.isVisible)
{
visibleIndexOfRemoval = GetVisibleIndexForNode(node);
removedNodes = node.VisibleDescendantsAndSelf().ToList();
}
RemoveNodes(node, removeEnd);
if (removedNodes != null)
{
var flattener = GetListRoot().treeFlattener;
if (flattener != null)
{
flattener.NodesRemoved(visibleIndexOfRemoval, removedNodes);
}
}
}
}
if (e.NewItems != null)
{
SharpTreeNode insertionPos;
if (e.NewStartingIndex == 0)
{
insertionPos = null;
}
else
{
insertionPos = modelChildren[e.NewStartingIndex - 1];
}
foreach (SharpTreeNode node in e.NewItems)
{
Debug.Assert(node.modelParent == null);
node.modelParent = this;
node.UpdateIsVisible(isVisible && isExpanded, false);
//Debug.WriteLine("Inserting {0} after {1}", node, insertionPos);
while (insertionPos != null && insertionPos.modelChildren != null && insertionPos.modelChildren.Count > 0)
{
insertionPos = insertionPos.modelChildren.Last();
}
InsertNodeAfter(insertionPos ?? this, node);
insertionPos = node;
if (node.isVisible)
{
var flattener = GetListRoot().treeFlattener;
if (flattener != null)
{
flattener.NodesInserted(GetVisibleIndexForNode(node), node.VisibleDescendantsAndSelf());
}
}
}
}
RaisePropertyChanged(nameof(ShowExpander));
RaiseIsLastChangedIfNeeded(e);
}
private static void DeleteNode(SharpTreeNode node)
{
SharpTreeNode balancingNode;
if (node.left == null)
{
balancingNode = node.listParent;
node.ReplaceWith(node.right);
node.right = null;
}
else if (node.right == null)
{
balancingNode = node.listParent;
node.ReplaceWith(node.left);
node.left = null;
}
else
{
SharpTreeNode tmp = node.right;
while (tmp.left != null)
{
tmp = tmp.left;
}
// First replace tmp with tmp.right
balancingNode = tmp.listParent;
tmp.ReplaceWith(tmp.right);
tmp.right = null;
Debug.Assert(tmp.left == null);
Debug.Assert(tmp.listParent == null);
// Now move node's children to tmp:
tmp.left = node.left;
node.left = null;
tmp.right = node.right;
node.right = null;
if (tmp.left != null)
{
tmp.left.listParent = tmp;
}
if (tmp.right != null)
{
tmp.right.listParent = tmp;
}
// Then replace node with tmp
node.ReplaceWith(tmp);
if (balancingNode == node)
{
balancingNode = tmp;
}
}
Debug.Assert(node.listParent == null);
Debug.Assert(node.left == null);
Debug.Assert(node.right == null);
node.height = 1;
node.totalListLength = -1;
if (balancingNode != null)
{
RebalanceUntilRoot(balancingNode);
}
}