defaultdotnetnodebuilder.cs

全功能c#编译器

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

using System;
using System.IO;
using System.Windows.Forms;
using System.Diagnostics;
using System.Drawing;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Utility;

using ICSharpCode.Core.Properties;

using ICSharpCode.Core.Services;
using ICSharpCode.SharpDevelop.Internal.Project;

namespace ICSharpCode.SharpDevelop.Gui.Pads.ProjectBrowser
{
	public class DefaultDotNetNodeBuilder : IProjectNodeBuilder
	{
		static FileUtilityService fileUtilityService = (FileUtilityService)ServiceManager.Services.GetService(typeof(FileUtilityService));

		public bool CanBuildProjectTree(IProject project)
		{
			return true;
		}

		public static bool IsWebReference(AbstractBrowserNode node)
		{
			if (node != null) {
				if (node is ProjectBrowserNode)
					return false;
				if (node.Text == "Web References")
					return true;
				return IsWebReference((AbstractBrowserNode)node.Parent);
			}

			return false;
		}

		public AbstractBrowserNode BuildProjectTreeNode(IProject project)
		{
			ResourceService resourceService = (ResourceService)ServiceManager.Services.GetService(typeof(IResourceService));
			IconService iconService = (IconService)ServiceManager.Services.GetService(typeof(IconService));
			ProjectBrowserNode projectNode = new ProjectBrowserNode(project);

			projectNode.IconImage = iconService.GetImageForProjectType(project.ProjectType);

			FolderNode resourceNode = new NamedFolderNode("ProjectComponent.ResourceFilesString", 0);
			resourceNode.ContextmenuAddinTreePath = "/SharpDevelop/Views/ProjectBrowser/ContextMenu/ResourceFolderNode";
			resourceNode.OpenedImage = resourceService.GetBitmap("Icons.16x16.OpenResourceFolder");
			resourceNode.ClosedImage = resourceService.GetBitmap("Icons.16x16.ClosedResourceFolder");
			projectNode.Nodes.Add(resourceNode);

			FolderNode referenceNode = new NamedFolderNode("ProjectComponent.ReferencesString", 1);
			referenceNode.ContextmenuAddinTreePath = "/SharpDevelop/Views/ProjectBrowser/ContextMenu/ReferenceFolderNode";
			referenceNode.OpenedImage = resourceService.GetBitmap("Icons.16x16.OpenReferenceFolder");
			referenceNode.ClosedImage = resourceService.GetBitmap("Icons.16x16.ClosedReferenceFolder");
			projectNode.Nodes.Add(referenceNode);

			// build a hash of projectFile items
			System.Collections.Hashtable fileHash = new Hashtable();

			// add items to the list by dependency order
			bool bDone = false;
			while(fileHash.Count != project.ProjectFiles.Count && bDone != true) {
				bool bAtLeastOneLoaded = false;
				bDone = true;
				foreach(ProjectFile projectFile in project.ProjectFiles) {
					if(fileHash.ContainsKey(projectFile.Name)) {
						continue;
					}

					bDone = false;

					if(projectFile.DependsOn != null && projectFile.DependsOn != String.Empty) {
						if(!fileHash.ContainsKey(projectFile.DependsOn)) {
							// cannot load yet
							continue;
						}
					}

					// flag to true in the hash
					bAtLeastOneLoaded = true;
					fileHash.Add(projectFile.Name, true);
				}
				if(!bAtLeastOneLoaded) {
					// we have dependencies that cannot be resolved
					// so we will add them without dependson
					foreach(ProjectFile projectFile in project.ProjectFiles) {
						if(!fileHash.ContainsKey(projectFile.Name)) {
							projectFile.DependsOn = String.Empty;
						}
					}
					break;
				}
			}

			// now we can load the files
			foreach(ProjectFile projectFile in project.ProjectFiles) {
				switch(projectFile.Subtype) {
					case Subtype.Code:
						// add a source file
						switch (projectFile.BuildAction) {
							case BuildAction.Exclude:
								// should we add?
								break;
							case BuildAction.EmbedAsResource:
								// add as a resource
								AbstractBrowserNode newResNode = new FileNode(projectFile);
								resourceNode.Nodes.Add(newResNode);
								break;
							default:
								// add everything else
								AddProjectFileNode(project, projectNode, projectFile);
								break;
						}
						break;
					default:
						// add everything else
						AddProjectFileNode(project, projectNode, projectFile);
						break;
				}
			}

			/*
			// create 'empty' directories
			for (int i = 0; i < project.ProjectFiles.Count; ++i) {
				if(project.ProjectFiles[i].Subtype == Subtype.WebReferences ) {
					string directoryName   = fileUtilityService.AbsoluteToRelativePath(project.BaseDirectory, project.ProjectFiles[i].Name);
					// if directoryname starts with ./ oder .\
					if (directoryName.StartsWith(".")) {
						directoryName =  directoryName.Substring(2);
					}
					string parentDirectory = Path.GetFileName(directoryName);
					AbstractBrowserNode currentPathNode = GetPath(directoryName, projectNode, true);

					DirectoryNode newFolderNode  = new DirectoryNode(project.ProjectFiles[i].Name);
					newFolderNode.OpenedImage = resourceService.GetBitmap("Icons.16x16.OpenWebReferenceFolder");
					newFolderNode.ClosedImage = resourceService.GetBitmap("Icons.16x16.ClosedWebReferenceFolder");
					currentPathNode.Nodes.Add(newFolderNode);

				}
				else if (project.ProjectFiles[i].Subtype == Subtype.Directory) {
					string directoryName   = fileUtilityService.AbsoluteToRelativePath(project.BaseDirectory, project.ProjectFiles[i].Name);

					// if directoryname starts with ./ oder .\
					if (directoryName.StartsWith(".")) {
						directoryName =  directoryName.Substring(2);
					}

					string parentDirectory = Path.GetFileName(directoryName);

					AbstractBrowserNode currentPathNode = GetPath(directoryName, projectNode, true);

					DirectoryNode newFolderNode  = new DirectoryNode(project.ProjectFiles[i].Name);
					newFolderNode.OpenedImage = resourceService.GetBitmap("Icons.16x16.OpenFolderBitmap");
					newFolderNode.ClosedImage = resourceService.GetBitmap("Icons.16x16.ClosedFolderBitmap");

					currentPathNode.Nodes.Add(newFolderNode);

				}
			}

			// create file tree
			for (int i = 0; i < project.ProjectFiles.Count; ++i) {
				if (project.ProjectFiles[i].Subtype != Subtype.Directory) {
					ProjectFile fileInformation = project.ProjectFiles[i];

					string relativeFile = fileUtilityService.AbsoluteToRelativePath(project.BaseDirectory, fileInformation.Name);

					string fileName     = Path.GetFileName(fileInformation.Name);

					switch (fileInformation.BuildAction) {

						case BuildAction.Exclude:
							break;

						case BuildAction.EmbedAsResource:
							AbstractBrowserNode newResNode = new FileNode(fileInformation);
							resourceNode.Nodes.Add(newResNode);
							break;

						default:
							AbstractBrowserNode currentPathNode = GetPath(relativeFile, projectNode, true);

							AbstractBrowserNode newNode = new FileNode(fileInformation);
							newNode.ContextmenuAddinTreePath = FileNode.ProjectFileContextMenuPath;
							currentPathNode.Nodes.Add(newNode);
							break;
					}
				}
			}
			*/

			InitializeReferences(referenceNode, project);
			SortUtility.QuickSort(referenceNode.Nodes, TreeNodeComparer.ProjectNode);
			SortUtility.QuickSort(resourceNode.Nodes, TreeNodeComparer.ProjectNode);
			SortUtility.QuickSort(projectNode.Nodes, TreeNodeComparer.ProjectNode);
			return projectNode;
		}

		public static void AddProjectFileNode(IProject project, AbstractBrowserNode projectNode, ProjectFile projectFile) {

			if(projectNode.TreeView != null)
				projectNode.TreeView.BeginUpdate();

			// only works for relative paths right now!
			AbstractBrowserNode parentNode = null;
			string relativeFile = fileUtilityService.AbsoluteToRelativePath(project.BaseDirectory, projectFile.Name);
			string fileName     = Path.GetFileName(projectFile.Name);
			ResourceService resourceService = (ResourceService)ServiceManager.Services.GetService(typeof(IResourceService));

			parentNode = projectNode;

			if(projectFile.DependsOn != String.Empty && projectFile.DependsOn != null) {
				// make sure the dependant node exists
				AbstractBrowserNode dependNode = GetPath(fileUtilityService.AbsoluteToRelativePath(project.BaseDirectory,projectFile.DependsOn), projectNode, false);
				if(dependNode == null) {
					// dependsOn does not exist, do what?
				}

			}