directorynode.cs

SharpDevelop2.0.0 c#开发免费工具

							node.AddTo(this);
							fileNodeDictionary[fileName] = node;
						}
					}
					
					node.ProjectItem = fileItem;
					if (fileItem != null && fileItem.DependentUpon != null && fileItem.DependentUpon.Length > 0) {
						dependendFileDictionary[node] = fileItem.DependentUpon;
					}
				}
			}
			
			// Insert 'code behind files'
			foreach (KeyValuePair<FileNode, string> pair in dependendFileDictionary) {
				string fileName = Path.GetFileName(pair.Value);
				if (!fileNodeDictionary.ContainsKey(fileName)) {
					continue;
				}
				AbstractProjectBrowserTreeNode parentNode = fileNodeDictionary[fileName];
				pair.Key.Parent.Nodes.Remove(pair.Key);
				pair.Key.AddTo(parentNode);
				if (pair.Key.FileNodeStatus != FileNodeStatus.Missing) {
					pair.Key.FileNodeStatus = FileNodeStatus.BehindFile;
				}
			}
			base.Initialize();
		}

		protected void BaseInitialize()
		{
			base.Initialize();
		}
		
		void AddParentFolder(string virtualName, string relativeDirectoryPath, Dictionary<string, DirectoryNode> directoryNodeList)
		{
			if (relativeDirectoryPath.Length == 0
			    || string.Compare(virtualName, 0, relativeDirectoryPath, 0, relativeDirectoryPath.Length, StringComparison.InvariantCultureIgnoreCase) == 0)
			{
				// virtualName is a file in this folder, so we have to add its containing folder
				// to the project
				int pos = virtualName.IndexOf('/', relativeDirectoryPath.Length + 1);
				if (pos < 0)
					return;
				string subFolderName = virtualName.Substring(relativeDirectoryPath.Length, pos - relativeDirectoryPath.Length);
				DirectoryNode node;
				if (directoryNodeList.TryGetValue(subFolderName, out node)) {
					if (node.FileNodeStatus == FileNodeStatus.None) {
						node.FileNodeStatus = FileNodeStatus.InProject;
					}
				} else {
					node = new DirectoryNode(Path.Combine(Directory, subFolderName), FileNodeStatus.Missing);
					node.AddTo(this);
					directoryNodeList[subFolderName] = node;
				}
			}
		}
		
		void SetOpenedImage()
		{
			if (openedImage != null) {
				SetIcon(openedImage);
			}
		}
		
		void SetClosedImage()
		{
			if (closedImage != null) {
				SetIcon(closedImage);
			}
		}
		public override void Expanding()
		{
			SetOpenedImage();
			base.Expanding();
		}
		
		public override void Collapsing()
		{
			SetClosedImage();
			base.Collapsing();
		}
		
		public override void AfterLabelEdit(string newName)
		{
			if (newName == null) {
				return;
			}
			if (!FileService.CheckFileName(newName)) {
				return;
			}
			if (!FileService.CheckDirectoryName(newName)) {
				return;
			}
			if (String.Compare(Text, newName, true) == 0) {
				return;
			}
			string oldText = Text;
			Text = newName;
			if (Directory != null) {
				string newPath = Path.Combine(Path.GetDirectoryName(Directory), newName);
				if (System.IO.Directory.Exists(newPath)) {
					if (System.IO.Directory.GetFileSystemEntries(newPath).Length == 0) {
						System.IO.Directory.Delete(newPath);
						FileService.RenameFile(Directory, newPath, true);
					} else {
						MessageService.ShowError("The folder already exists and contains files!");
						Text = oldText;
						return;
					}
				} else {
					FileService.RenameFile(Directory, newPath, true);
				}
				
				this.directory = newPath;
				Project.Save();
			}
		}
		public override object AcceptVisitor(ProjectBrowserTreeNodeVisitor visitor, object data)
		{
			return visitor.Visit(this, data);
		}
		
		#region Cut & Paste
		public override bool EnableDelete {
			get {
				return true;
			}
		}
		
		public override void Delete()
		{
			if (FileNodeStatus == FileNodeStatus.Missing) {
				FileService.RemoveFile(Directory, true);
				Project.Save();
			} else {
				if (MessageService.AskQuestion(GetQuestionText("${res:ProjectComponent.ContextMenu.DeleteWithContents.Question}"))) {
					FileService.RemoveFile(Directory, true);
					Project.Save();
				}
			}
		}
		
		public override bool EnablePaste {
			get {
				IDataObject dataObject = ClipboardWrapper.GetDataObject();
				if (dataObject == null) {
					return false;
				}
				if (dataObject.GetDataPresent(DataFormats.FileDrop)) {
					return true;
				}
				if (dataObject.GetDataPresent(typeof(FileNode))) {
					FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(FileNode).ToString());
					return !FileUtility.IsEqualFileName(Directory, clipboardObject.FileName) && !FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(clipboardObject.FileName)) && File.Exists(clipboardObject.FileName);
				}
				if (dataObject.GetDataPresent(typeof(DirectoryNode))) {
					FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(DirectoryNode).ToString());
					if (FileUtility.IsBaseDirectory(clipboardObject.FileName, Directory)) {
						return false;
					}
					return !FileUtility.IsEqualFileName(Directory, clipboardObject.FileName) && !FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(clipboardObject.FileName)) && System.IO.Directory.Exists(clipboardObject.FileName);
				}
				return false;
			}
		}
		
		public override void Paste()
		{
			IDataObject dataObject = ClipboardWrapper.GetDataObject();
			
			if (dataObject.GetDataPresent(DataFormats.FileDrop)) {
				string[] files = (string[])dataObject.GetData(DataFormats.FileDrop);
				foreach (string fileName in files) {
					if (System.IO.Directory.Exists(fileName)) {
						if (!FileUtility.IsBaseDirectory(fileName, Directory)) {
							CopyDirectoryHere(fileName, false);
						}
					} else {
						CopyFileHere(fileName, false);
					}
				}
			} else if (dataObject.GetDataPresent(typeof(FileNode))) {
				FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(FileNode).ToString());
				
				if (File.Exists(clipboardObject.FileName)) {
					CopyFileHere(clipboardObject.FileName, clipboardObject.PerformMove);
					if (clipboardObject.PerformMove) {
						Clipboard.Clear();
					}
				}
			} else if (dataObject.GetDataPresent(typeof(DirectoryNode))) {
				FileOperationClipboardObject clipboardObject = (FileOperationClipboardObject)dataObject.GetData(typeof(DirectoryNode).ToString());
				
				if (System.IO.Directory.Exists(clipboardObject.FileName)) {
					CopyDirectoryHere(clipboardObject.FileName, clipboardObject.PerformMove);
					if (clipboardObject.PerformMove) {
						Clipboard.Clear();
					}
				}
			}
			ProjectService.SaveSolution();
		}
		
		public void CopyDirectoryHere(string fileName, bool performMove)
		{
			AddExistingItemsToProject.CopyDirectory(fileName, this, true);
			if (performMove) {
				foreach (IViewContent content in WorkbenchSingleton.Workbench.ViewContentCollection) {
					if (content.FileName != null &&
					    FileUtility.IsBaseDirectory(fileName, content.FileName))
					{
						content.FileName = FileUtility.RenameBaseDirectory(content.FileName, fileName, Path.Combine(this.directory, Path.GetFileName(fileName)));
					}
				}
				FileService.RemoveFile(fileName, true);
			}
		}
		
		public void CopyDirectoryHere(DirectoryNode node, bool performMove)
		{
			CopyDirectoryHere(node.Directory, performMove);
		}
		
		public void CopyFileHere(string fileName, bool performMove)
		{
			string shortFileName = Path.GetFileName(fileName);
			string copiedFileName = Path.Combine(Directory, shortFileName);
			if (FileUtility.IsEqualFileName(fileName, copiedFileName))
				return;
			
			FileProjectItem newItem = AddExistingItemsToProject.CopyFile(fileName, this, true);
			IProject sourceProject = Solution.FindProjectContainingFile(fileName);
			if (sourceProject != null) {
				string sourceDirectory = Path.GetDirectoryName(fileName);
				bool dependendElementsCopied = false;
				foreach (ProjectItem item in sourceProject.Items.ToArray()) {
					FileProjectItem fileItem = item as FileProjectItem;
					if (fileItem == null)
						continue;
					if (newItem != null && FileUtility.IsEqualFileName(fileItem.FileName, fileName)) {
						fileItem.CopyExtraPropertiesTo(newItem);
					}
					if (!string.Equals(fileItem.DependentUpon, shortFileName, StringComparison.OrdinalIgnoreCase))
						continue;
					string itemPath = Path.Combine(sourceProject.Directory, fileItem.VirtualName);
					if (!FileUtility.IsEqualFileName(sourceDirectory, Path.GetDirectoryName(itemPath)))
						continue;
					// this file is dependend on the file being copied/moved: copy it, too
					CopyFileHere(itemPath, performMove);
					dependendElementsCopied = true;
				}
				if (dependendElementsCopied)
					RecreateSubNodes();
			}
			if (performMove) {
				foreach (IViewContent content in WorkbenchSingleton.Workbench.ViewContentCollection) {
					if (content.FileName != null &&
					    FileUtility.IsEqualFileName(content.FileName, fileName))
					{
						content.FileName  = copiedFileName;
						content.TitleName = shortFileName;
					}
				}
				FileService.RemoveFile(fileName, false);
			}
		}
		
		public void CopyFileHere(FileNode node, bool performMove)
		{
			if (node.FileNodeStatus == FileNodeStatus.None) {
				AddExistingItemsToProject.CopyFile(node.FileName, this, false);
				if (performMove) {
					FileService.RemoveFile(node.FileName, false);
				}
			} else if (node.IsLink) {
				string relFileName = FileUtility.GetRelativePath(Project.Directory, node.FileName);
				FileNode fileNode = new FileNode(node.FileName, FileNodeStatus.InProject);
				FileProjectItem fileProjectItem = new FileProjectItem(Project, IncludeFileInProject.GetDefaultItemType(Project, node.FileName));
				fileProjectItem.Include = relFileName;
				fileProjectItem.Properties.Set("Link", Path.Combine(RelativePath, Path.GetFileName(node.FileName)));
				fileNode.ProjectItem = fileProjectItem;
				fileNode.AddTo(this);
				ProjectService.AddProjectItem(Project, fileProjectItem);
				if (performMove) {
					ProjectService.RemoveProjectItem(node.Project, node.ProjectItem);
					node.Remove();
				}
			} else {
				CopyFileHere(node.FileName, performMove);
			}
		}
		
		public override bool EnableCopy {
			get {
				if (IsEditing) {
					return false;
				}
				return true;
			}
		}
		public override void Copy()
		{
			ClipboardWrapper.SetDataObject(FileOperationClipboardObject.CreateDataObject(this, false));
		}
		
		public override bool EnableCut {
			get {
				if (IsEditing) {
					return false;
				}
				return true;
			}
		}
		
		public override void Cut()
		{
			DoPerformCut = true;
			ClipboardWrapper.SetDataObject(FileOperationClipboardObject.CreateDataObject(this, true));
		}
		#endregion
		
		#region Drag & Drop
		public override DataObject DragDropDataObject {
			get {
				return new DataObject(this);
			}
		}
		
		public override DragDropEffects GetDragDropEffect(IDataObject dataObject, DragDropEffects proposedEffect)
		{
			if (dataObject.GetDataPresent(typeof(FileNode))) {
				FileNode fileNode = (FileNode)dataObject.GetData(typeof(FileNode));
				
				if (!FileUtility.IsEqualFileName(Directory, fileNode.FileName) && !FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(fileNode.FileName))) {
					if (Project != fileNode.Project) {
						return DragDropEffects.Copy;
					}
					return proposedEffect;
				}
			}
			
			if (dataObject.GetDataPresent(typeof(DirectoryNode))) {
				DirectoryNode directoryNode = (DirectoryNode)dataObject.GetData(typeof(DirectoryNode));
				if (FileUtility.IsBaseDirectory(directoryNode.Directory, Directory)) {
					return DragDropEffects.None;
				}
				if (!FileUtility.IsEqualFileName(Directory, directoryNode.Directory) && !FileUtility.IsEqualFileName(Directory, Path.GetDirectoryName(directoryNode.Directory))) {
					if (Project != directoryNode.Project) {
						return DragDropEffects.Copy;
					}
					return proposedEffect;
				}
			}
			if (dataObject.GetDataPresent(DataFormats.FileDrop)) {
				return DragDropEffects.Copy;
			}
			return DragDropEffects.None;
		}
		
		public override void DoDragDrop(IDataObject dataObject, DragDropEffects effect)
		{
			PerformInitialization();
			Expand();
			try {
				if (dataObject.GetDataPresent(typeof(FileNode))) {
					FileNode fileNode = (FileNode)dataObject.GetData(typeof(FileNode));
					CopyFileHere(fileNode, effect == DragDropEffects.Move);
				} else if (dataObject.GetDataPresent(typeof(DirectoryNode))) {
					DirectoryNode directoryNode = (DirectoryNode)dataObject.GetData(typeof(DirectoryNode));
					CopyDirectoryHere(directoryNode, effect == DragDropEffects.Move);
				} else if (dataObject.GetDataPresent(DataFormats.FileDrop)) {
					string[] files = (string[])dataObject.GetData(DataFormats.FileDrop);
					foreach (string fileName in files) {
						if (System.IO.Directory.Exists(fileName)) {
							if (!FileUtility.IsBaseDirectory(fileName, Directory)) {
								CopyDirectoryHere(fileName, false);
							}
						} else {
							CopyFileHere(fileName, false);
						}
					}
				}
				
				ProjectService.SaveSolution();
			} catch (Exception e) {
				MessageService.ShowError(e);
			}
		}
		#endregion
	}
}