Display parsing progress in status bar when opening project.

Fixed cross thread calls on SWF controls.

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

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Project/VBNetProject.cs

@@ -220,18 +220,23 @@ namespace VBNetBinding
 		public VBNetProject(string fileName, string projectName)
 		{
 			this.Name = projectName;
-			Language = "VBNet";
-			LanguageProperties = ICSharpCode.SharpDevelop.Dom.LanguageProperties.VBNet;
+			InitVB();
 			SetupProject(fileName);
 			IdGuid = BaseConfiguration["ProjectGuid"];
 		}
 		
 		public VBNetProject(ProjectCreateInformation info)
 		{
-			Language = "VBNet";
-			LanguageProperties = ICSharpCode.SharpDevelop.Dom.LanguageProperties.VBNet;
+			InitVB();
 			Create(info);
 			imports.Add(@"$(MSBuildBinPath)\Microsoft.VisualBasic.Targets");
 		}
+		
+		void InitVB()
+		{
+			Language = "VBNet";
+			LanguageProperties = ICSharpCode.SharpDevelop.Dom.LanguageProperties.VBNet;
+			BuildConstantSeparator = ',';
+		}
 	}
 }

src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs

@@ -12,120 +12,141 @@ using ICSharpCode.Core;
 namespace ICSharpCode.SharpDevelop.Dom
 {
 	/// <summary>
-	/// Context used to resolve lazy return types.
+	/// The GetClassReturnType is used when the class should be resolved on demand, but the
+	/// full name is already known. Example: ReflectionReturnType
 	/// </summary>
-	public interface IResolveContext
+	public sealed class GetClassReturnType : ProxyReturnType
 	{
-		IReturnType Resolve(object data);
-	}
-	
-	/// <summary>
-	/// The LazyReturnType is the most used return type:
-	/// It is not bound to a class, but only resolved on demand.
-	/// The LazyReturnType is nearly always used to point at a <see cref="DefaultReturnType"/>.
-	/// </summary>
-	public sealed class LazyReturnType : ProxyReturnType
-	{
-		IResolveContext context;
-		object data;
+		IProjectContent content;
+		string fullName;
 		
-		public LazyReturnType(IResolveContext context, object data)
+		public GetClassReturnType(IProjectContent content, string fullName)
 		{
-			if (context == null)
-				throw new ArgumentNullException("context");
-			if (data == null)
-				throw new ArgumentNullException("data");
-			this.context = context;
-			this.data = data;
+			this.content = content;
+			this.fullName = fullName;
 		}
 		
 		public override bool Equals(object o)
 		{
-			LazyReturnType rt = o as LazyReturnType;
+			GetClassReturnType rt = o as GetClassReturnType;
 			if (rt == null) return false;
-			if (!context.Equals(rt.context)) return false;
-			return data.Equals(rt.data);
+			return fullName == rt.fullName;
 		}
 		
 		public override int GetHashCode()
 		{
-			return context.GetHashCode() ^ data.GetHashCode();
+			return content.GetHashCode() ^ fullName.GetHashCode();
 		}
 		
 		public override IReturnType BaseType {
 			get {
-				return context.Resolve(data);
+				IClass c = content.GetClass(fullName);
+				return (c != null) ? c.DefaultReturnType : null;
 			}
 		}
 		
-		public override string ToString()
-		{
-			return String.Format("[LazyReturnType: context = {0}, data = {1}]",
-			                     context,
-			                     data);
+		public override string FullyQualifiedName {
+			get {
+				return fullName;
+			}
 		}
-	}
-	
-	public class GetClassResolveContext : IResolveContext
-	{
-		IProjectContent content;
 		
-		public GetClassResolveContext(IProjectContent content)
-		{
-			this.content = content;
+		public override string Name {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.Name : fullName.Substring(fullName.LastIndexOf('.') + 1);
+			}
 		}
 		
-		public IReturnType Resolve(object data)
-		{
-			IClass c = content.GetClass((string)data);
-			return (c != null) ? c.DefaultReturnType : null;
+		public override string Namespace {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.Namespace : fullName.Substring(0, fullName.LastIndexOf('.'));
+			}
 		}
 		
-		public override bool Equals(object obj)
-		{
-			GetClassResolveContext b = obj as GetClassResolveContext;
-			if (b == null) return false;
-			return content == b.content;
+		public override string DotNetName {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.DotNetName : fullName;
+			}
 		}
 		
-		public override int GetHashCode()
+		public override string ToString()
 		{
-			return content.GetHashCode();
+			return String.Format("[GetClassReturnType: {0}]", fullName);
 		}
 	}
 	
-	public class SearchClassResolveContext : IResolveContext
+	/// <summary>
+	/// The SearchClassReturnType is used when only a part of the class name is known and the
+	/// type can only be resolved on demand (the ConvertVisitor uses SearchClassReturnType's).
+	/// </summary>
+	public sealed class SearchClassReturnType : ProxyReturnType
 	{
 		IClass declaringClass;
 		int caretLine;
 		int caretColumn;
+		string name;
 		
-		public SearchClassResolveContext(IClass declaringClass, int caretLine, int caretColumn)
+		public SearchClassReturnType(IClass declaringClass, int caretLine, int caretColumn, string name)
 		{
 			this.declaringClass = declaringClass;
 			this.caretLine = caretLine;
 			this.caretColumn = caretColumn;
+			this.name = name;
 		}
 		
-		public IReturnType Resolve(object data)
+		public override bool Equals(object o)
 		{
-			IClass c = declaringClass.ProjectContent.SearchType((string)data, declaringClass, caretLine, caretColumn);
-			return (c != null) ? c.DefaultReturnType : null;
+			SearchClassReturnType rt = o as SearchClassReturnType;
+			if (rt == null) return false;
+			if (declaringClass != rt.declaringClass) return false;
+			return name == rt.name;
 		}
 		
-		public override bool Equals(object obj)
+		public override int GetHashCode()
 		{
-			SearchClassResolveContext b = obj as SearchClassResolveContext;
-			if (b == null) return false;
-			if (declaringClass != b.declaringClass) return false;
-			if (caretLine != b.caretLine) return false;
-			if (caretColumn != b.caretColumn) return false;
-			return true;
+			return declaringClass.GetHashCode() ^ name.GetHashCode();
 		}
 		
-		public override int GetHashCode()
+		public override IReturnType BaseType {
+			get {
+				IClass c = declaringClass.ProjectContent.SearchType(name, declaringClass, caretLine, caretColumn);
+				return (c != null) ? c.DefaultReturnType : null;
+			}
+		}
+		
+		public override string FullyQualifiedName {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.FullyQualifiedName : name;
+			}
+		}
+		
+		public override string Name {
+			get {
+				return name;
+			}
+		}
+		
+		public override string Namespace {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.Namespace : "?";
+			}
+		}
+		
+		public override string DotNetName {
+			get {
+				IReturnType baseType = BaseType;
+				return (baseType != null) ? baseType.DotNetName : name;
+			}
+		}
+		
+		public override string ToString()
 		{
-			return declaringClass.GetHashCode() ^ caretLine ^ caretColumn;
+			return String.Format("[SearchClassReturnType: {0}]", name);
 		}
 	}
 }

