assemblytree.cs

SharpDevelop2.0.0 c#开发免费工具

// <file>
//     <copyright see="prj:///doc/copyright.txt"/>
//     <license see="prj:///doc/license.txt"/>
//     <owner name="Georg Brandl" email="[e-mail]"/>
//     <version value="$version"/>
// </file>

using System;
using System.Xml;
using System.Collections;
using System.IO;
using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;
using System.Threading;
using System.Resources;
using System.Text;

using Microsoft.Win32;
using System.Diagnostics;

using ICSharpCode.Core;
using ICSharpCode.SharpDevelop.Dom;
using ICSharpCode.SharpDevelop.Gui;
using ICSharpCode.SharpDevelop.Project;
using ICSharpCode.SharpDevelop.Internal.ExternalTool;
using SA = ICSharpCode.SharpAssembly.Assembly;

namespace ICSharpCode.SharpDevelop.AddIns.AssemblyScout
{
	public class AssemblyTree : TreeView
	{
		public static IAmbience CurrentAmbience = AmbienceService.CurrentAmbience;
				
		ArrayList assemblies = new ArrayList();
		AssemblyScoutViewContent _parent;
		
		public ShowOptions showInternalTypes, showInternalMembers;
		public ShowOptions showPrivateTypes, showPrivateMembers;
		
		public bool showSpecial = false;
		
		MenuItem mnuBack;
		MenuItem mnuLoadAsm, mnuLoadStd, mnuLoadRef;
		MenuItem mnuRemAsm, mnuCopyTree, mnuSaveRes, mnuJump, mnuOpenRef, mnuDisAsm;
		
		Stack history = new Stack();
		bool histback = false;
		
		AssemblyTreeNode selnode;
		
		public event EventHandler Changed;
		
		public AssemblyTree(AssemblyScoutViewContent parent) : base()
		{
			if (Changed != null) {} // only to prevent these pesky compiler warning :) M.K.
			
			Dock = DockStyle.Fill;
			
			string resPrefix = "ObjectBrowser.Menu.";
						
			this.ImageList = ClassBrowserIconService.ImageList;
			
			LabelEdit     = false;
			HotTracking   = false;
			AllowDrop     = true;
			HideSelection = false;
			
			mnuBack    = new MenuItem(StringParser.Parse("${res:" + resPrefix + "GoBack}"), new EventHandler(Back));
			mnuLoadAsm = new MenuItem(StringParser.Parse("${res:" + resPrefix + "LoadAssembly}"), new EventHandler(LoadAssembly));
			mnuLoadStd = new MenuItem(StringParser.Parse("${res:" + resPrefix + "LoadStd}"), new EventHandler(LoadStdAssemblies));
			mnuLoadRef = new MenuItem(StringParser.Parse("${res:" + resPrefix + "LoadRef}"), new EventHandler(LoadRefAssemblies));
			
			mnuRemAsm   = new MenuItem(StringParser.Parse("${res:" + resPrefix + "RemoveAsm}"), new EventHandler(RemoveAssembly));
			mnuCopyTree = new MenuItem(StringParser.Parse("${res:" + resPrefix + "CopyTree}"), new EventHandler(CopyAssemblyTree));
			mnuSaveRes  = new MenuItem(StringParser.Parse("${res:" + resPrefix + "SaveRes}"), new EventHandler(SaveCurrentResource));
			mnuJump     = new MenuItem(StringParser.Parse("${res:" + resPrefix + "JumpType}"), new EventHandler(JumpLink));
			mnuOpenRef  = new MenuItem(StringParser.Parse("${res:" + resPrefix + "OpenRef}"), new EventHandler(OpenReference));
			mnuDisAsm   = new MenuItem(StringParser.Parse("${res:" + resPrefix + "DisasmToFile}"), new EventHandler(DisAssembly));
			
			ContextMenu = new ContextMenu(new MenuItem[] {
				mnuBack,
				new MenuItem("-"),
				mnuLoadAsm,
				mnuLoadStd,
				mnuLoadRef,
				new MenuItem("-"),
				mnuRemAsm,
				mnuCopyTree,
				mnuSaveRes,
				mnuJump,
				mnuOpenRef,
				mnuDisAsm
			});
			
			showPrivateTypes    = (ShowOptions)PropertyService.Get("AddIns.AssemblyScout.privateTypesBox", 1);
			showInternalTypes   = (ShowOptions)PropertyService.Get("AddIns.AssemblyScout.internalTypesBox", 1);
			showPrivateMembers  = (ShowOptions)PropertyService.Get("AddIns.AssemblyScout.privateMembersBox", 1);
			showInternalMembers = (ShowOptions)PropertyService.Get("AddIns.AssemblyScout.internalMembersBox", 1);
			showSpecial = PropertyService.Get("AddIns.AssemblyScout.ShowSpecialMethods", false);
			
			_parent = parent;
		}
		
