Use callback method for MSBuildEngine instead of Application.DoEvents() loop. Probably fixes SD2-619.

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

src/AddIns/Misc/MbUnitPad/Project/Src/MbUnitCommands.cs

@@ -96,20 +96,23 @@ namespace ICSharpCode.MbUnitPad
 				return;
 			}
 			IProject project = c.ProjectContent.Project;
-			if (project.Build().Errors.Count > 0) {
-				return;
-			}
-			string mbUnitDir = Path.GetDirectoryName(typeof(ReflectorTreeView).Assembly.Location);
-			ProcessStartInfo startInfo = new ProcessStartInfo(Path.Combine(mbUnitDir, "MbUnit.Cons.exe"));
-			string assemblyPath = project.OutputAssemblyFullPath;
-			StringBuilder sb = new StringBuilder();
-			sb.Append("\"/filter-type:" + c.FullyQualifiedName + "\"");
-			sb.Append(" \"/assembly-path:" + Path.GetDirectoryName(assemblyPath) + "\"");
-			sb.Append(" \"" + assemblyPath + "\"");
-			startInfo.Arguments = sb.ToString();
-			startInfo.WorkingDirectory = mbUnitDir;
-			LoggingService.Info("Run " + startInfo.FileName + " " + startInfo.Arguments);
-			DebuggerService.CurrentDebugger.Start(startInfo);
+			MSBuildEngineCallback callback = delegate(System.CodeDom.Compiler.CompilerResults results) {
+				if (results.Errors.Count > 0) {
+					return;
+				}
+				string mbUnitDir = Path.GetDirectoryName(typeof(ReflectorTreeView).Assembly.Location);
+				ProcessStartInfo startInfo = new ProcessStartInfo(Path.Combine(mbUnitDir, "MbUnit.Cons.exe"));
+				string assemblyPath = project.OutputAssemblyFullPath;
+				StringBuilder sb = new StringBuilder();
+				sb.Append("\"/filter-type:" + c.FullyQualifiedName + "\"");
+				sb.Append(" \"/assembly-path:" + Path.GetDirectoryName(assemblyPath) + "\"");
+				sb.Append(" \"" + assemblyPath + "\"");
+				startInfo.Arguments = sb.ToString();
+				startInfo.WorkingDirectory = mbUnitDir;
+				LoggingService.Info("Run " + startInfo.FileName + " " + startInfo.Arguments);
+				DebuggerService.CurrentDebugger.Start(startInfo);
+			};
+			project.Build(callback);
 		}
 	}
 	
@@ -159,7 +162,7 @@ namespace ICSharpCode.MbUnitPad
 		{
 			MbUnitPadContent.Instance.TreeView.ExpandAllFailures();
 		}
-	}	
+	}
 	
 	public class ExpandCurrentFailuresCommand : AbstractMenuCommand
 	{
@@ -167,7 +170,7 @@ namespace ICSharpCode.MbUnitPad
 		{
 			MbUnitPadContent.Instance.TreeView.ExpandCurrentFailures();
 		}
-	}	
+	}
 	
 	public class ExpandAllIgnoredCommand : AbstractMenuCommand
 	{
@@ -175,7 +178,7 @@ namespace ICSharpCode.MbUnitPad
 		{
 			MbUnitPadContent.Instance.TreeView.ExpandAllIgnored();
 		}
-	}	
+	}
 	
 	public class ExpandCurrentIgnoredCommand : AbstractMenuCommand
 	{
@@ -183,7 +186,7 @@ namespace ICSharpCode.MbUnitPad
 		{
 			MbUnitPadContent.Instance.TreeView.ExpandCurrentIgnored();
 		}
-	}		
+	}
 	
 	public class ClearResultsCommand : AbstractMenuCommand
 	{
@@ -191,5 +194,5 @@ namespace ICSharpCode.MbUnitPad
 		{
 			MbUnitPadContent.Instance.TreeView.ClearAllResults();
 		}
-	}	
+	}
 }

src/Main/Base/Project/Src/Commands/BuildCommands.cs

