reflectiontree.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.Reflection;
using System.Threading;
using System.Resources;
using System.Text;
using System.Diagnostics;
using System.Security.Policy;
using System.Configuration;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using Microsoft.Win32;

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;

namespace ICSharpCode.SharpDevelop.Internal.Reflection
{
	public class ReflectionTree : TreeView
	{
		public ResourceService ress = (ResourceService)ServiceManager.Services.GetService(typeof(ResourceService));
		
		ArrayList assemblies = new ArrayList();
		ObjectBrowser.DisplayInformationWrapper _parent;
		PropertyService propSvc;
		
		public bool showInternalTypes = true, showInternalMembers = true;
		public bool showPrivateTypes = true, showPrivateMembers = true;
		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;
		
		ReflectionNode selnode;
		
		public event EventHandler Changed;
		
		internal static AmbienceReflectionDecorator languageConversion;
		
		public ReflectionTree(ObjectBrowser.DisplayInformationWrapper 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));
			AmbienceService          ambienceService = (AmbienceService)ServiceManager.Services.GetService(typeof(AmbienceService));
			propSvc = (PropertyService)ServiceManager.Services.GetService(typeof(PropertyService));
			
			languageConversion = ambienceService.CurrentAmbience;
			languageConversion.ConversionFlags = languageConversion.ConversionFlags & ~(ConversionFlags.UseFullyQualifiedNames | ConversionFlags.ShowModifiers | ConversionFlags.ShowParameterNames);
			
			this.ImageList = classBrowserIconService.ImageList;
			
			LabelEdit     = false;
			HotTracking   = false;
			AllowDrop     = true;
			HideSelection = false;
			//Sorted        = true;
			