src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs

@@ -23,28 +23,28 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public virtual string FullyQualifiedName {
 			get {
 				IReturnType baseType = BaseType;
-				return (baseType != null) ? baseType.FullyQualifiedName : null;
+				return (baseType != null) ? baseType.FullyQualifiedName : "?";
 			}
 		}
 		
 		public virtual string Name {
 			get {
 				IReturnType baseType = BaseType;
-				return (baseType != null) ? baseType.Name : null;
+				return (baseType != null) ? baseType.Name : "?";
 			}
 		}
 		
 		public virtual string Namespace {
 			get {
 				IReturnType baseType = BaseType;
-				return (baseType != null) ? baseType.Namespace : null;
+				return (baseType != null) ? baseType.Namespace : "?";
 			}
 		}
 		
 		public virtual string DotNetName {
 			get {
 				IReturnType baseType = BaseType;
-				return (baseType != null) ? baseType.DotNetName : null;
+				return (baseType != null) ? baseType.DotNetName : "?";
 			}
 		}
 		

src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs

@@ -362,8 +362,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, int caretLine, int caretColumn)
 		{
 			if (reference.IsNull) return null;
-			IResolveContext context = new SearchClassResolveContext(callingClass, caretLine, caretColumn);
-			IReturnType t = new LazyReturnType(context, reference.SystemType);
+			IReturnType t = new SearchClassReturnType(callingClass, caretLine, caretColumn, reference.SystemType);
 			if (reference.GenericTypes.Count > 0) {
 				List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count);
 				for (int i = 0; i < reference.GenericTypes.Count; ++i) {

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs

@@ -25,7 +25,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			if (type.IsArray) {
 				return MakeArray(type, Create(content, type.GetElementType()));
 			} else {
-				return new LazyReturnType(new GetClassResolveContext(content), name);
+				return new GetClassReturnType(content, name);
 			}
 		}
 		

src/Main/Base/Project/Src/Dom/ResolveResult.cs

@@ -73,27 +73,27 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public virtual ArrayList GetCompletionData(IProjectContent projectContent)
 		{
-			return GetCompletionData(false);
+			return GetCompletionData(projectContent.Language, false);
 		}
 		
-		protected ArrayList GetCompletionData(bool showStatic)
+		protected ArrayList GetCompletionData(LanguageProperties language, bool showStatic)
 		{
 			if (resolvedType == null) return null;
 			ArrayList res = new ArrayList();
 			foreach (IMethod m in resolvedType.GetMethods()) {
-				if (m.IsStatic == showStatic)
+				if (language.ShowMember(m, showStatic))
 					res.Add(m);
 			}
 			foreach (IEvent e in resolvedType.GetEvents()) {
-				if (e.IsStatic == showStatic)
+				if (language.ShowMember(e, showStatic))
 					res.Add(e);
 			}
 			foreach (IField f in resolvedType.GetFields()) {
-				if (f.IsStatic == showStatic)
+				if (language.ShowMember(f, showStatic))
 					res.Add(f);
 			}
 			foreach (IProperty p in resolvedType.GetProperties()) {
-				if (p.IsStatic == showStatic)
+				if (language.ShowMember(p, showStatic))
 					res.Add(p);
 			}
 			return res;
@@ -241,7 +241,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override ArrayList GetCompletionData(IProjectContent projectContent)
 		{
-			ArrayList ar = GetCompletionData(true);
+			ArrayList ar = GetCompletionData(projectContent.Language, true);
 			ar.AddRange(resolvedClass.InnerClasses);
 			return ar;
 		}

src/Main/Base/Project/Src/Gui/Components/StatusBar/SdStatusBar.cs

@@ -13,7 +13,8 @@ namespace ICSharpCode.SharpDevelop.Gui
 {
 	public class SdStatusBar : StatusStrip, IProgressMonitor
 	{
-		ProgressBar statusProgressBar      = new ProgressBar();
+		ToolStripProgressBar statusProgressBar     = new ToolStripProgressBar();
+		ToolStripStatusLabel jobNamePanel          = new ToolStripStatusLabel();
 		
 		ToolStripStatusLabel  txtStatusBarPanel    = new ToolStripStatusLabel();
 		ToolStripStatusLabel  cursorStatusBarPanel = new ToolStripStatusLabel();
@@ -44,92 +45,126 @@ namespace ICSharpCode.SharpDevelop.Gui
 		
 		public SdStatusBar()
 		{
+			
 //			txtStatusBarPanel.Width = 500;
 //			txtStatusBarPanel.AutoSize = StatusBarPanelAutoSize.Spring;
 //			Panels.Add(txtStatusBarPanel);
 //	//		manager.Add(new StatusBarContributionItem("TextPanel", txtStatusBarPanel));
-//			
+//
 //			statusProgressBar.Width  = 200;
 //			statusProgressBar.Height = 14;
 //			statusProgressBar.Location = new Point(160, 6);
 //			statusProgressBar.Minimum = 0;
 //			statusProgressBar.Visible = false;
 //			Controls.Add(statusProgressBar);
-//			
+//
 //			cursorStatusBarPanel.Width = 200;
 //			cursorStatusBarPanel.AutoSize = StatusBarPanelAutoSize.None;
 //			cursorStatusBarPanel.Alignment = HorizontalAlignment.Left;
 //			Panels.Add(cursorStatusBarPanel);
-//				
+//
 //			modeStatusBarPanel.Width = 44;
 //			modeStatusBarPanel.AutoSize = StatusBarPanelAutoSize.None;
 //			modeStatusBarPanel.Alignment = HorizontalAlignment.Right;
 //			Panels.Add(modeStatusBarPanel);
+			ToolStripStatusLabel  springLabel = new ToolStripStatusLabel();
+			springLabel.Spring = true;
+			jobNamePanel.Visible = false;
+			statusProgressBar.Visible = false;
+			statusProgressBar.Size = new Size(100, 20);
 			
-			Items.AddRange(new ToolStripItem[] { txtStatusBarPanel, cursorStatusBarPanel, modeStatusBarPanel });
-
-			
-	//		manager.Add(new StatusBarContributionItem("ProgressBar", statusProgressBar));
+			Items.AddRange(new ToolStripItem[] { txtStatusBarPanel, springLabel, jobNamePanel, statusProgressBar, cursorStatusBarPanel, modeStatusBarPanel });
+		}
+		
+		protected override void OnHandleCreated(EventArgs e)
+		{
+			base.OnHandleCreated(e);
+			UpdateText();
 		}
 		
 		public void ShowErrorMessage(string message)
 		{
-			txtStatusBarPanel.Text = "Error : " + message;
+			SetMessage("Error : " + message);
 		}
 		
 		public void ShowErrorMessage(Image image, string message)
 		{
-			txtStatusBarPanel.Text = "Error : " + message;
+			SetMessage(image, "Error : " + message);
 		}
 		
+		string currentMessage;
+		
 		public void SetMessage(string message)
 		{
-			txtStatusBarPanel.Text = message;
+			currentMessage = message;
+			if (this.IsHandleCreated)
+				BeginInvoke(new MethodInvoker(UpdateText));
+		}
+		
+		void UpdateText()
+		{
+			txtStatusBarPanel.Text = currentMessage;
 		}
 		
 		public void SetMessage(Image image, string message)
 		{
-			txtStatusBarPanel.Text = message;
+			SetMessage(message);
 		}
 		
 		// Progress Monitor implementation
-		string oldMessage = null;
+		int totalWork;
+		
 		public void BeginTask(string name, int totalWork)
 		{
-			oldMessage = txtStatusBarPanel.Text;
-			SetMessage(name);
-			statusProgressBar.Maximum = totalWork;
-			statusProgressBar.Left = txtStatusBarPanel.Width - statusProgressBar.Width - 4; 
-			statusProgressBar.Visible = true;
+			taskName = name;
+			this.totalWork = totalWork;
+			this.BeginInvoke(new MethodInvoker(MakeVisible));
 		}
 		
-		public void Worked(int work)
+		void MakeVisible()
 		{
-			statusProgressBar.Value = work;
+			statusProgressBar.Value = 0;
+			statusProgressBar.Maximum = totalWork;
+			jobNamePanel.Text = taskName;
+			jobNamePanel.Visible = true;
+			statusProgressBar.Visible = true;
 		}
 		
-		public void Done()
+		void MakeInvisible()
 		{
-			SetMessage(oldMessage);
-			oldMessage = null;
+			jobNamePanel.Visible = false;
 			statusProgressBar.Visible = false;
 		}
 		
-		public bool Canceled {
+		int workDone;
+		
+		public int WorkDone {
 			get {
-				return oldMessage == null;
+				return workDone;
 			}
 			set {
-				Done();
+				if (workDone == value) return;
+				workDone = value;
+				this.BeginInvoke(new MethodInvoker(SetWorkDone));
 			}
 		}
 		
+		void SetWorkDone()
+		{
+			statusProgressBar.Value = workDone;
+		}
+		
+		public void Done()
+		{
+			taskName = null;
+			this.BeginInvoke(new MethodInvoker(MakeInvisible));
+		}
+		
+		string taskName;
+		
 		public string TaskName {
 			get {
-				return "";
-			}
-			set {
-				
+				return taskName;
 			}
 		}
 	}

src/Main/Base/Project/Src/Gui/IProgressMonitor.cs

@@ -8,25 +8,22 @@
 namespace ICSharpCode.SharpDevelop.Gui
 {
 	/// <summary>
-	/// This is a basic interface to a "progress bar" type of 
+	/// This is a basic interface to a "progress bar" type of
 	/// control.
 	/// </summary>
-	public interface IProgressMonitor 
+	public interface IProgressMonitor
 	{
 		void BeginTask(string name, int totalWork);
 		
-		void Worked(int work);
-		
-		void Done();
-		
-		bool Canceled {
+		int WorkDone {
 			get;
 			set;
 		}
 		
+		void Done();
+		
 		string TaskName {
 			get;
-			set;
 		}
 	}
 }

src/Main/Base/Project/Src/Gui/WorkbenchSingleton.cs

@@ -40,7 +40,6 @@ namespace ICSharpCode.SharpDevelop.Gui
 		
 		static WorkbenchSingleton()
 		{
-			caller = new STAThreadCaller();
 			PropertyService.PropertyChanged += new PropertyChangedEventHandler(TrackPropertyChanges);
 		}
 		
@@ -64,6 +63,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 		public static void InitializeWorkbench()
 		{
 			workbench = new DefaultWorkbench();
+			caller = new STAThreadCaller(workbench);
 			
 			workbench.InitializeWorkspace();
 			
@@ -80,42 +80,48 @@ namespace ICSharpCode.SharpDevelop.Gui
 		/// </summary>
 		public class STAThreadCaller
 		{
-			delegate object PerformCallDelegate(/*object target, string methodName, object[] arguments*/);
+			delegate object PerformCallDelegate(object target, string methodName, object[] arguments);
 			
-			object target;
-			string methodName;
-			object[] arguments;
-			Form  form = (Form)WorkbenchSingleton.Workbench;
+			Control ctl;
 			PerformCallDelegate performCallDelegate;
 			
 			#if DEBUG
 			string callerStack;
 			#endif
 			
-			public STAThreadCaller()
+			public STAThreadCaller(Control ctl)
 			{
+				this.ctl = ctl;
 				performCallDelegate = new PerformCallDelegate(DoPerformCall);
 			}
 			
-			public object Call(object target, string methodName, params object[] arguments)
+			public object Call(object target, string methodName, object[] arguments)
 			{
 				if (target == null) {
-					throw new System.ArgumentNullException("target");
+					throw new ArgumentNullException("target");
+				}
+				
+				#if DEBUG
+				callerStack = Environment.StackTrace;
+				#endif
+				
+				return ctl.Invoke(performCallDelegate, new object[] {target, methodName, arguments});
+			}
+			
+			public void BeginCall(object target, string methodName, object[] arguments)
+			{
+				if (target == null) {
+					throw new ArgumentNullException("target");
 				}
-
-				this.target     = target;
-				this.methodName = methodName;
-				this.arguments  = arguments;
 				
 				#if DEBUG
 				callerStack = Environment.StackTrace;
 				#endif
 				
-				// TODO: This doesn't look like it's thread-safe, we're calling the target directly!
-				return DoPerformCall();
+				ctl.BeginInvoke(performCallDelegate, new object[] {target, methodName, arguments});
 			}
 			
-			object DoPerformCall( /*object target, string methodName, object[] arguments */)
+			object DoPerformCall(object target, string methodName, object[] arguments)
 			{
 				MethodInfo methodInfo = null;
 				if (target is Type) {
@@ -134,7 +140,10 @@ namespace ICSharpCode.SharpDevelop.Gui
 							return methodInfo.Invoke(target, arguments);
 						}
 					} catch (Exception ex) {
-						MessageService.ShowError(ex, "Exception got. ");
+						if (ex is TargetInvocationException && ex.InnerException != null) {
+							ex = ex.InnerException;
+						}
+						MessageService.ShowError(ex, "Exception got.");
 						#if DEBUG
 						Console.WriteLine("Stacktrace of source thread:");
 						Console.WriteLine(callerStack);
@@ -144,24 +153,25 @@ namespace ICSharpCode.SharpDevelop.Gui
 				}
 				return null;
 			}
-			
-			object InternalSafeThreadCall(/*object target, string methodName, params object[] arguments*/)
-			{
-				if (form.InvokeRequired) {
-					return form.Invoke(performCallDelegate, null /*new object[] { target, methodName, arguments } */);
-				} else {
-					return DoPerformCall(/*target, methodName, arguments*/);
-				}
-			}
 		}
 		
 		/// <summary>
-		/// Makes a call GUI threadsafe.
+		/// Makes a call GUI threadsafe. WARNING: This method waits for the result of the
+		/// operation, which can result in a dead-lock when the main thread waits for this
+		/// thread to exit!
 		/// </summary>
 		public static object SafeThreadCall(object target, string methodName, params object[] arguments)
 		{
 			return caller.Call(target, methodName, arguments);
 		}
+		
+		/// <summary>
+		/// Makes a call GUI threadsafe without waiting for the returned value.
+		/// </summary>
+		public static void SafeThreadAsyncCall(object target, string methodName, params object[] arguments)
+		{
+			caller.BeginCall(target, methodName, arguments);
+		}
 		#endregion
 		
 		static void OnWorkbenchCreated()

src/Main/Base/Project/Src/Project/MSBuildProject.cs

@@ -20,6 +20,8 @@ namespace ICSharpCode.SharpDevelop.Project
 		{
 		}
 		
+		protected char BuildConstantSeparator = ';';
+		
 		protected void Create(ProjectCreateInformation information)
 		{
 			Name = information.ProjectName;
@@ -36,7 +38,7 @@ namespace ICSharpCode.SharpDevelop.Project
 			configurations["Debug|AnyCPU"] = new PropertyGroup();
 			configurations["Debug|AnyCPU"]["OutputPath"] = @"bin\Debug\";
 			configurations["Debug|AnyCPU"]["Optimize"] = "false";
-			configurations["Debug|AnyCPU"]["DefineConstants"] = "DEBUG;TRACE";
+			configurations["Debug|AnyCPU"]["DefineConstants"] = "DEBUG" + BuildConstantSeparator + "TRACE";
 			
 			configurations["Release|AnyCPU"] = new PropertyGroup();
 			configurations["Release|AnyCPU"]["OutputPath"] = @"bin\Release\";
@@ -62,7 +64,7 @@ namespace ICSharpCode.SharpDevelop.Project
 		readonly static Regex configurationRegEx = new Regex(@"\s*'.*'\s*==\s*'(?<configuration>.*)'", RegexOptions.Compiled);
 		
 		protected void SetupProject(string projectFileName)
-		{	
+		{
 			this.fileName = projectFileName;
 			using (XmlTextReader reader = new XmlTextReader(projectFileName)) {
 				while (reader.Read()) {
@@ -246,11 +248,11 @@ namespace ICSharpCode.SharpDevelop.Project
 //		static void BeforeBuild()
 //		{
 //			TaskService.NotifyTaskChange();
-//			
+//
 //			StatusBarService.SetMessage("${res:MainWindow.StatusBar.CompilingMessage}");
-//			
+//
 //			StringParser.Properties["Project"] = this.Name;
-//			
+//
 //			TaskService.BuildMessageViewCategory.AppendText(StringParser.Parse("${res:MainWindow.CompilerMessages.BuildStartedOutput}", new string[,] {
 //			                                                                 	{"PROJECT", this.Name},
 //			                                                                 	{"CONFIG", this.Configuration + "|" + this.Platform}
@@ -259,12 +261,12 @@ namespace ICSharpCode.SharpDevelop.Project
 //			// TODO :BEFORE COMPILE ACTION.
 //			//TaskService.CompilerOutput += StringParser.Parse("${res:MainWindow.CompilerMessages.ExecuteScript}", new string[,] { {"SCRIPT", conf.ExecuteBeforeBuild} }) + "\n";
 //		}
-//		
+//
 //		static void AfterBuild()
 //		{
 //			// TODO: After COMPILE ACTION.
 //			//TaskService.CompilerOutput += StringParser.Parse("${res:MainWindow.CompilerMessages.ExecuteScript}", new string[,] { {"SCRIPT", conf.ExecuteAfterBuild} }) + "\n";
-//			
+//
 //			TaskService.BuildMessageViewCategory.AppendText(StringParser.Parse("${res:MainWindow.CompilerMessages.ProjectStatsOutput}", new string[,] { {"ERRORS", TaskService.Errors.ToString()}, {"WARNINGS", TaskService.Warnings.ToString()} }) + Environment.NewLine + Environment.NewLine);
 //			isDirty = TaskService.Errors != 0;
 //		}

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

@@ -71,6 +71,12 @@ namespace ICSharpCode.Core
 			}
 		}
 		
+		public List<IProjectContent> ReferencedContents {
+			get {
+				return referencedContents;
+			}
+		}
+		
 		LanguageProperties language = LanguageProperties.CSharp;
 		
 		/// <summary>
@@ -163,6 +169,7 @@ namespace ICSharpCode.Core
 		internal void Initialize1()
 		{
 			foreach (ProjectItem item in project.Items.ToArray()) {
+				if (project == null) return; // abort initialization
 				switch (item.ItemType) {
 					case ItemType.Reference:
 					case ItemType.ProjectReference:
@@ -177,14 +184,29 @@ namespace ICSharpCode.Core
 		
 		internal void Initialize2()
 		{
-			foreach (ProjectItem item in project.Items.ToArray()) {
-				if (item.ItemType == ItemType.Compile) {
-					ParseInformation parseInfo = ParserService.ParseFile(item.FileName, null, true, false);
-					if (parseInfo != null) {
-						UpdateCompilationUnit(null, parseInfo.BestCompilationUnit as ICompilationUnit, item.FileName, true);
+			ProjectItem[] arr = project.Items.ToArray();
+			try {
+				StatusBarService.ProgressMonitor.BeginTask("Parsing " + project.Name + "...", arr.Length);
+				for (int i = 0; i < arr.Length; ++i) {
+					ProjectItem item = arr[i];
+					if ((i % 5) == 2)
+						StatusBarService.ProgressMonitor.WorkDone = i;
+					if (item.ItemType == ItemType.Compile) {
+						ParseInformation parseInfo = ParserService.ParseFile(item.FileName, null, true, false);
+						if (parseInfo != null) {
+							UpdateCompilationUnit(null, parseInfo.BestCompilationUnit as ICompilationUnit, item.FileName, true);
+						}
 					}
+					if (project == null) return;
 				}
+			} finally {
+				StatusBarService.ProgressMonitor.Done();
+				project = null;
 			}
+		}
+		
+		public void Dispose()
+		{
 			project = null;
 		}
 		
@@ -231,7 +253,8 @@ namespace ICSharpCode.Core
 		
 		public void UpdateCompilationUnit(ICompilationUnit oldUnit, ICompilationUnit parserOutput, string fileName, bool updateCommentTags)
 		{
-			
+			// TODO: UpdateCommentTags must run on the main thread
+			// (use fire+forget because main thread could be waiting on this thread to finish)
 			if (updateCommentTags) {
 				TaskService.UpdateCommentTags(fileName, parserOutput.TagComments);
 			}

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

@@ -22,7 +22,7 @@ using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.Core
 {
-	public interface IProjectContent
+	public interface IProjectContent : IDisposable
 	{
 		XmlDoc XmlDoc {
 			get;

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

@@ -38,6 +38,8 @@ namespace ICSharpCode.Core
 		
 		public static IProjectContent CurrentProjectContent {
 			get {
+				if (forcedContent != null) return forcedContent;
+				
 				if (ProjectService.CurrentProject == null || !projectContents.ContainsKey(ProjectService.CurrentProject)) {
 					return defaultProjectContent;
 				}
@@ -45,6 +47,15 @@ namespace ICSharpCode.Core
 			}
 		}
 		
+		static IProjectContent forcedContent;
+		/// <summary>
+		/// Used for unit tests ONLY!!
+		/// </summary>
+		public static void ForceProjectContent(IProjectContent content)
+		{
+			forcedContent = content;
+		}
+		
 		static ParserService()
 		{
 			try {
@@ -59,20 +70,39 @@ namespace ICSharpCode.Core
 		
 		static void ProjectServiceSolutionClosed(object sender, EventArgs e)
 		{
+			abortLoadSolutionProjectsThread = true;
 			lock (projectContents) {
+				foreach (IProjectContent content in projectContents.Values) {
+					content.Dispose();
+				}
 				projectContents.Clear();
 			}
 		}
 		
-		public static void OpenCombine(object sender, SolutionEventArgs e)
+		static Thread loadSolutionProjectsThread;
+		static bool   abortLoadSolutionProjectsThread;
+		
+		static void OpenCombine(object sender, SolutionEventArgs e)
 		{
-			Thread t = new Thread(new ThreadStart(LoadSolutionProjects));
-			t.Priority = ThreadPriority.Lowest;
-			t.IsBackground = true;
-			t.Start();
+			if (loadSolutionProjectsThread != null)
+				loadSolutionProjectsThread.Join();
+			loadSolutionProjectsThread = new Thread(new ThreadStart(LoadSolutionProjects));
+			loadSolutionProjectsThread.Priority = ThreadPriority.Lowest;
+			loadSolutionProjectsThread.IsBackground = true;
+			loadSolutionProjectsThread.Start();
 		}
 		
 		static void LoadSolutionProjects()
+		{
+			try {
+				abortLoadSolutionProjectsThread = false;
+				LoadSolutionProjectsInternal();
+			} finally {
+				loadSolutionProjectsThread = null;
+			}
+		}
+		
+		static void LoadSolutionProjectsInternal()
 		{
 			List<DefaultProjectContent> createdContents = new List<DefaultProjectContent>();
 			foreach (IProject project in ProjectService.OpenSolution.Projects) {
@@ -90,6 +120,7 @@ namespace ICSharpCode.Core
 				}
 			}
 			foreach (DefaultProjectContent newContent in createdContents) {
+				if (abortLoadSolutionProjectsThread) return;
 				try {
 					newContent.Initialize1();
 				} catch (Exception e) {
@@ -98,6 +129,7 @@ namespace ICSharpCode.Core
 				}
 			}
 			foreach (DefaultProjectContent newContent in createdContents) {
+				if (abortLoadSolutionProjectsThread) return;
 				try {
 					newContent.Initialize2();
 				} catch (Exception e) {

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

@@ -47,9 +47,9 @@ namespace ICSharpCode.Core
 				return contents[item.Include];
 			}
 			
+			StatusBarService.ProgressMonitor.BeginTask("Loading " + item.Include + "...", 100);
 			int time = Environment.TickCount;
 			Assembly assembly = null;
-			
 			try {
 				assembly = Assembly.ReflectionOnlyLoadFrom(item.FileName);
 				if (assembly != null) {
@@ -68,6 +68,7 @@ namespace ICSharpCode.Core
 				}
 			} finally {
 				Console.WriteLine("Loaded {0} in {1}ms", item.Include, Environment.TickCount - time);
+				StatusBarService.ProgressMonitor.Done();
 			}
 			
 			return null;

src/Main/Base/Project/Src/Services/Tasks/TaskService.cs

@@ -65,7 +65,7 @@ namespace ICSharpCode.Core
 		}
 		
 		static Dictionary<TaskType, int> taskCount = new Dictionary<TaskType, int>();
-	
+		
 		public static int GetCount(TaskType type)
 		{
 			if (!taskCount.ContainsKey(type)) {
@@ -158,13 +158,17 @@ namespace ICSharpCode.Core
 			if (fileName == null || tagComments == null) {
 				return;
 			}
-				
+			WorkbenchSingleton.SafeThreadAsyncCall(typeof(TaskService), "UpdateCommentTagsInvoked", fileName, tagComments);
+		}
+		
+		static void UpdateCommentTagsInvoked(string fileName, List<Tag> tagComments)
+		{
 			List<Task> newTasks = new List<Task>();
 			foreach (Tag tag in tagComments) {
-				newTasks.Add(new Task(fileName, 
-				                      tag.Key + tag.CommentString, 
-				                      tag.Region.BeginColumn, 
-				                      tag.Region.BeginLine, 
+				newTasks.Add(new Task(fileName,
+				                      tag.Key + tag.CommentString,
+				                      tag.Region.BeginColumn,
+				                      tag.Region.BeginLine,
 				                      TaskType.Comment));
 			}
 			List<Task> oldTasks = new List<Task>();

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -16,7 +16,9 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			ICSharpCode.NRefactory.Parser.IParser p = ICSharpCode.NRefactory.Parser.ParserFactory.CreateParser(ICSharpCode.NRefactory.Parser.SupportedLanguages.CSharp, new StringReader(fileContent));
 			p.Parse();
-			IProjectContent pc = new DefaultProjectContent();
+			DefaultProjectContent pc = new DefaultProjectContent();
+			pc.ReferencedContents.Add(corLib);
+			ParserService.ForceProjectContent(pc);
 			lastPC = pc;
 			NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
 			visitor.Visit(p.CompilationUnit, null);
@@ -36,7 +38,10 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			ICSharpCode.NRefactory.Parser.IParser p = ICSharpCode.NRefactory.Parser.ParserFactory.CreateParser(ICSharpCode.NRefactory.Parser.SupportedLanguages.VBNet, new StringReader(fileContent));
 			p.Parse();
-			IProjectContent pc = new DefaultProjectContent();
+			DefaultProjectContent pc = new DefaultProjectContent();
+			ParserService.ForceProjectContent(pc);
+			pc.ReferencedContents.Add(corLib);
+			pc.Language = LanguageProperties.VBNet;
 			lastPC = pc;
 			NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
 			visitor.Visit(p.CompilationUnit, null);
@@ -84,7 +89,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		}
 		#endregion
 		
-		#region Test for old issues
+		#region Test for old issues (Fidalgo)
 		// Issue SD-291
 		[Test]
 		public void VBNetMultipleVariableDeclarationsTest()
@@ -127,7 +132,7 @@ End Class
 		
 		// Issue SD-265
 		[Test]
-		public void VBNetStaticMembersonObjectTest()
+		public void VBNetStaticMembersOnInstanceTest()
 		{
 			string program = @"Class X
 	Sub Z()
@@ -209,29 +214,38 @@ End Module
 		[Test]
 		public void InheritedInterfaceResolveTest()
 		{
-			string program = @"class A {
+			string program = @"using System;
+class A {
 	void Method(IInterface1 a) {
 		
 	}
 }
-interface IInterface1 : IInterface2 {
+interface IInterface1 : IInterface2, IDisposable {
 	void Method1();
 }
 interface IInterface2 {
 	void Method2();
 }
 ";
-			ResolveResult result = Resolve(program, "a", 3);
+			ResolveResult result = Resolve(program, "a", 4);
 			Assert.IsNotNull(result, "result");
 			Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
 			ArrayList arr = result.GetCompletionData(lastPC);
 			Assert.IsNotNull(arr, "arr");
-			Assert.AreEqual(2, arr.Count, "Number of CC results");
+			bool m1 = false;
+			bool m2 = false;
+			bool disp = false;
 			foreach (IMethod m in arr) {
+				if (m.Name == "Method1")
+					m1 = true;
 				if (m.Name == "Method2")
-					return;
+					m2 = true;
+				if (m.Name == "Dispose")
+					disp = true;
 			}
-			Assert.Fail("Method2 not found");
+			Assert.IsTrue(m1, "Method1 not found");
+			Assert.IsTrue(m2, "Method2 not found");
+			Assert.IsTrue(disp, "Dispose not found");
 		}
 		
 		[Test]
@@ -320,6 +334,39 @@ interface IInterface2 {
 			Assert.IsTrue(result is MemberResolveResult, "'Multiply(1.0,1.0)' is MemberResolveResult");
 			Assert.AreEqual("System.Double", result.ResolvedType.FullyQualifiedName, "'Multiply(1.0,1.0)'");
 		}
+		
+		[Test]
+		public void CTorOverloadLookupTest()
+		{
+			string program = @"class A {
+	void Method() {
+		
+	}
+	
+	static A() {}
+	A() {}
+	A(int intVal) {}
+	A(double dblVal) {}
+}
+";
+			ResolveResult result = Resolve(program, "new A()", 3);
+			Assert.IsNotNull(result);
+			IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember;
+			Assert.IsFalse(m.IsStatic, "new A() is static");
+			Assert.AreEqual(0, m.Parameters.Count, "new A() parameter count");
+			
+			result = Resolve(program, "new A(10)", 3);
+			Assert.IsNotNull(result);
+			m = (IMethod)((MemberResolveResult)result).ResolvedMember;
+			Assert.AreEqual(1, m.Parameters.Count, "new A(10) parameter count");
+			Assert.AreEqual("intVal", m.Parameters[0].Name, "new A(10) parameter");
+			
+			result = Resolve(program, "new A(11.1)", 3);
+			Assert.IsNotNull(result);
+			m = (IMethod)((MemberResolveResult)result).ResolvedMember;
+			Assert.AreEqual(1, m.Parameters.Count, "new A(11.1) parameter count");
+			Assert.AreEqual("dblVal", m.Parameters[0].Name, "new A(11.1) parameter");
+		}
 		#endregion
 	}
 }

src/Main/StartUp/Project/SharpDevelopMain.cs

@@ -97,6 +97,9 @@ namespace ICSharpCode.SharpDevelop
 		
 		static void Run(string[] args)
 		{
+			#if DEBUG
+			Control.CheckForIllegalCrossThreadCalls = true;
+			#endif
 			commandLineArgs = args;
 			bool noLogo = false;