projectbrowserview.cs

全功能c#编译器

			SortUtility.QuickSort(combineNode.Nodes, TreeNodeComparer.ProjectNode);
			
			return combineNode;
		}
		
		protected override bool ProcessDialogKey(Keys keyData)
		{
			switch (keyData) {
				case Keys.F2:
					StartLabelEdit();
					break;
				default:
					return base.ProcessDialogKey(keyData);
			}
			return true;
		}

		protected override void OnAfterSelect(TreeViewEventArgs e)
		{ // set current project & current combine
			base.OnAfterSelect(e);
			AbstractBrowserNode node = (AbstractBrowserNode)e.Node;

			IProjectService projectService = (IProjectService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IProjectService));

			projectService.CurrentSelectedProject = node.Project;
			projectService.CurrentSelectedCombine = node.Combine;
			PropertyPad.SetDesignableObject(node.UserData);
			
			MenuService menuService = (MenuService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(MenuService));
			ContextMenu = menuService.CreateContextMenu(this, node.ContextmenuAddinTreePath);
		}

		protected override void OnMouseDown(MouseEventArgs e)
		{
			AbstractBrowserNode node = (AbstractBrowserNode)GetNodeAt(e.X, e.Y);
			if (node != null && SelectedNode != node) {
				SelectedNode = node;
			}
		}

		// open file with the enter key
		protected override void OnKeyPress(KeyPressEventArgs e)
		{
			base.OnKeyPress(e);
			if (e.KeyChar == '\r') {
				OnDoubleClick(e);
			}
		}
		
		protected override void OnDoubleClick(EventArgs e)
		{
			if (SelectedNode != null && SelectedNode is AbstractBrowserNode) {
				((AbstractBrowserNode)SelectedNode).ActivateItem();
			}
		}

		protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
		{ // show open folder icons
			base.OnBeforeExpand(e);
			if (e.Node != null && e.Node is AbstractBrowserNode) {
				((AbstractBrowserNode)e.Node).BeforeExpand();
			}
		}

		protected override void OnBeforeCollapse(TreeViewCancelEventArgs e)
		{
			base.OnBeforeCollapse(e);
			if (e.Node != null && e.Node is AbstractBrowserNode) {
				((AbstractBrowserNode)e.Node).BeforeCollapse();
			}
		}

		protected override void OnAfterLabelEdit(NodeLabelEditEventArgs e)
		{
			base.OnAfterLabelEdit(e);
			AbstractBrowserNode node = (AbstractBrowserNode)e.Node;
			LabelEdit = false;
			
			// we set the label ourself
			node.AfterLabelEdit(e.Label);
			
			e.CancelEdit = true;
			
			if(node.Parent != null) {
				SortUtility.QuickSort(node.Parent.Nodes, TreeNodeComparer.ProjectNode);
			}
			
			// save changes
			IProjectService projectService = (IProjectService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IProjectService));
			projectService.SaveCombine();
		}
		
		
		static ImageList projectBrowserImageList  = null;
		static Hashtable projectBrowserImageIndex = new Hashtable();

		public static int GetImageIndexForImage(Image image)
		{
			if (projectBrowserImageIndex[image] == null) {
				projectBrowserImageList.Images.Add(image);
				projectBrowserImageIndex[image] = projectBrowserImageList.Images.Count - 1;
				return projectBrowserImageList.Images.Count - 1;
			}

			return (int)projectBrowserImageIndex[image];
		}

		public IXmlConvertable CreateMemento()
		{
			return new TreeViewMemento(this);
		}

		public void SetMemento(IXmlConvertable memento)
		{
			((TreeViewMemento)memento).Restore(this);
		}

		// Drag & Drop handling
		
		protected override void OnItemDrag(ItemDragEventArgs e)
		{
			base.OnItemDrag(e);
			AbstractBrowserNode node = e.Item as AbstractBrowserNode;
			if (node != null) {
				DataObject dataObject = node.DragDropDataObject;

				if (dataObject != null) {
					DoDragDrop(dataObject, DragDropEffects.All);
				}
			}
		}

		protected override void OnDragEnter(DragEventArgs e)
		{
			base.OnDragEnter(e);
			e.Effect = DragDropEffects.Move | DragDropEffects.Copy | DragDropEffects.None;
		}

		protected override void OnDragOver(DragEventArgs e)
		{
			base.OnDragOver(e);
			
			Point clientcoordinate   = PointToClient(new Point(e.X, e.Y));
			AbstractBrowserNode node = (AbstractBrowserNode)GetNodeAt(clientcoordinate);
			
			DragDropEffects effect = DragDropEffects.None;
			
			if ((e.KeyState & 8) > 0) { // CTRL key pressed.
				effect = DragDropEffects.Copy;
			} else {
				effect = DragDropEffects.Move;
			}
			e.Effect = node.GetDragDropEffect(e.Data, effect);

			if (e.Effect != DragDropEffects.None) {
//				((Form)WorkbenchSingleton.Workbench).Activate();
//				Select();
				SelectedNode = node;
			}
		}

		protected override void OnDragDrop(DragEventArgs e)
		{
			base.OnDragDrop(e);

			Point clientcoordinate   = PointToClient(new Point(e.X, e.Y));
			AbstractBrowserNode node = (AbstractBrowserNode)GetNodeAt(clientcoordinate);

			if (node == null) {
				return;
			}
			node.DoDragDrop(e.Data, e.Effect);
			IProjectService projectService = (IProjectService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IProjectService));
			
			if(node.Parent != null) {
				SortUtility.QuickSort(node.Parent.Nodes, TreeNodeComparer.ProjectNode);
			}
			
			projectService.SaveCombine();
		}
		
		static ProjectBrowserNode GetRootProjectNode(AbstractBrowserNode node)
		{
			while (node != null) {
				if(node is ProjectBrowserNode) {
					return (ProjectBrowserNode)node;
				}
				node = (AbstractBrowserNode)node.Parent;
			}
			return null;
		}

		public static void MoveCopyFile(string filename, AbstractBrowserNode node, bool move, bool alreadyInPlace)
		{
//			FileType type      = FileUtility.GetFileType(filename);
			bool     directory = fileUtilityService.IsDirectory(filename);
			if (
//			    type == FileType.Dll ||
//			    type == FileType.Resource ||
			    directory) { // insert reference
			    return;
			    }
			System.Diagnostics.Debug.Assert(directory || File.Exists(filename), "ProjectBrowserEventHandler.MoveCopyFile : source file doesn't exist");
			
			// search "folder" in which the node contains
			while (!(node is DirectoryNode || node is ProjectBrowserNode))  {
				node = (AbstractBrowserNode)node.Parent;
				if (node == null) {
					return;
				}
			}

			string name          = Path.GetFileName(filename);
			string baseDirectory = node is DirectoryNode ? ((DirectoryNode)node).FolderName : node.Project.BaseDirectory;
			string newfilename   = alreadyInPlace ? filename : Path.Combine(baseDirectory, name);
			//Console.WriteLine(filename + " --- " + newfilename);
			
			string oldrelativename = fileUtilityService.AbsoluteToRelativePath(node.Project.BaseDirectory, filename);
			string newrelativename = fileUtilityService.AbsoluteToRelativePath(node.Project.BaseDirectory, newfilename);
			
			//Console.WriteLine(oldrelativename + " --- " + newrelativename);
			AbstractBrowserNode oldparent = DefaultDotNetNodeBuilder.GetPath(oldrelativename, GetRootProjectNode(node), false);          // TODO : change this for more projects
			AbstractBrowserNode newparent = DefaultDotNetNodeBuilder.GetPath(newrelativename, GetRootProjectNode(node), alreadyInPlace);

			AbstractBrowserNode oldnode   = null; // if oldnode is == null the old file doesn't exist in current tree

			if (oldparent != null) {
				foreach (AbstractBrowserNode childnode in oldparent.Nodes) {
					if (childnode.Text == name) {
						oldnode = childnode;
						break;
					}
				}
			}

			if (oldnode != null && oldnode is DirectoryNode) {
				// TODO can't move folders yet :(
				return;
			}

			if (oldparent == newparent && oldnode != null) {
				//Console.WriteLine("same loc!!!");
				// move/copy to the same location
				return;
			}
			
			if (!Directory.Exists(Path.GetDirectoryName(newfilename))) {
				Directory.CreateDirectory(Path.GetDirectoryName(newfilename));
			}
			
			IMessageService messageService =(IMessageService)ServiceManager.Services.GetService(typeof(IMessageService));
			
			if (move) {
				if (Path.GetFullPath(filename).ToLower() != Path.GetFullPath(newfilename).ToLower()) {
					try {
						File.Copy(filename, newfilename, true);
					} catch(UnauthorizedAccessException) {
						messageService.ShowError("${res:ICSharpCode.SharpDevelop.Commands.ProjectBrowser.AddFilesToProject.FileIsReadOnly}");
						return;
					}
					IFileService fileService = (IFileService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IFileService));
					fileService.RemoveFile(filename);
				}
				if (oldnode != null) {
					oldparent.Nodes.Remove(oldnode);
				}
			} else {
				if (Path.GetFullPath(filename).ToLower() != Path.GetFullPath(newfilename).ToLower()) {
					try {
						File.Copy(filename, newfilename, true);
					} catch(UnauthorizedAccessException) {
						messageService.ShowError("${res:ICSharpCode.SharpDevelop.Commands.ProjectBrowser.AddFilesToProject.FileIsReadOnly}");
						return;
					}
				}
			}
			
			if (!newparent.Project.IsFileInProject(newfilename)) {
				ProjectFile fInfo;
				IProjectService projectService = (IProjectService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IProjectService));
				
				if (newparent.Project.IsCompileable(newfilename)) {
					fInfo = projectService.AddFileToProject(newparent.Project, newfilename, BuildAction.Compile);
				} else {
					fInfo = projectService.AddFileToProject(newparent.Project, newfilename, BuildAction.Nothing);
				}
				
				AbstractBrowserNode pbn = new FileNode(fInfo);
				pbn.ContextmenuAddinTreePath = FileNode.ProjectFileContextMenuPath;
				SortUtility.SortedInsert(pbn, newparent.Nodes, TreeNodeComparer.ProjectNode);
				pbn.EnsureVisible();
				projectService.SaveCombine();
			}
		}


		// ********* Own events
		protected virtual void OnTitleChanged(EventArgs e)
		{
			if (TitleChanged != null) {
				TitleChanged(this, e);
			}
		}

		protected virtual void OnIconChanged(EventArgs e)
		{
			if (IconChanged != null) {
				IconChanged(this, e);
			}
		}

		public event EventHandler TitleChanged;
		public event EventHandler IconChanged;
		
		public void BringPadToFront()
		{
			if (!WorkbenchSingleton.Workbench.WorkbenchLayout.IsVisible(this)) {
				WorkbenchSingleton.Workbench.WorkbenchLayout.ShowPad(this);
			}
			WorkbenchSingleton.Workbench.WorkbenchLayout.ActivatePad(this);
		}		
	}
}