assemblytree.cs

全功能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.Services;
using ICSharpCode.SharpDevelop.Services;
using ICSharpCode.Core.Properties;
using ICSharpCode.SharpDevelop.Gui.Dialogs;
using ICSharpCode.SharpDevelop.Internal.Project.Collections;
using ICSharpCode.SharpDevelop.Internal.Project;
using ICSharpCode.SharpDevelop.Internal.ExternalTool;

using SA = ICSharpCode.SharpAssembly.Assembly;
using SharpDevelop.Internal.Parser;

namespace ICSharpCode.SharpDevelop.AddIns.AssemblyScout
{
	public class AssemblyTree : TreeView
	{
		static AmbienceService  ambienceService = (AmbienceService)ServiceManager.Services.GetService(typeof(AmbienceService));
		public static IAmbience CurrentAmbience = ambienceService.CurrentAmbience;
		
		public ResourceService ress = (ResourceService)ServiceManager.Services.GetService(typeof(ResourceService));
		
		ArrayList assemblies = new ArrayList();
		AssemblyScoutViewContent _parent;
		PropertyService propSvc;
		
		public ShowOptions showInternalTypes, showInternalMembers;
		public ShowOptions showPrivateTypes, showPrivateMembers;
		
		public bool showSpecial = false;
		
		MenuItem mnuBack;
		MenuItem mnuLoadAsm, mnuLoadStd, mnuLoadRef;
		//MenuItem mnuShowPrivTypes, mnuShowIntTypes;
		//MenuItem mnuShowPrivMem, mnuShowIntMem, mnuShowSpecial;
		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.";
			
			ClassBrowserIconsService classBrowserIconService = (ClassBrowserIconsService)ServiceManager.Services.GetService(typeof(ClassBrowserIconsService));
			propSvc = (PropertyService)ServiceManager.Services.GetService(typeof(PropertyService));
			
			this.ImageList = classBrowserIconService.ImageList;
			
			LabelEdit     = false;
			HotTracking   = false;
			AllowDrop     = true;
			HideSelection = false;
			//Sorted        = true;
			
			mnuBack    = new MenuItem(ress.GetString(resPrefix + "GoBack"), new EventHandler(Back));
			mnuLoadAsm = new MenuItem(ress.GetString(resPrefix + "LoadAssembly"), new EventHandler(LoadAssembly));
			mnuLoadStd = new MenuItem(ress.GetString(resPrefix + "LoadStd"), new EventHandler(LoadStdAssemblies));
			mnuLoadRef = new MenuItem(ress.GetString(resPrefix + "LoadRef"), new EventHandler(LoadRefAssemblies));
			//mnuShowPrivTypes = new MenuItem(ress.GetString(resPrefix + "ShowPrivTypes"), new EventHandler(ShowPrivTypesEvt));
			//mnuShowIntTypes  = new MenuItem(ress.GetString(resPrefix + "ShowIntTypes"), new EventHandler(ShowIntTypesEvt));
			//mnuShowPrivMem   = new MenuItem(ress.GetString(resPrefix + "ShowPrivMem"), new EventHandler(ShowPrivMemEvt));
			//mnuShowIntMem    = new MenuItem(ress.GetString(resPrefix + "ShowIntMem"), new EventHandler(ShowIntMemEvt));
			//mnuShowSpecial   = new MenuItem(ress.GetString(resPrefix + "ShowSpecial"), new EventHandler(ShowSpecialEvt));
			mnuRemAsm   = new MenuItem(ress.GetString(resPrefix + "RemoveAsm"), new EventHandler(RemoveAssembly));
			mnuCopyTree = new MenuItem(ress.GetString(resPrefix + "CopyTree"), new EventHandler(CopyAssemblyTree));
			mnuSaveRes  = new MenuItem(ress.GetString(resPrefix + "SaveRes"), new EventHandler(SaveCurrentResource));
			mnuJump     = new MenuItem(ress.GetString(resPrefix + "JumpType"), new EventHandler(JumpLink));
			mnuOpenRef  = new MenuItem(ress.GetString(resPrefix + "OpenRef"), new EventHandler(OpenReference));
			mnuDisAsm   = new MenuItem(ress.GetString(resPrefix + "DisasmToFile"), new EventHandler(DisAssembly));
			
			ContextMenu = new ContextMenu(new MenuItem[] {
				mnuBack,
				new MenuItem("-"),
				mnuLoadAsm,
				mnuLoadStd,
				mnuLoadRef,
				new MenuItem("-"),
			//	mnuShowPrivTypes,
			//	mnuShowIntTypes,
			//	new MenuItem("-"),
			//	mnuShowPrivMem,
			//	mnuShowIntMem,
			//	mnuShowSpecial,
			//	new MenuItem("-"),
				mnuRemAsm,
				mnuCopyTree,
				mnuSaveRes,
				mnuJump,
				mnuOpenRef,
				mnuDisAsm
			});
			
			showPrivateTypes    = (ShowOptions)propSvc.GetProperty("AddIns.AssemblyScout.privateTypesBox", 1);
			showInternalTypes   = (ShowOptions)propSvc.GetProperty("AddIns.AssemblyScout.internalTypesBox", 1);
			showPrivateMembers  = (ShowOptions)propSvc.GetProperty("AddIns.AssemblyScout.privateMembersBox", 1);
			showInternalMembers = (ShowOptions)propSvc.GetProperty("AddIns.AssemblyScout.internalMembersBox", 1);
			showSpecial = propSvc.GetProperty("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 = "";
				
			TypeNode typenode = GetTypeNode((SA.SharpAssembly)member.DeclaringType.DeclaredIn, member.DeclaringType.Namespace, member.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)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)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) {