Fixed SD2-552: Class Browser not Refreshing

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@712 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Main/Base/Project/Src/Gui/Dialogs/NewProjectDialog.cs

@@ -245,7 +245,7 @@ namespace ICSharpCode.SharpDevelop.Project.Dialogs
 		{
 			FileProjectItem newItem = new FileProjectItem(project, ItemType.Compile);
 			newItem.Include = filename;
-			project.Items.Add(newItem);
+			ProjectService.AddProjectItem(project, newItem);
 			
 			StreamWriter sr = File.CreateText(filename);
 			sr.Write(StringParser.Parse(content, new string[,] { {"PROJECT", ((TextBox)ControlDictionary["nameTextBox"]).Text}, {"FILE", Path.GetFileName(filename)}}));

src/Main/Base/Project/Src/Gui/Pads/ClassBrowser/ClassBrowser.cs

@@ -118,7 +118,9 @@ namespace ICSharpCode.SharpDevelop.Gui
 				foreach (ICompilationUnit[] units in pending) {
 					foreach (TreeNode node in classBrowserTreeView.Nodes) {
 						ProjectNode prjNode = node as ProjectNode;
-						if (prjNode != null && prjNode.Project.IsFileInProject(units[1].FileName)) {
+						ICompilationUnit nonNullUnit = units[1] ?? units[0];
+						IProject project = nonNullUnit.ProjectContent.Project;
+						if (prjNode != null && prjNode.Project.IsFileInProject(nonNullUnit.FileName)) {
 							prjNode.UpdateParseInformation(units[0], units[1]);
 						}
 					}

src/Main/Base/Project/Src/Gui/Pads/ClassBrowser/Nodes/ProjectNode.cs

@@ -57,17 +57,18 @@ namespace ICSharpCode.SharpDevelop.Gui
 					wasUpdatedDictionary[c.FullyQualifiedName] = false;
 				}
 			}
-			foreach (IClass c in unit.Classes) {
-				TreeNode  path = GetNodeByPath(c.Namespace, true);
-				ClassNode node = GetNodeByName(path.Nodes, c.Name) as ClassNode;
-				if (node != null) {
-					node.Class = c;
-				} else {
-					new ClassNode(project, c).AddTo(path);
+			if (unit != null) {
+				foreach (IClass c in unit.Classes) {
+					TreeNode  path = GetNodeByPath(c.Namespace, true);
+					ClassNode node = GetNodeByName(path.Nodes, c.Name) as ClassNode;
+					if (node != null) {
+						node.Class = c;
+					} else {
+						new ClassNode(project, c).AddTo(path);
+					}
+					wasUpdatedDictionary[c.FullyQualifiedName] = true;
 				}
-				wasUpdatedDictionary[c.FullyQualifiedName] = true;
 			}
-			
 			foreach (KeyValuePair<string, bool> entry in wasUpdatedDictionary) {
 				if (!entry.Value) {
 					IClass c = classDictionary[entry.Key];
@@ -98,7 +99,9 @@ namespace ICSharpCode.SharpDevelop.Gui
 			
 			if (projectContent != null) {
 				Nodes.Clear();
-				new ReferenceFolderNode(project).AddTo(this);
+				ReferenceFolderNode referencesNode = new ReferenceFolderNode(project);
+				referencesNode.AddTo(this);
+				projectContent.ReferencedContentsChanged += delegate { referencesNode.UpdateReferenceNodes(); };
 				foreach (ProjectItem item in project.Items) {
 					switch (item.ItemType) {
 						case ItemType.Reference:

src/Main/Base/Project/Src/Gui/Pads/ClassBrowser/Nodes/ReferenceFolderNode.cs

@@ -56,6 +56,11 @@ namespace ICSharpCode.SharpDevelop.Gui
 		protected override void Initialize()
 		{
 			base.Initialize();
+			UpdateReferenceNodes();
+		}
+		
+		public void UpdateReferenceNodes()
+		{
 			Nodes.Clear();
 			foreach (ProjectItem item in project.Items) {
 				if (item.ItemType == ItemType.Reference) {

src/Main/Base/Project/Src/Gui/Pads/ProjectBrowser/TreeNodes/ReferenceNode.cs

@@ -45,7 +45,7 @@ namespace ICSharpCode.SharpDevelop.Project
 		public override void Delete()
 		{
 			IProject project = Project;
-			referenceProjectItem.Project.Items.Remove(referenceProjectItem);
+			ProjectService.RemoveProjectItem(referenceProjectItem.Project, referenceProjectItem);
 			Debug.Assert(Parent != null);
 			Debug.Assert(Parent is ReferenceFolder);
 			((ReferenceFolder)Parent).ShowReferences();

src/Main/Base/Project/Src/Services/ParserService/DefaultProjectContent.cs

@@ -410,6 +410,13 @@ namespace ICSharpCode.Core
 			RemoveEmptyNamespace(parent); // remove parent if also empty
 		}
 		
+		public void RemoveCompilationUnit(ICompilationUnit unit)
+		{
+			foreach (IClass c in unit.Classes) {
+				RemoveClass(c);
+			}
+		}
+		
 		public void UpdateCompilationUnit(ICompilationUnit oldUnit, ICompilationUnit parserOutput, string fileName, bool updateCommentTags)
 		{
 			if (updateCommentTags) {
@@ -417,13 +424,11 @@ namespace ICSharpCode.Core
 			}
 			
 			lock (namespaces) {
-				ICompilationUnit cu = (ICompilationUnit)parserOutput;
-				
 				if (oldUnit != null) {
-					RemoveClasses(oldUnit, cu);
+					RemoveClasses(oldUnit, parserOutput);
 				}
 				
-				foreach (IClass c in cu.Classes) {
+				foreach (IClass c in parserOutput.Classes) {
 					AddClassToNamespaceListInternal(c);
 				}
 			}
@@ -812,5 +817,14 @@ namespace ICSharpCode.Core
 			return new Position(null, -1, -1);
 		}
 		#endregion
+		
+		public event EventHandler ReferencedContentsChanged;
+		
+		protected virtual void OnReferencedContentsChanged(EventArgs e)
+		{
+			if (ReferencedContentsChanged != null) {
+				ReferencedContentsChanged(this, e);
+			}
+		}
 	}
 }

src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs

@@ -47,6 +47,8 @@ namespace ICSharpCode.Core
 			get;
 		}
 		
+		event EventHandler ReferencedContentsChanged;
+		
 		/// <summary>
 		/// Gets the properties of the language this project content was written in.
 		/// </summary>

src/Main/Base/Project/Src/Services/ParserService/ParseProjectContent.cs

@@ -10,6 +10,7 @@ using System;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Gui;
 
 namespace ICSharpCode.Core
 {
@@ -64,6 +65,7 @@ namespace ICSharpCode.Core
 				}
 			}
 			UpdateReferenceInterDependencies();
+			WorkbenchSingleton.SafeThreadAsyncCall(this, "OnReferencedContentsChanged", EventArgs.Empty);
 		}
 		
 		void UpdateReferenceInterDependencies()
@@ -76,8 +78,6 @@ namespace ICSharpCode.Core
 			}
 		}
 		
-		delegate void AddReferenceDelegate(ReferenceProjectItem reference, bool updateInterDependencies);
-		
 		void AddReference(ReferenceProjectItem reference, bool updateInterDependencies)
 		{
 			try {
@@ -88,28 +88,62 @@ namespace ICSharpCode.Core
 				if (updateInterDependencies) {
 					UpdateReferenceInterDependencies();
 				}
+				WorkbenchSingleton.SafeThreadAsyncCall(this, "OnReferencedContentsChanged", EventArgs.Empty);
 			} catch (Exception e) {
 				MessageService.ShowError(e);
 			}
 		}
 		
+		// waitcallback for AddReference
+		void AddReference(object state)
+		{
+			AddReference((ReferenceProjectItem)state, true);
+		}
+		
 		void OnProjectItemAdded(object sender, ProjectItemEventArgs e)
 		{
 			if (e.Project != project) return;
+			
 			ReferenceProjectItem reference = e.ProjectItem as ReferenceProjectItem;
 			if (reference != null) {
-				new AddReferenceDelegate(AddReference).BeginInvoke(reference, true, null, null);
+				System.Threading.ThreadPool.QueueUserWorkItem(AddReference, reference);
 			}
-			if (e.ProjectItem.ItemType == ItemType.Import) {
-				UpdateDefaultImports(project.Items.ToArray());
+			switch (e.ProjectItem.ItemType) {
+				case ItemType.Import:
+					UpdateDefaultImports(project.Items.ToArray());
+					break;
+				case ItemType.Compile:
+					ParserService.EnqueueForParsing(e.ProjectItem.FileName);
+					break;
 			}
 		}
 		
 		void OnProjectItemRemoved(object sender, ProjectItemEventArgs e)
 		{
 			if (e.Project != project) return;
-			if (e.ProjectItem.ItemType == ItemType.Import) {
-				UpdateDefaultImports(project.Items.ToArray());
+			
+			ReferenceProjectItem reference = e.ProjectItem as ReferenceProjectItem;
+			if (reference != null) {
+				try {
+					IProjectContent referencedContent = ProjectContentRegistry.GetProjectContentForReference(reference);
+					if (referencedContent != null) {
+						ReferencedContents.Remove(referencedContent);
+						OnReferencedContentsChanged(EventArgs.Empty);
+					}
+				} catch (Exception ex) {
+					MessageService.ShowError(ex);
+				}
+			}
+			
+			switch (e.ProjectItem.ItemType) {
+				case ItemType.Import:
+					UpdateDefaultImports(project.Items.ToArray());
+					break;
+				case ItemType.Compile:
+					ParseInformation info = ParserService.GetParseInformation(e.ProjectItem.FileName);
+					RemoveCompilationUnit(info.MostRecentCompilationUnit);
+					ParserService.ClearParseInformation(e.ProjectItem.FileName);
+					break;
 			}
 		}
 		

src/Main/Base/Project/Src/Services/ParserService/ParserService.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.Core
 		static ParserDescriptor[] parser;
 		
 		static Dictionary<IProject, IProjectContent> projectContents = new Dictionary<IProject, IProjectContent>();
-		static Dictionary<string, ParseInformation> parsings        = new Dictionary<string, ParseInformation>();
+		static Dictionary<string, ParseInformation> parsings = new Dictionary<string, ParseInformation>();
 		
 		public static IProjectContent CurrentProjectContent {
 			[DebuggerStepThrough]
@@ -79,6 +79,7 @@ namespace ICSharpCode.Core
 					content.Dispose();
 				}
 				projectContents.Clear();
+				parsings.Clear();
 			}
 		}
 		
@@ -162,6 +163,33 @@ namespace ICSharpCode.Core
 			return null;
 		}
 		
+		static Queue<KeyValuePair<string, string>> parseQueue = new Queue<KeyValuePair<string, string>>();
+		
+		static void ParseQueue()
+		{
+			while (true) {
+				KeyValuePair<string, string> entry;
+				lock (parseQueue) {
+					if (parseQueue.Count == 0)
+						return;
+					entry = parseQueue.Dequeue();
+				}
+				ParseFile(entry.Key, entry.Value);
+			}
+		}
+		
+		public static void EnqueueForParsing(string fileName)
+		{
+			EnqueueForParsing(fileName, GetParseableFileContent(fileName));
+		}
+		
+		public static void EnqueueForParsing(string fileName, string fileContent)
+		{
+			lock (parseQueue) {
+				parseQueue.Enqueue(new KeyValuePair<string, string>(fileName, fileContent));
+			}
+		}
+		
 		public static void StartParserThread()
 		{
 			abortParserUpdateThread = false;
@@ -178,7 +206,7 @@ namespace ICSharpCode.Core
 		
 		static bool abortParserUpdateThread = false;
 		
-		static Dictionary<string, int> lastUpdateSize = new Dictionary<string, int>();
+		static Dictionary<string, int> lastUpdateHash = new Dictionary<string, int>();
 		
 		static void ParserUpdateThread()
 		{
@@ -188,6 +216,7 @@ namespace ICSharpCode.Core
 			
 			while (!abortParserUpdateThread) {
 				try {
+					ParseQueue();
 					ParserUpdateStep();
 				} catch (Exception e) {
 					ICSharpCode.Core.MessageService.ShowError(e);
@@ -239,10 +268,10 @@ namespace ICSharpCode.Core
 							text = editable.Text;
 							if (text == null) return;
 						}
-						int hash = text.Length;
-						if (!lastUpdateSize.ContainsKey(fileName) || (int)lastUpdateSize[fileName] != hash) {
+						int hash = text.GetHashCode();
+						if (!lastUpdateHash.ContainsKey(fileName) || lastUpdateHash[fileName] != hash) {
 							parseInformation = ParseFile(fileName, text, !viewContent.IsUntitled, true);
-							lastUpdateSize[fileName] = hash;
+							lastUpdateHash[fileName] = hash;
 							updated = true;
 						}
 						if (updated) {
@@ -309,9 +338,21 @@ namespace ICSharpCode.Core
 				if (defaultProjectContent == null) {
 					lock (projectContents) {
 						if (defaultProjectContent == null) {
+							LoggingService.Info("Creating default project content");
 							defaultProjectContent = new DefaultProjectContent();
 							defaultProjectContent.ReferencedContents.Add(ProjectContentRegistry.Mscorlib);
-							defaultProjectContent.ReferencedContents.Add(ProjectContentRegistry.WinForms);
+							string[] defaultReferences = new string[] {
+								"System",
+								"System.Data",
+								"System.Drawing",
+								"System.Windows.Forms",
+								"System.XML",
+							};
+							foreach (string defaultReference in defaultReferences) {
+								ReferenceProjectItem item = new ReferenceProjectItem(null, defaultReference);
+								IProjectContent pc = ProjectContentRegistry.GetProjectContentForReference(item);
+								defaultProjectContent.ReferencedContents.Add(pc);
+							}
 						}
 					}
 				}
@@ -432,6 +473,18 @@ namespace ICSharpCode.Core
 			return parsings[fileName];
 		}
 		
+		public static void ClearParseInformation(string fileName)
+		{
+			if (fileName == null || fileName.Length == 0) {
+				return;
+			}
+			if (parsings.ContainsKey(fileName)) {
+				ParseInformation parseInfo = parsings[fileName];
+				parsings.Remove(fileName);
+				OnParseInformationUpdated(new ParseInformationEventArgs(fileName, parseInfo, null));
+			}
+		}
+		
 		public static IExpressionFinder GetExpressionFinder(string fileName)
 		{
 			IParser parser = GetParser(fileName);
@@ -499,7 +552,7 @@ namespace ICSharpCode.Core
 				ParseInformationUpdated(null, e);
 			}
 		}
-
+		
 		public static event ParseInformationEventHandler ParseInformationUpdated;
 	}
 }

src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs

@@ -13,6 +13,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
 
+using ICSharpCode.SharpDevelop.Gui;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.Core;
 
@@ -108,11 +109,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public void InitializeReferences()
 		{
+			bool changed = false;
 			if (initialized) {
 				if (missingNames != null) {
 					for (int i = 0; i < missingNames.Count; i++) {
 						IProjectContent content = ProjectContentRegistry.GetExistingProjectContent((AssemblyName)missingNames[i]);
 						if (content != null) {
+							changed = true;
 							ReferencedContents.Add(content);
 							missingNames.RemoveAt(i--);
 						}
@@ -121,12 +124,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 						missingNames = null;
 					}
 				}
+				if (changed)
+					WorkbenchSingleton.SafeThreadAsyncCall(this, "OnReferencedContentsChanged", EventArgs.Empty);
 				return;
 			}
 			initialized = true;
 			foreach (AssemblyName name in referencedAssemblies) {
 				IProjectContent content = ProjectContentRegistry.GetExistingProjectContent(name);
 				if (content != null) {
+					changed = true;
 					ReferencedContents.Add(content);
 				} else {
 					if (missingNames == null)
@@ -134,6 +140,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 					missingNames.Add(name);
 				}
 			}
+			if (changed)
+				WorkbenchSingleton.SafeThreadAsyncCall(this, "OnReferencedContentsChanged", EventArgs.Empty);
 		}
 		
 		public override string ToString()

src/Main/Base/Project/Src/Services/ProjectService/ProjectService.cs

@@ -138,6 +138,7 @@ namespace ICSharpCode.SharpDevelop.Project
 						ProjectItem item =project.Items[i];
 						if (FileUtility.IsBaseDirectory(fileName, item.FileName)) {
 							project.Items.RemoveAt(i);
+							OnProjectItemRemoved(new ProjectItemEventArgs(project, item));
 						} else {
 							++i;
 						}

src/Main/StartUp/Project/SharpDevelopMain.cs

@@ -174,15 +174,26 @@ namespace ICSharpCode.SharpDevelop
 				
 				InitializeCore();
 				
+				bool exception = false;
 				// finally start the workbench.
 				try {
 					LoggingService.Info("Starting workbench...");
 					new StartWorkbenchCommand().Run(SplashScreenForm.GetRequestedFileList());
+				} catch {
+					exception = true;
+					throw;
 				} finally {
 					LoggingService.Info("Unloading services...");
-					ProjectService.CloseSolution();
-					FileService.Unload();
-					PropertyService.Save();
+					try {
+						ProjectService.CloseSolution();
+						FileService.Unload();
+						PropertyService.Save();
+					} catch (Exception ex) {
+						if (exception)
+							LoggingService.Warn("Exception during unloading after exception", ex);
+						else
+							MessageService.ShowError(ex);
+					}
 				}
 			} finally {
 				LoggingService.Info("Leaving RunApplication()");