directorynode.cs

SharpDevelop2.0.0 c#开发免费工具

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

using System;
using System.Collections.Generic;
using System.IO;
using System.Windows.Forms;

using ICSharpCode.Core;
using ICSharpCode.SharpDevelop.Gui;
using ICSharpCode.SharpDevelop.Project.Commands;

namespace ICSharpCode.SharpDevelop.Project
{
	[Serializable]
	public class FileOperationClipboardObject
	{
		string fileName;
		bool   performMove;
		public string FileName {
			get {
				return fileName;
			}
		}
		public bool PerformMove {
			get {
				return performMove;
			}
		}
		public FileOperationClipboardObject(string fileName, bool performMove)
		{
			this.fileName = fileName;
			this.performMove = performMove;
		}
		
		public static IDataObject CreateDataObject(FileNode node, bool performMove)
		{
			return new DataObject(typeof(FileNode).ToString(), new FileOperationClipboardObject(node.FileName, performMove));
		}
		
		public static IDataObject CreateDataObject(SolutionItemNode node, bool performMove)
		{
			return new DataObject(typeof(SolutionItemNode).ToString(),
			                      new FileOperationClipboardObject(node.FileName, performMove));
		}
		
		public static IDataObject CreateDataObject(DirectoryNode node, bool performMove)
		{
			return new DataObject(typeof(DirectoryNode).ToString(),
			                      new FileOperationClipboardObject(node.Directory, performMove));
		}
	}
	
	public enum SpecialFolder {
		None,
		AppDesigner,
		WebReference,
		WebReferencesFolder
	}
	
	public class DirectoryNodeFactory
	{
		DirectoryNodeFactory()
		{
		}
		
		public static DirectoryNode CreateDirectoryNode(TreeNode parent, IProject project, string directory)
		{
			DirectoryNode node = new DirectoryNode(directory);
			if (directory == Path.Combine(project.Directory, project.AppDesignerFolder)) {
				node.SpecialFolder = SpecialFolder.AppDesigner;
			} else if (DirectoryNode.IsWebReferencesFolder(project, directory)) {
				node = new WebReferencesFolderNode(directory);
			} else if (parent != null && parent is WebReferencesFolderNode) {
				node = new WebReferenceNode(directory);
			}
			return node;
		}
		
		public static DirectoryNode CreateDirectoryNode(ProjectItem item, FileNodeStatus status)
		{
			DirectoryNode node;
			if (item is WebReferencesProjectItem) {
				node = new WebReferencesFolderNode((WebReferencesProjectItem)item);
				node.FileNodeStatus = status;
			} else {
				node = new DirectoryNode(item.FileName.Trim('\\', '/'), status);
				node.ProjectItem = item;
			}
			return node;
		}
	}
	
	public class DirectoryNode : AbstractProjectBrowserTreeNode, IOwnerState
	{
		string closedImage = null;
		string openedImage = null;
		FileNodeStatus fileNodeStatus = FileNodeStatus.None;
		SpecialFolder  specialFolder  = SpecialFolder.None;
		ProjectItem projectItem = null;
		
		public override bool Visible {
			get {
				return ShowAll || fileNodeStatus != FileNodeStatus.None;
			}
		}
		
		public SpecialFolder SpecialFolder {
			get {
				return specialFolder;
			}
			set {
				if (specialFolder != value) {
					specialFolder = value;
					SetIcon();
				}
			}
		}
		
		public string ClosedImage {
			get {
				return closedImage;
			}
			set {
				closedImage = value;
				if (!IsExpanded) {
					SetIcon(closedImage);
				}
			}
		}
		
		public ProjectItem ProjectItem {
			get {
				return projectItem;
			}
			set {
				projectItem = value;
				if (projectItem != null && projectItem.ItemType == ItemType.WebReferenceUrl) {
					Tag = projectItem;
				}
			}
		}
		
		public string OpenedImage {
			get {
				return openedImage;
			}
			set {
				openedImage = value;
				if (IsExpanded) {
					SetIcon(openedImage);
				}
			}
		}
		