		public ArrayList Assemblies {
			get {
				return assemblies;
			}
		}
		
		public PrintDocument PrintDocument {
			get {
				return null;
			}
		}
		
		public bool WriteProtected {
			get {
				return false;
			}
			set {
			}
		}
		
		public void LoadFile(string fileName) 
		{
			AddAssembly(SA.SharpAssembly.LoadFrom(fileName));
		}
		
		public bool IsAssemblyLoaded(string filename)
		{
			try {
				foreach(SA.SharpAssembly asm in assemblies) {
					if (asm.Location == filename) return true;
				}
			} catch {
			}
			return false;
		}
		
		public void SaveFile(string filename)
		{
		}
		
		public void AddAssembly(SA.SharpAssembly assembly)
		{
			try {
				if (IsAssemblyLoaded(assembly.Location)) return;
				
				assemblies.Add(assembly);
				
				TreeNode node = new FolderNode(System.IO.Path.GetFileNameWithoutExtension(assembly.Location), assembly, NodeType.Assembly, 0, 1);
				Nodes.Add(node);
				PopulateTree((AssemblyTreeNode)node);
			} catch (Exception e) {
				MessageBox.Show("Could not load assembly: " + e.ToString());
			}
		}

		public void RePopulateTreeView()
		{
			foreach (AssemblyTreeNode node in Nodes) {
				node.Populate(showPrivateTypes, showInternalTypes);
				PopulateTree(node);
			}
		}
		
		public void PopulateTree(AssemblyTreeNode parentnode)
		{
			if (!parentnode.Populated)
				parentnode.Populate(showPrivateTypes, showInternalTypes);
			
			foreach (AssemblyTreeNode node in parentnode.Nodes) {
				if (!node.Populated) {
					node.Populate(showPrivateTypes, showInternalTypes);
				}
				PopulateTree(node);
			}
		}
		
		public void GoToMember(IMember member) 
		{
			string paramtext = "";
			SharpAssemblyClass declaringType = member.DeclaringType as SharpAssemblyClass;
			TypeNode typenode = GetTypeNode((SA.SharpAssembly)declaringType.DeclaredIn, declaringType.Namespace, declaringType.FullyQualifiedName);
			if (typenode == null) return;
			
			bool isEnum = false;
			if (member.DeclaringType != null && member.DeclaringType.ClassType == ClassType.Enum) isEnum = true;
			
			paramtext = MemberNode.GetShortMemberName(member, isEnum);
			
			if (!typenode.MembersPopulated) {
				typenode.PopulateMembers(showPrivateMembers, showInternalMembers, showSpecial);
			}
			
			TreeNode foundnode = typenode.GetNodeFromChildren(paramtext);
			if (foundnode == null) return;
			
			foundnode.EnsureVisible();
			SelectedNode = foundnode;
		}
		
