// Adds the assemblies that are initially loaded with the
// component inspector code
public static void AddCurrentAssemblies()
{
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
// Don't add the current assembly
if (!(LocalPrefs.Get(LocalPrefs.DEV) != null))
{
if (assembly.Equals(Assembly.GetCallingAssembly()))
{
continue;
}
}
// Skip the dynamically created assembly used by the
// internal dynamic classes
if (assembly.GetName().Name.Equals(AssemblySupport.DUMMY_ASSY_NAME))
{
continue;
}
try {
AssemblyTreeNode node = AddAssy(assembly, null);
// Don't allow close since these are always loaded
// automatically
node.NoClose = true;
} catch (Exception ex) {
TraceUtil.WriteLineWarning(null, "Error adding local assembly: "
+ assembly + ": " + ex);
}
}
}
internal static void OpenFile(String fileName)
{
// Keep track if the assembly was actually loaded, if
// not then it must already be loaded, so handle adding
// it to the tree.
_assyLoadedNode = null;
LoadAssembly(fileName);
if (_assyLoadedNode == null)
{
Assembly assy = Assembly.LoadFrom(fileName);
if (assy.Equals(Assembly.GetExecutingAssembly()))
{
throw new Exception("You may not inspect the Component Inspector");
}
// Already loaded
_assyLoadedNode = FindAssemblyNode(assy);
if (_assyLoadedNode == null)
{
AssemblyTreeNode node = AddAssy(assy, null);
RememberAssembly(assy, null, null);
_assyLoadedNode = node;
}
}
// Make sure this node is presented and selected
SelectAssyTab();
_assyLoadedNode.PointToNode();
}
public ModuleState(CorModuleDefFile corModuleDefFile, AssemblyTreeNode moduleNode, HashSet <uint> modifiedTypes, HashSet <uint> loadClassHash)
{
this.CorModuleDefFile = corModuleDefFile;
this.ModuleNode = moduleNode;
this.ModifiedTypes = modifiedTypes;
this.LoadClassHash = loadClassHash;
}
public void Execute(SharpTreeNode[] selectedNodes)
{
if (!CurrentDebugger.IsDebugging)
{
AssemblyTreeNode n = selectedNodes[0] as AssemblyTreeNode;
var settings = ILSpySettings.Load();
XElement e = settings["DebuggerSettings"];
var askForArguments = (bool?)e.Attribute("askForArguments");
if (askForArguments.HasValue && askForArguments.Value)
{
var window = new ExecuteProcessWindow {
Owner = MainWindow.Instance,
SelectedExecutable = n.LoadedAssembly.FileName
};
if (window.ShowDialog() == true)
{
string fileName = window.SelectedExecutable;
// execute the process
this.StartExecutable(fileName, window.WorkingDirectory, window.Arguments);
}
}
else
{
this.StartExecutable(n.LoadedAssembly.FileName, null, null);
}
}
}
void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args)
{
if (args.NavigateTo != null)
{
bool found = false;
if (args.NavigateTo.StartsWith("N:", StringComparison.Ordinal))
{
string namespaceName = args.NavigateTo.Substring(2);
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm);
if (asmNode != null)
{
NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName);
if (nsNode != null)
{
found = true;
SelectNode(nsNode);
break;
}
}
}
}
else
{
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
ModuleDefinition def = asm.GetModuleDefinitionOrNull();
if (def != null)
{
MemberReference mr = XmlDocKeyProvider.FindMemberByKey(def, args.NavigateTo);
if (mr != null)
{
found = true;
JumpToReference(mr);
break;
}
}
}
}
if (!found)
{
AvalonEditTextOutput output = new AvalonEditTextOutput();
output.Write(string.Format("Cannot find '{0}' in command line specified assemblies.", args.NavigateTo));
decompilerTextView.ShowText(output);
}
}
else if (commandLineLoadedAssemblies.Count == 1)
{
// NavigateTo == null and an assembly was given on the command-line:
// Select the newly loaded assembly
JumpToReference(commandLineLoadedAssemblies[0].GetModuleDefinitionOrNull());
}
if (args.Search != null)
{
SearchPane.Instance.SearchTerm = args.Search;
SearchPane.Instance.Show();
}
commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore
}
public void Execute(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return;
}
if (!CurrentDebugger.IsDebugging)
{
AssemblyTreeNode n = context.SelectedTreeNodes[0] as AssemblyTreeNode;
if (DebuggerSettings.Instance.AskForArguments)
{
var window = new ExecuteProcessWindow {
Owner = MainWindow.Instance,
SelectedExecutable = n.LoadedAssembly.FileName
};
if (window.ShowDialog() == true)
{
string fileName = window.SelectedExecutable;
// execute the process
this.StartExecutable(fileName, window.WorkingDirectory, window.Arguments);
}
}
else
{
this.StartExecutable(n.LoadedAssembly.FileName, null, null);
}
}
}
public void Execute(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return;
}
AssemblyTreeNode node = (AssemblyTreeNode)context.SelectedTreeNodes[0];
AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(node.LoadedAssembly.FileName);
ModuleDefinition module = asm.MainModule;
string assemblyPath = Path.GetDirectoryName(node.LoadedAssembly.FileName);
foreach (var resource in module.Resources)
{
if (!resource.Name.StartsWith("costura.") && !resource.Name.EndsWith(".dll.compressed"))
{
continue;
}
string fileName = assemblyPath + "/" + resource.Name.Substring(8, resource.Name.LastIndexOf(".compressed") - 8);
if (File.Exists(fileName))
{
// Assembly has already been decompressed and saved in the local path, just load it.
MainWindow.Instance.CurrentAssemblyList.OpenAssembly(fileName);
}
else
{
EmbeddedResource er = resource as EmbeddedResource;
MemoryStream memoryStream = DecompressEmbeddedAssembly(er.GetResourceStream());
WriteAssemblyToFile(memoryStream, fileName);
OpenAssemblyFromStream(memoryStream, fileName);
}
}
}
public void Execute(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return;
}
AssemblyTreeNode node = (AssemblyTreeNode)context.SelectedTreeNodes[0];
AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(node.LoadedAssembly.FileName);
ModuleDefinition module = asm.MainModule;
foreach (var type in module.Types)
{
if (type.FullName == "<Module>")
{
foreach (var method in type.Methods)
{
if (method.Name == ".cctor")
{
ClearAttachCallFromMethod(method);
}
}
}
}
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = node.LoadedAssembly.FileName;
dlg.Filter = "Assembly|*.dll;*.exe";
if (dlg.ShowDialog() == DialogResult.OK)
{
asm.MainModule.Write(dlg.FileName);
module.Write(dlg.FileName);
}
}
void SearchAssemblyInternal(AssemblyTreeNode asmNode) {
if (asmNode == null)
return;
var res = filter.GetFilterResult(asmNode.LoadedAssembly, AssemblyFilterType.Assembly);
if (res.FilterResult == FilterResult.Hidden)
return;
if (res.IsMatch && IsMatch(asmNode.LoadedAssembly.AssemblyDefinition.FullName, asmNode.LoadedAssembly)) {
onMatch(new SearchResult {
Language = language,
Object = asmNode,
NameObject = asmNode.LoadedAssembly.AssemblyDefinition,
TypeImageInfo = GetAssemblyImage(asmNode.LoadedAssembly.ModuleDefinition),
LocationObject = null,
LocationImageInfo = new ImageInfo(),
LoadedAssembly = asmNode.LoadedAssembly,
});
}
Debug.Assert(!asmNode.LazyLoading);
if (asmNode.LazyLoading)
throw new InvalidOperationException("Assembly's children haven't been loaded yet. Load them in the UI thread.");
foreach (AssemblyTreeNode modNode in asmNode.Children) {
cancellationToken.ThrowIfCancellationRequested();
SearchModule(modNode.LoadedAssembly);
}
}
internal static void CloseAssembly(AssemblyTreeNode node)
{
CloseAssembly(node.Assembly);
if (node.TypeLib != null)
{
node.TypeLib.Close();
}
}
public void Dispose()
{
if (asmNode != null)
{
MainWindow.Instance.AssemblyListTreeNode.UnregisterCached(asmNode.LoadedAssembly);
}
asmNode = null;
}
public void Dispose()
{
if (asmNode != null)
{
MainWindow.Instance.DnSpyFileListTreeNode.UnregisterCached(asmNode.DnSpyFile);
}
asmNode = null;
}
internal static bool HasPENode(AssemblyTreeNode node)
{
if (node == null)
{
return(false);
}
// Currently only nodes loaded from files on disk have a PE node
return(node.DnSpyFile.PEImage != null && node.DnSpyFile.LoadedFromFile);
}
public DebugMetadataTreeNode(PEFile module, bool isEmbedded, MetadataReader provider, AssemblyTreeNode assemblyTreeNode)
{
this.module = module;
this.provider = provider;
this.assemblyTreeNode = assemblyTreeNode;
this.isEmbedded = isEmbedded;
this.Text = "Debug Metadata (" + (isEmbedded ? "Embedded" : "From portable PDB") + ")";
this.LazyLoading = true;
}
RemoveNetModuleFromAssemblyCommand(AssemblyTreeNode modNode)
{
this.asmNode = (AssemblyTreeNode)modNode.Parent;
Debug.Assert(this.asmNode != null);
this.modNode = modNode;
this.removeIndex = asmNode.Children.IndexOf(modNode);
Debug.Assert(this.removeIndex > 0);
Debug.Assert(asmNode.DnSpyFile.AssemblyDef != null &&
asmNode.DnSpyFile.AssemblyDef.Modules.IndexOf(modNode.DnSpyFile.ModuleDef) == this.removeIndex);
}
public TreeViewUpdater(CorModuleDefFile cmdf, AssemblyTreeNode node, HashSet <uint> modifiedTypes, HashSet <uint> loadedClassTokens)
{
Debug.Assert(node.DnSpyFile == cmdf);
this.CorModuleDefFile = cmdf;
this.ModuleNode = node;
this.modifiedTypes = new HashSet <uint>(modifiedTypes);
this.loadedClassTokens = loadedClassTokens;
this.checkedTypes = new HashSet <TypeDef>();
this.modNode = node;
}
public void Execute(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return;
}
AssemblyTreeNode n = context.SelectedTreeNodes[0] as AssemblyTreeNode;
DebuggerPlugin.Start(n.LoadedAssembly.FileName);
}
RemoveNetModuleFromAssemblyCommand(AssemblyTreeNode modNode)
{
this.asmNode = (AssemblyTreeNode)modNode.Parent;
Debug.Assert(this.asmNode != null);
this.modNode = modNode;
this.removeIndex = asmNode.Children.IndexOf(modNode);
Debug.Assert(this.removeIndex > 0);
Debug.Assert(asmNode.LoadedAssembly.AssemblyDefinition != null &&
asmNode.LoadedAssembly.AssemblyDefinition.Modules.IndexOf(modNode.LoadedAssembly.ModuleDefinition) == this.removeIndex);
}
AssemblySettingsCommand(AssemblyTreeNode asmNode, AssemblyOptions newOptions)
{
this.asmNode = asmNode;
this.newOptions = newOptions;
this.origOptions = new AssemblyOptions(asmNode.DnSpyFile.AssemblyDef);
if (newOptions.Name != origOptions.Name)
{
this.assemblyRefInfos = RefFinder.FindAssemblyRefsToThisModule(asmNode.DnSpyFile.ModuleDef).Where(a => AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(a, asmNode.DnSpyFile.AssemblyDef)).Select(a => new AssemblyRefInfo(a)).ToArray();
}
}
protected AddNetModuleToAssemblyCommand(AssemblyTreeNode asmNode, AssemblyTreeNode modNode, bool modNodeWasCreated)
{
if (asmNode.Parent is AssemblyTreeNode)
{
asmNode = (AssemblyTreeNode)asmNode.Parent;
}
Debug.Assert(!(asmNode.Parent is AssemblyTreeNode));
Debug.Assert(asmNode.IsAssembly);
this.asmNode = asmNode;
this.modNode = modNode;
this.modNodeWasCreated = modNodeWasCreated;
}
public bool IsVisible(SharpTreeNode[] selectedNodes)
{
return(selectedNodes.All(
delegate(SharpTreeNode n) {
AssemblyTreeNode a = n as AssemblyTreeNode;
if (a == null)
{
return false;
}
AssemblyDefinition asm = a.LoadedAssembly.AssemblyDefinition;
return asm != null && asm.EntryPoint != null;
}));
}
public bool IsVisible(TextViewContext context)
{
return(context.SelectedTreeNodes != null && context.SelectedTreeNodes.All(
delegate(SharpTreeNode n) {
AssemblyTreeNode a = n as AssemblyTreeNode;
if (a == null)
{
return false;
}
AssemblyDefinition asm = a.LoadedAssembly.AssemblyDefinition;
return asm != null && asm.EntryPoint != null;
}));
}
static IEnumerable <AssemblyTreeNode> GetAssemblyNodes(AssemblyTreeNode node)
{
if (!node.IsAssembly || node.Children.Count == 0)
{
yield return(node);
}
else
{
foreach (AssemblyTreeNode child in node.Children)
{
yield return(child);
}
}
}
void HandleCommandLineArgumentsAfterShowList(CommandLineArguments args)
{
if (args.NavigateTo != null)
{
bool found = false;
if (args.NavigateTo.StartsWith("N:", StringComparison.Ordinal))
{
string namespaceName = args.NavigateTo.Substring(2);
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
AssemblyTreeNode asmNode = assemblyListTreeNode.FindAssemblyNode(asm);
if (asmNode != null)
{
NamespaceTreeNode nsNode = asmNode.FindNamespaceNode(namespaceName);
if (nsNode != null)
{
found = true;
SelectNode(nsNode);
break;
}
}
}
}
else
{
foreach (LoadedAssembly asm in commandLineLoadedAssemblies)
{
AssemblyDefinition def = asm.AssemblyDefinition;
if (def != null)
{
MemberReference mr = XmlDocKeyProvider.FindMemberByKey(def.MainModule, args.NavigateTo);
if (mr != null)
{
found = true;
JumpToReference(mr);
break;
}
}
}
}
if (!found)
{
AvalonEditTextOutput output = new AvalonEditTextOutput();
output.Write("Cannot find " + args.NavigateTo);
decompilerTextView.ShowText(output);
}
}
commandLineLoadedAssemblies.Clear(); // clear references once we don't need them anymore
}
internal static AssemblyTreeNode FindAssemblyTreeNode(Assembly assy)
{
foreach (TreeNode node in _assyRootNode.LogicalNodes)
{
if (node is AssemblyTreeNode)
{
AssemblyTreeNode atNode = (AssemblyTreeNode)node;
if (assy.Equals(atNode.Assembly))
{
return(atNode);
}
}
}
return(null);
}
IEnumerable <TypeTreeNode> GetDefaultModuleTypes()
{
// Load assembly metadata
var loadedAssembly = LoadAssembly();
var assemblyDefinition = GetAssemblyDefinition(loadedAssembly);
var mainModule = assemblyDefinition.MainModule;
var assemblyTreeNode = new AssemblyTreeNode(loadedAssembly);
return(mainModule.Types.Where(t => t.Name != "<Module>")
.OrderBy(t => t.FullName)
.Select(type => new TypeTreeNode(type, assemblyTreeNode)));
}
public new bool IsVisible(TextViewContext context)
{
return(DebuggerService.CurrentDebugger != null && !DebuggerService.CurrentDebugger.IsDebugging &&
context.SelectedTreeNodes != null && context.SelectedTreeNodes.Length > 0 &&
context.SelectedTreeNodes.All(
delegate(SharpTreeNode n) {
AssemblyTreeNode a = n as AssemblyTreeNode;
if (a == null)
{
return false;
}
AssemblyDef asm = a.LoadedAssembly.AssemblyDefinition;
return asm != null && asm.ManifestModule != null && (asm.ManifestModule.ManagedEntryPoint != null || asm.ManifestModule.NativeEntryPoint != 0);
}));
}
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);
}
}
}
/// <summary>
/// Returns the ancestor of type AssemblyTreeNode of the given node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static AssemblyTreeNode GetAssemblyNode(SharpTreeNode node)
{
AssemblyTreeNode moduleNode = null;
SharpTreeNode currentNode = node;
while (moduleNode == null)
{
if (currentNode.Parent == null)
{
break;
}
currentNode = currentNode.Parent;
moduleNode = currentNode as AssemblyTreeNode;
}
return(moduleNode);
}
public NamespaceTreeNodeCreator(string ns, AssemblyTreeNode asmNode)
{
Debug.Assert(asmNode.IsModule);
if (!asmNode.IsModule)
{
throw new InvalidOperationException();
}
this.asmNode = asmNode;
this.nsNode = asmNode.FindNamespaceNode(ns);
if (this.nsNode == null)
{
this.nsNode = new NamespaceTreeNode(ns);
this.nsNodeCreated = true;
}
}
static int Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("usage: decompiler [dll] [output path]");
return 2;
}
var assemblies = new AssemblyList("global");
var assembly = assemblies.OpenAssembly(args[0]);
assembly.WaitUntilLoaded();
var root = new AssemblyTreeNode(assembly);
root.Decompile(new CSharpLanguage(), new PlainTextOutput(), new DecompilationOptions
{
SaveAsProjectDirectory = args[1],
FullDecompilation = true,
DecompilerSettings = new DecompilerSettings
{
YieldReturn = false
}
});
return 0;
}
public TypeTreeNode(TypeDefinition type, AssemblyTreeNode parentAssemblyNode)
{
if (parentAssemblyNode == null)
throw new ArgumentNullException("parentAssemblyNode");
if (type == null)
throw new ArgumentNullException("type");
this.type = type;
this.parentAssemblyNode = parentAssemblyNode;
}
private static TreeNode GetNamespaceNode(AssemblyTreeNode asmNode, TypedefEntry iClass)
{
var names = Types.GetNamespaceChain(iClass.Name);
TreeNode parentNode = asmNode;
for (var i = 0; i < names.Length - 1; ++i)
{
var nextNode = FindNamespaceNode(parentNode.Nodes, names[i]);
if (nextNode == null)
{
nextNode = new NamespaceTreeNode(asmNode.Assembly, names[i])
{
NamespacePath = string.Join(".", names, 0, i + 1)
};
parentNode.Nodes.Add(nextNode);
}
parentNode = nextNode;
}
return parentNode;
}
void OnReportOpened(object sender, EventArgs e)
{
BeginUpdate();
var report = serviceContainer.getService<IReportService>().Report;
foreach (var assembly in report.Assemblies)
{
var asmNode = new AssemblyTreeNode(assembly);
Nodes.Add(asmNode);
foreach (var dType in assembly.Types)
{
var namespaceNode = GetNamespaceNode(asmNode, dType);
var classNode = new ClassTreeNode(dType);
namespaceNode.Nodes.Add(classNode);
var props = new Dictionary<string, PropertyTreeNode>();
foreach (var md in dType.Methods)
{
if (!Methods.IsSpecial(md.Flags))
{
AddMethodTreeNode(classNode, md);
continue;
}
//has special meaning
var mdSpecial = Methods.GetMdSpecial(md.Name);
if (mdSpecial == MdSpecial.Unknown)
{
AddMethodTreeNode(classNode, md);
continue;
}
var propName = Methods.GetMdSpecialName(md.Name);
PropertyTreeNode propertyNode;
if (!props.TryGetValue(propName, out propertyNode))
{
propertyNode = new PropertyTreeNode(propName);
props[propName] = propertyNode;
classNode.Nodes.Add(propertyNode);
}
var mdNode = new MethodTreeNode(md)
{
//MethodName = mdSpecial.ToString().ToLowerInvariant()
};
switch (mdSpecial)
{
case MdSpecial.Get:
mdNode.ImageIndex = ImageSelector.ForPropertyGet(md);
mdNode.SelectedImageIndex = ImageSelector.ForPropertyGet(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Remove:
mdNode.ImageIndex = ImageSelector.ForEventRemove(md);
mdNode.SelectedImageIndex = ImageSelector.ForEventRemove(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Set:
mdNode.ImageIndex = ImageSelector.ForPropertySet(md);
mdNode.SelectedImageIndex = ImageSelector.ForPropertySet(md);
propertyNode.Setter = mdNode;
break;
case MdSpecial.Add:
mdNode.ImageIndex = ImageSelector.ForEventAdd(md);
mdNode.SelectedImageIndex = ImageSelector.ForEventAdd(md);
propertyNode.Setter = mdNode;
break;
}
}
foreach (var kv in props)
{
if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter);
if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter);
}
}
asmNode.UpdateCoverageInfo();
}
EndUpdate();
}
void onReportOpened(object sender, EventArgs e)
{
BeginUpdate();
ICoverageReport report = serviceContainer.GetService<ICoverageReportService>().Report;
foreach (IAssembly assembly in report.GetAssemblies())
{
AssemblyTreeNode asmNode = new AssemblyTreeNode(assembly);
Nodes.Add(asmNode);
foreach (IClass dType in assembly.GetTypes())
{
TreeNode namespaceNode = GetNamespaceNode(asmNode, dType);
ClassTreeNode classNode = new ClassTreeNode(dType);
namespaceNode.Nodes.Add(classNode);
Dictionary<string, PropertyTreeNode> props = new Dictionary<string, PropertyTreeNode>();
foreach (IMethod md in dType.GetMethods())
{
if (!Methods.isSpecial(md.Flags))
{
AddMethodTreeNode(classNode, md);
continue;
}
//has special meaning
MdSpecial mdSpecial = Methods.getMdSpecial(md.Name);
if (mdSpecial == MdSpecial.Unknown)
{
AddMethodTreeNode(classNode, md);
continue;
}
string propName = Methods.getMdSpecialName(md.Name);
PropertyTreeNode propertyNode;
if (!props.TryGetValue(propName, out propertyNode))
{
propertyNode = new PropertyTreeNode(propName);
props[propName] = propertyNode;
classNode.Nodes.Add(propertyNode);
}
MethodTreeNode mdNode = new MethodTreeNode(md);
mdNode.MethodName = mdSpecial.ToString().ToLowerInvariant();
switch (mdSpecial)
{
case MdSpecial.Get:
mdNode.ImageIndex = ImageSelector.forPropertyGet(md);
mdNode.SelectedImageIndex = ImageSelector.forPropertyGet(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Remove:
mdNode.ImageIndex = ImageSelector.forEventRemove(md);
mdNode.SelectedImageIndex = ImageSelector.forEventRemove(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Set:
mdNode.ImageIndex = ImageSelector.forPropertySet(md);
mdNode.SelectedImageIndex = ImageSelector.forPropertySet(md);
propertyNode.Setter = mdNode;
break;
case MdSpecial.Add:
mdNode.ImageIndex = ImageSelector.forEventAdd(md);
mdNode.SelectedImageIndex = ImageSelector.forEventAdd(md);
propertyNode.Setter = mdNode;
break;
}
}
foreach (KeyValuePair<string, PropertyTreeNode> kv in props)
{
if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter);
if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter);
}
}
asmNode.UpdateCoverageInfo();
}
EndUpdate();
}