		public System.Enum InternalState {
			get {
				return fileNodeStatus;
			}
		}
		
		public FileNodeStatus FileNodeStatus {
			get {
				return fileNodeStatus;
			}
			set {
				if (fileNodeStatus != value) {
					fileNodeStatus = value;
					SetIcon();
				}
			}
		}
		public override void Refresh()
		{
			base.Refresh();
			if (Nodes.Count == 0) {
				SetIcon(ClosedImage);
			} else if (IsExpanded) {
				SetIcon(openedImage);
			}
		}
		
		
		void SetIcon()
		{
			switch (fileNodeStatus) {
				case FileNodeStatus.None:
					OpenedImage = "ProjectBrowser.GhostFolder.Open";
					ClosedImage = "ProjectBrowser.GhostFolder.Closed";
					break;
				case FileNodeStatus.Missing:
					OpenedImage = "ProjectBrowser.Folder.Missing";
					ClosedImage = "ProjectBrowser.Folder.Missing";
					break;
				default:
					switch (SpecialFolder) {
						case SpecialFolder.None:
							OpenedImage = "ProjectBrowser.Folder.Open";
							ClosedImage = "ProjectBrowser.Folder.Closed";
							break;
						case SpecialFolder.AppDesigner:
							OpenedImage = "ProjectBrowser.PropertyFolder.Open";
							ClosedImage = "ProjectBrowser.PropertyFolder.Closed";
							break;
						case SpecialFolder.WebReferencesFolder:
							OpenedImage = "ProjectBrowser.WebReferenceFolder.Open";
							ClosedImage = "ProjectBrowser.WebReferenceFolder.Closed";
							break;
						case SpecialFolder.WebReference:
							OpenedImage = "ProjectBrowser.WebReference";
							ClosedImage = "ProjectBrowser.WebReference";
							break;
					}
					break;
			}
		}
		
		string directory = String.Empty;
		public virtual string Directory {
			get {
				return directory;
			}
			set {
				directory = value;
				Text = Path.GetFileName(directory);
			}
		}
		
		public virtual string RelativePath {
			get {
				if (Parent is DirectoryNode) {
					return Path.Combine(((DirectoryNode)Parent).RelativePath, Text);
				}
				return Text;
			}
		}
		
		protected DirectoryNode()
		{
			sortOrder = 1;
			SetIcon();
			canLabelEdit = true;
		}
		
		public DirectoryNode(string directory) : this(directory, FileNodeStatus.None)
		{
			sortOrder = 1;
			canLabelEdit = true;
		}
		CustomNode removeMe = null;
		public DirectoryNode(string directory, FileNodeStatus fileNodeStatus)
		{
			sortOrder = 1;
			ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/FolderNode";
			this.Directory = directory;
			this.fileNodeStatus = fileNodeStatus;
			
			removeMe = new CustomNode();
			removeMe.AddTo(this);
			
			SetIcon();
			canLabelEdit = true;
		}
		
		/// <summary>
		/// Determines if the specified <paramref name="folder"/> is a
		/// web reference folder in the specified <paramref name="project"/>.
		/// </summary>
		/// <param name="folder">The full folder path.</param>
		public static bool IsWebReferencesFolder(IProject project, string folder)
		{
			foreach (ProjectItem item in project.Items) {
				if (item.ItemType == ItemType.WebReferences) {
					if (FileUtility.IsEqualFileName(Path.Combine(project.Directory, item.Include), folder)) {
						return true;
					}
				}
			}
			return false;
		}
		
		public void RecreateSubNodes()
		{
			invisibleNodes.Clear();
			if (autoClearNodes) {
				Nodes.Clear();
			} else {
				List<TreeNode> removedNodes = new List<TreeNode>();
				foreach (TreeNode node in Nodes) {
					if (node is FileNode || node is DirectoryNode)
						removedNodes.Add(node);
				}
				foreach (TreeNode node in removedNodes) {
					Nodes.Remove(node);
				}
			}
			Initialize();
			UpdateVisibility();
		}
		