			mnuBack    = new MenuItem(ress.GetString(resPrefix + "GoBack"), new EventHandler(BackEvt));
			mnuLoadAsm = new MenuItem(ress.GetString(resPrefix + "LoadAssembly"), new EventHandler(LoadAsmEvt));
			mnuLoadStd = new MenuItem(ress.GetString(resPrefix + "LoadStd"), new EventHandler(LoadStdEvt));
			mnuLoadRef = new MenuItem(ress.GetString(resPrefix + "LoadRef"), new EventHandler(LoadRefEvt));
			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(RemAsmEvt));
			mnuCopyTree = new MenuItem(ress.GetString(resPrefix + "CopyTree"), new EventHandler(CopyTreeEvt));
			mnuSaveRes  = new MenuItem(ress.GetString(resPrefix + "SaveRes"), new EventHandler(SaveResEvt));
			mnuJump     = new MenuItem(ress.GetString(resPrefix + "JumpType"), new EventHandler(JumpEvt));
			mnuOpenRef  = new MenuItem(ress.GetString(resPrefix + "OpenRef"), new EventHandler(OpenRefEvt));
			mnuDisAsm   = new MenuItem(ress.GetString(resPrefix + "DisasmToFile"), new EventHandler(DisAsmEvt));
			
			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
			});
			
			mnuShowPrivTypes.Checked = showPrivateTypes    = propSvc.GetProperty("ObjectBrowser.ShowPrivTypes", true);
			mnuShowIntTypes.Checked  = showInternalTypes   = propSvc.GetProperty("ObjectBrowser.ShowIntTypes", true);
			mnuShowPrivMem.Checked   = showPrivateMembers  = propSvc.GetProperty("ObjectBrowser.ShowPrivMembers", true);
			mnuShowIntMem.Checked    = showInternalMembers = propSvc.GetProperty("ObjectBrowser.ShowIntMembers", true);
			mnuShowSpecial.Checked   = showSpecial = propSvc.GetProperty("ObjectBrowser.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(Assembly.LoadFrom(fileName));
		}
		
		public bool IsAssemblyLoaded(string filename)
		{
			try {
				foreach(Assembly asm in assemblies) {
					if (asm.Location == filename) return true;
				}
			} finally {
			}
			return false;
		}
		
		public void SaveFile(string filename)
		{
		}
		
		public void AddAssembly(Assembly assembly)
		{
			if (IsAssemblyLoaded(assembly.Location)) return;
			
			assemblies.Add(assembly);
			TreeNode node = new ReflectionFolderNode(Path.GetFileNameWithoutExtension(assembly.CodeBase), assembly, ReflectionNodeType.Assembly, 0, 1);
			Nodes.Add(node);
			PopulateTree((ReflectionNode)node);
		}

		public void RePopulateTreeView()
		{
			foreach (ReflectionNode node in Nodes) {
				node.Populate(showPrivateTypes, showInternalTypes);
				PopulateTree(node);
			}
		}
		
		public void PopulateTree(ReflectionNode parentnode)
		{
			if (!parentnode.Populated)
				parentnode.Populate(showPrivateTypes, showInternalTypes);
			
			foreach (ReflectionNode node in parentnode.Nodes) {
				if (!node.Populated) {
					node.Populate(showPrivateTypes, showInternalTypes);
				}
				PopulateTree(node);
			}
		}
		
		public void GoToMember(MemberInfo member, Assembly MemberAssembly) 
		{
			string paramtext = "";
			paramtext = ReflectionMemberNode.GetMemberNodeText(member);
				
			ReflectionTypeNode typenode = GetTypeNode(member.DeclaringType);
			if (typenode == null) return;
			
			if (!typenode.MembersPopulated) {
				typenode.PopulateMembers(showPrivateMembers, showInternalMembers, showSpecial);
			}
			
			TreeNode foundnode = typenode.GetNodeFromChildren(paramtext);
			if (foundnode == null) return;
			
			foundnode.EnsureVisible();
			SelectedNode = foundnode;
		}
		
		private ReflectionTypeNode GetTypeNode(Type type)
		{
			foreach (ReflectionNode node in Nodes) {
				Assembly assembly = (Assembly)node.Attribute;
				if (type.Assembly.FullName == assembly.FullName) {
					
					// curnode contains Filename node
					ReflectionNode curnode = (ReflectionNode)node.GetNodeFromChildren(Path.GetFileName(assembly.CodeBase));
					
					TreeNode path;
					
					if (type.Namespace == null || type.Namespace == "") {
						path = curnode;
					} else {
						TreeNode tnode = curnode.GetNodeFromChildren(type.Namespace); // get namespace node
						if (tnode == null) {
							return null; // TODO : returns, if the tree isn't up to date.
						} else {
							path = tnode;
						}
					}

					string nodename = type.FullName.Substring(type.Namespace.Length + 1);
										
					TreeNode foundnode = node.GetNodeFromCollection(path.Nodes, nodename);
					return (ReflectionTypeNode)foundnode;
				}
			}
			
			// execute if assembly containing the type is not loaded
			AddAssembly(type.Assembly);
			return GetTypeNode(type);
			
		}
		
		public void GoToNamespace(Assembly asm, string name)
		{
			foreach (ReflectionNode node in Nodes) {
				Assembly assembly = (Assembly)node.Attribute;
				if (asm.FullName == assembly.FullName) {
					
					// curnode contains Filename node
					ReflectionNode curnode = (ReflectionNode)node.GetNodeFromChildren(Path.GetFileName(assembly.CodeBase));
					
					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);			
		}
		
		public void GoToType(Type type)
		{
			ReflectionNode node = GetTypeNode(type);
			if (node == null) return;
			
			node.EnsureVisible();
			SelectedNode = node;
		}
		
		protected override void OnDoubleClick(EventArgs e)
		{
			ReflectionNode rn = (ReflectionNode)SelectedNode;
			if (rn == null)
				return;
			switch (rn.Type) {
				
				case ReflectionNodeType.Link: // clicked on link, jump to link.
					if (rn.Attribute is Type) {
						GoToType((Type)rn.Attribute);
					}
					break;
				
				case ReflectionNodeType.Reference: // clicked on assembly reference, open assembly
					// check if the assembly is open