@@ -38,21 +38,26 @@ namespace ICSharpCode.SharpDevelop.Project.Commands
 		{
 			if (CanRunBuild) {
 				BeforeBuild();
-				RunBuild();
-				AfterBuild();
+				StartBuild();
 			} else {
 				MSBuildEngine.AddNoSingleFileCompilationError();
 			}
 		}
-
-		public abstract void RunBuild();
+		
+		protected void CallbackMethod(CompilerResults results)
+		{
+			MSBuildEngine.ShowResults(results);
+			AfterBuild();
+		}
+		
+		public abstract void StartBuild();
 	}
 	
 	public class Build : AbstractBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.OpenSolution.Build());
+			ProjectService.OpenSolution.Build(CallbackMethod);
 		}
 		
 		public override void AfterBuild()
@@ -63,25 +68,25 @@ namespace ICSharpCode.SharpDevelop.Project.Commands
 	
 	public class Rebuild : Build
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.OpenSolution.Rebuild());
+			ProjectService.OpenSolution.Rebuild(CallbackMethod);
 		}
 	}
 	
 	public class Clean : AbstractBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.OpenSolution.Clean());
+			ProjectService.OpenSolution.Clean(CallbackMethod);
 		}
 	}
 	
 	public class Publish : AbstractBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.OpenSolution.Publish());
+			ProjectService.OpenSolution.Publish(CallbackMethod);
 		}
 	}
 	
@@ -89,16 +94,16 @@ namespace ICSharpCode.SharpDevelop.Project.Commands
 	{
 		public override bool CanRunBuild {
 			get {
-				return base.CanRunBuild 
+				return base.CanRunBuild
 					&& ProjectService.CurrentProject!=null;
 			}
 		}
 	}
 	public class BuildProject : AbstractProjectBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.CurrentProject.Build());
+			ProjectService.CurrentProject.Build(CallbackMethod);
 		}
 		
 		public override void AfterBuild()
@@ -109,25 +114,25 @@ namespace ICSharpCode.SharpDevelop.Project.Commands
 	
 	public class RebuildProject : BuildProject
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.CurrentProject.Rebuild());
+			ProjectService.CurrentProject.Rebuild(CallbackMethod);
 		}
 	}
 	
 	public class CleanProject : AbstractProjectBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.CurrentProject.Clean());
+			ProjectService.CurrentProject.Clean(CallbackMethod);
 		}
 	}
 	
 	public class PublishProject : AbstractProjectBuildMenuCommand
 	{
-		public override void RunBuild()
+		public override void StartBuild()
 		{
-			MSBuildEngine.ShowResults(ProjectService.CurrentProject.Publish());
+			ProjectService.CurrentProject.Publish(CallbackMethod);
 		}
 	}
 	

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

@@ -695,24 +695,20 @@ namespace ICSharpCode.SharpDevelop.Project
 		#endregion
 		
 		
-		public virtual CompilerResults Build()
+		public virtual void Build(MSBuildEngineCallback callback)
 		{
-			return null;
 		}
 		
-		public virtual CompilerResults Rebuild()
+		public virtual void Rebuild(MSBuildEngineCallback callback)
 		{
-			return null;
 		}
 		
-		public virtual CompilerResults Clean()
+		public virtual void Clean(MSBuildEngineCallback callback)
 		{
-			return null;
 		}
 		
-		public virtual CompilerResults Publish()
+		public virtual void Publish(MSBuildEngineCallback callback)
 		{
-			return null;
 		}
 		
 		/// <summary>

src/Main/Base/Project/Src/Project/Converter/PrjxToSolutionProject.cs

@@ -277,7 +277,9 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 			Conversion conversion = new Conversion();
 			if (Path.GetExtension(fileName).ToLowerInvariant() == ".vbproj")
 				conversion.IsVisualBasic = true;