		public void GoToNamespace(SA.SharpAssembly asm, string name)
		{
			foreach (AssemblyTreeNode node in Nodes) {
				SA.SharpAssembly assembly = (SA.SharpAssembly)node.Attribute;
				if (asm.FullName == assembly.FullName) {
					
					// curnode contains Filename node
					AssemblyTreeNode curnode = (AssemblyTreeNode)node.GetNodeFromChildren(Path.GetFileName(assembly.Location));
					
					TreeNode tnode = curnode.GetNodeFromChildren(name); // get namespace node
					if (tnode == null) return;
					tnode.EnsureVisible();
					SelectedNode = tnode;
					return;
				}
			}
			
			// execute if assembly containing the type is not loaded
			AddAssembly(asm);
			GoToNamespace(asm, name);			
		}
		
		private TypeNode GetTypeNode(SA.SharpAssembly targetAssembly, string Namespace, string FullName)
		{
			foreach (AssemblyTreeNode node in Nodes) {
				SA.SharpAssembly assembly = (SA.SharpAssembly)node.Attribute;
				if (targetAssembly.FullName == assembly.FullName) {
					
					// curnode contains Filename node
					AssemblyTreeNode curnode = (AssemblyTreeNode)node.GetNodeFromChildren(Path.GetFileName(assembly.Location));
					
					TreeNode path;
					
					if (Namespace == null || Namespace == "") {
						path = curnode;
					} else {
						TreeNode tnode = curnode.GetNodeFromChildren(Namespace); // get namespace node
						if (tnode == null) {
							return null; // TODO : returns null if the tree isn't up to date.
						} else {
							path = tnode;
						}
					}

					string nodename = FullName.Substring(Namespace.Length + 1);
										
					TreeNode foundnode = node.GetNodeFromCollection(path.Nodes, nodename);
					return (TypeNode)foundnode;
				}
			}
			
			// execute if assembly containing the type is not loaded
			AddAssembly(targetAssembly);
			return GetTypeNode(targetAssembly, Namespace, FullName);
			
		}
		
		public void GoToType(IClass type)
		{
			AssemblyTreeNode node = GetTypeNode((SA.SharpAssembly)((SharpAssemblyClass)type).DeclaredIn, type.Namespace, type.FullyQualifiedName);
			if (node == null) {
				Console.WriteLine("No node for type found");
				return;
			}
			
			node.EnsureVisible();
			SelectedNode = node;
		}
		
		public void GoToType(IReturnType type)
		{
			AssemblyTreeNode node = GetTypeNode((SA.SharpAssembly)((SharpAssemblyClass)type).DeclaredIn, type.Namespace, type.FullyQualifiedName);
			if (node == null) return;
			
			node.EnsureVisible();
			SelectedNode = node;
		}
		
		protected override void OnDoubleClick(EventArgs e)
		{
			AssemblyTreeNode rn = (AssemblyTreeNode)SelectedNode;
			if (rn == null)
				return;
			switch (rn.Type) {
				
				case NodeType.Link: // clicked on link, jump to link.
					if (rn.Attribute is Type) {
						GoToType((IClass)rn.Attribute);
					}
					break;
				
				case NodeType.Reference: // clicked on assembly reference, open assembly
					// check if the assembly is open
					RefNodeAttribute attr = (RefNodeAttribute)rn.Attribute;
					OpenAssemblyByName(attr);
					break;
			}
		}
		
		public void OpenAssemblyByName(RefNodeAttribute attr)
		{
			foreach (AssemblyTreeNode node in Nodes) {
				if (node.Type == NodeType.Assembly) {
					if (attr.RefName.FullName == ((SA.SharpAssembly)node.Attribute).FullName) { // if yes, return
						node.EnsureVisible();
						SelectedNode = node;
						return;
					}
				}
			}
			try {
				AddAssembly(SA.SharpAssembly.Load(attr.RefName.FullName, System.IO.Path.GetDirectoryName(attr.Assembly.Location)));	
				OpenAssemblyByName(attr);
			} catch(Exception ex) {