		protected override void Initialize()
		{
			if (removeMe != null) {
				Nodes.Remove(removeMe);
				removeMe = null;
			}
			
			LoggingService.Info("Initialize DirectoryNode " + Directory);
			
			Dictionary<string, FileNode> fileNodeDictionary
				= new Dictionary<string, FileNode>(StringComparer.InvariantCultureIgnoreCase);
			Dictionary<FileNode, string> dependendFileDictionary = new Dictionary<FileNode, string>();
			Dictionary<string, DirectoryNode> directoryNodeList = new Dictionary<string, DirectoryNode>(StringComparer.InvariantCultureIgnoreCase);
			
			// Add files found in file system
			
			if (System.IO.Directory.Exists(Directory)) {
				foreach (string subDirectory in System.IO.Directory.GetDirectories(Directory)) {
					if (Path.GetFileName(subDirectory) != ".svn") {
						DirectoryNode newDirectoryNode = DirectoryNodeFactory.CreateDirectoryNode(this, Project, subDirectory);
						newDirectoryNode.AddTo(this);
						directoryNodeList[Path.GetFileName(subDirectory)] = newDirectoryNode;
					}
				}
				
				foreach (string file in System.IO.Directory.GetFiles(Directory)) {
					FileNode fileNode = new FileNode(file);
					fileNodeDictionary[Path.GetFileName(file)] = fileNode;
					fileNode.AddTo(this);
				}
			}
			if (Nodes.Count == 0) {
				SetClosedImage();
			}
			
			string relativeDirectoryPath = this.RelativePath;
			if (relativeDirectoryPath.Length > 0)
				relativeDirectoryPath = relativeDirectoryPath.Replace('\\', '/') + '/';
			
			// Add project items
			
			foreach (ProjectItem item in Project.Items) {
				if (item.ItemType == ItemType.WebReferenceUrl) {
					DirectoryNode node;
					if (directoryNodeList.TryGetValue(Path.GetFileName(item.FileName), out node)) {
						if (node.FileNodeStatus == FileNodeStatus.None) {
							node.FileNodeStatus = FileNodeStatus.InProject;
						}
						node.ProjectItem = item;
					}
					continue;
				}
				FileProjectItem fileItem = item as FileProjectItem;
				if (fileItem == null)
					continue;
				string virtualName = fileItem.VirtualName.Replace('\\', '/');
				if (virtualName.EndsWith("/"))
					virtualName = virtualName.Substring(0, virtualName.Length - 1);
				string fileName = Path.GetFileName(virtualName);
				if (!string.Equals(virtualName, relativeDirectoryPath + fileName, StringComparison.InvariantCultureIgnoreCase)) {
					AddParentFolder(virtualName, relativeDirectoryPath, directoryNodeList);
					continue;
				}
				
				if (item.ItemType == ItemType.Folder || item.ItemType == ItemType.WebReferences) {
					DirectoryNode node;
					if (directoryNodeList.TryGetValue(fileName, out node)) {
						if (node.FileNodeStatus == FileNodeStatus.None) {
							node.FileNodeStatus = FileNodeStatus.InProject;
						}
						node.ProjectItem = item;
					} else {
						node = DirectoryNodeFactory.CreateDirectoryNode(item, FileNodeStatus.Missing);
						node.AddTo(this);
						directoryNodeList[fileName] = node;
					}
				} else {
					FileNode node;
					if (fileItem.IsLink) {
						node = new FileNode(fileItem.FileName, FileNodeStatus.InProject);
						node.AddTo(this);
						fileNodeDictionary[fileName] = node;
					} else {
						if (fileNodeDictionary.TryGetValue(fileName, out node)) {
							if (node.FileNodeStatus == FileNodeStatus.None) {
								node.FileNodeStatus = FileNodeStatus.InProject;
							}
						} else {
							node = new FileNode(fileItem.FileName, FileNodeStatus.Missing);