-			Solution.ReadSolutionInformation(Solution.SolutionBeingLoaded.FileName, conversion);
+			if (Solution.SolutionBeingLoaded != null) {
+				Solution.ReadSolutionInformation(Solution.SolutionBeingLoaded.FileName, conversion);
+			}
 			RunConverter(old, fileName, "vsnet2msbuild.xsl", conversion);
 			if (File.Exists(oldUserFile)) {
 				RunConverter(oldUserFile, userFile, "vsnet2msbuild_user.xsl", conversion);

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

@@ -131,9 +131,9 @@ namespace ICSharpCode.SharpDevelop.Project
 		/// </summary>
 		ProjectItem CreateProjectItem(string itemType);
 
-		CompilerResults Build();
-		CompilerResults Rebuild();
-		CompilerResults Clean();
-		CompilerResults Publish();
+		void Build(MSBuildEngineCallback callback);
+		void Rebuild(MSBuildEngineCallback callback);
+		void Clean(MSBuildEngineCallback callback);
+		void Publish(MSBuildEngineCallback callback);
 	}
 }

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

@@ -19,6 +19,8 @@ using Microsoft.Build.BuildEngine;
 
 namespace ICSharpCode.SharpDevelop.Project
 {
+	public delegate void MSBuildEngineCallback(CompilerResults results);
+	
 	/// <summary>
 	/// Class responsible for building a project using MSBuild.
 	/// Is called by MSBuildProject.
@@ -69,11 +71,11 @@ namespace ICSharpCode.SharpDevelop.Project
 		}
 		
 		/// <summary>
-		/// Notifies the user that #develp's internal MSBuildEngine 
+		/// Notifies the user that #develp's internal MSBuildEngine
 		/// implementation only supports compiling solutions and projects;
 		/// it does not allow compiling individual files.
 		/// </summary>
-		/// <remarks>Adds a message to the <see cref="TaskService"/> and 
+		/// <remarks>Adds a message to the <see cref="TaskService"/> and
 		/// shows the <see cref="ErrorListPad"/>.</remarks>
 		public static void AddNoSingleFileCompilationError()
 		{
@@ -82,7 +84,7 @@ namespace ICSharpCode.SharpDevelop.Project
 			TaskService.Add(new Task(null, StringParser.Parse("${res:BackendBindings.ExecutionManager.NoSingleFileCompilation}"), 0, 0, TaskType.Error));
 			WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
 		}
-		#endregion		
+		#endregion
 		
 		MessageViewCategory messageView;
 		
@@ -136,48 +138,41 @@ namespace ICSharpCode.SharpDevelop.Project
 			}
 		}
 		
-		public CompilerResults Run(string buildFile)
+		public void Run(string buildFile, MSBuildEngineCallback callback)
 		{
-			return Run(buildFile, null);
+			Run(buildFile, null, callback);
 		}
 		
-		static bool IsRunning = false;
+		volatile static bool isRunning = false;
 		
-		public CompilerResults Run(string buildFile, string[] targets)
+		public void Run(string buildFile, string[] targets, MSBuildEngineCallback callback)
 		{
-			CompilerResults results = new CompilerResults(null);
-			if (IsRunning) {
-				results.Errors.Add(new CompilerError(null, 0, 0, null, "MsBuild is already running!"));
-				return results;
-			}
-			IsRunning = true;
-			try {
-				Thread thread = new Thread(new ThreadStarter(results, buildFile, targets, this).Run);
+			if (isRunning) {
+				CompilerResults results = new CompilerResults(null);
+				results.Errors.Add(new CompilerError(null, 0, 0, null, "MSBuild is already running!"));
+				callback(results);
+			} else {
+				isRunning = true;
+				Thread thread = new Thread(new ThreadStarter(buildFile, targets, this, callback).Run);
 				thread.SetApartmentState(ApartmentState.STA);
 				thread.Start();
-				while (!thread.Join(10)) {
-					Application.DoEvents();
-					Application.DoEvents();
-				}
-				return results;
-			} finally {
-				IsRunning = false;
 			}
 		}
 		
 		class ThreadStarter
 		{
-			CompilerResults results;
+			CompilerResults results = new CompilerResults(null);
 			string buildFile;
 			string[] targets;
 			MSBuildEngine engine;
+			MSBuildEngineCallback callback;
 			
-			public ThreadStarter(CompilerResults results, string buildFile, string[] targets, MSBuildEngine engine)
+			public ThreadStarter(string buildFile, string[] targets, MSBuildEngine engine, MSBuildEngineCallback callback)
 			{
-				this.results = results;
 				this.buildFile = buildFile;
 				this.targets = targets;
 				this.engine = engine;
+				this.callback = callback;
 			}
 			
 			[STAThread]
@@ -207,6 +202,10 @@ namespace ICSharpCode.SharpDevelop.Project
 				engine.BuildProject(project, targets);
 				
 				LoggingService.Debug("MSBuild finished");
+				MSBuildEngine.isRunning = false;
+				if (callback != null) {
+					WorkbenchSingleton.MainForm.BeginInvoke(callback, results);
+				}
 			}
 		}
 		

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

@@ -396,36 +396,9 @@ namespace ICSharpCode.SharpDevelop.Project
 		}
 		#endregion
 		
-//		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}
-//			                                                                   }) + Environment.NewLine);
-//			TaskService.BuildMessageViewCategory.AppendText(StringParser.Parse("${res:MainWindow.CompilerMessages.PerformingMainCompilationOutput}") + Environment.NewLine);
-//			// 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;
-//		}
-		
-		public static CompilerResults RunMSBuild(string fileName, string target, string configuration, string platform, bool isSingleProject)
+		public static void RunMSBuild(string fileName, string target, string configuration, string platform, bool isSingleProject, MSBuildEngineCallback callback)
 		{
 			WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
-//			BeforeBuild();
 			MSBuildEngine engine = new MSBuildEngine();
 			if (isSingleProject) {
 				string dir = ProjectService.OpenSolution.Directory;
@@ -437,37 +410,36 @@ namespace ICSharpCode.SharpDevelop.Project
 			engine.Platform = platform;
 			engine.MessageView = TaskService.BuildMessageViewCategory;
 			if (target == null) {
-				return engine.Run(fileName);
+				engine.Run(fileName, callback);
+			} else {
+				engine.Run(fileName, new string[] { target }, callback);
 			}
-			return engine.Run(fileName, new string[] { target });
-//			AfterBuild();
 		}
 		
-		public CompilerResults RunMSBuild(string target)
+		public void RunMSBuild(string target, MSBuildEngineCallback callback)
 		{
-			return RunMSBuild(this.FileName, target, this.Configuration, this.Platform, true);
+			RunMSBuild(this.FileName, target, this.Configuration, this.Platform, true, callback);
 		}
 		
-		public override CompilerResults Build()
+		public override void Build(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Build");
+			RunMSBuild("Build", callback);
 		}
 		
-		public override CompilerResults Rebuild()
+		public override void Rebuild(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Rebuild");
+			RunMSBuild("Rebuild", callback);
 		}
 		
-		public override CompilerResults Clean()
+		public override void Clean(MSBuildEngineCallback callback)
 		{
-			CompilerResults result = RunMSBuild("Clean");
+			RunMSBuild("Clean", callback);
 			isDirty = true;
-			return result;
 		}
 		
-		public override CompilerResults Publish()
+		public override void Publish(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Publish");
+			RunMSBuild("Publish", callback);
 		}
 		
 		public override string ToString()

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

@@ -625,29 +625,29 @@ namespace ICSharpCode.SharpDevelop.Project
 		}
 		#endregion
 		
-		public CompilerResults RunMSBuild(string target)
+		public void RunMSBuild(string target, MSBuildEngineCallback callback)
 		{
-			return MSBuildProject.RunMSBuild(FileName, target, preferences.ActiveConfiguration, preferences.ActivePlatform, false);
+			MSBuildProject.RunMSBuild(FileName, target, preferences.ActiveConfiguration, preferences.ActivePlatform, false, callback);
 		}
 		
-		public CompilerResults Build()
+		public void Build(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild(null);
+			RunMSBuild(null, callback);
 		}
 		
-		public CompilerResults Rebuild()
+		public void Rebuild(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Rebuild");
+			RunMSBuild("Rebuild", callback);
 		}
 		
-		public CompilerResults Clean()
+		public void Clean(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Clean");
+			RunMSBuild("Clean", callback);
 		}
 		
-		public CompilerResults Publish()
+		public void Publish(MSBuildEngineCallback callback)
 		{
-			return RunMSBuild("Publish");
+			RunMSBuild("Publish", callback);
 		}
 	}
 }