Moving functionality from NDebugger to Process - rewritten Debugger.AddIn to the process based model

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

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/CallStackPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public partial class CallStackPad : DebuggerPad
 	{
 		ListView  callStackList;
+		Debugger.Process debuggedProcess;
 		
 		ColumnHeader name     = new ColumnHeader();
 		ColumnHeader language = new ColumnHeader();
@@ -59,20 +60,31 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		}
 		
 
-		protected override void RegisterDebuggerEvents()
+		protected override void SelectProcess(Debugger.Process process)
 		{
-			debuggerCore.DebuggeeStateChanged += delegate { RefreshPad(); };
-			debuggerCore.ProcessExited += delegate { callStackList.Items.Clear(); };
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged -= debuggedProcess_DebuggeeStateChanged;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged += debuggedProcess_DebuggeeStateChanged;
+			}
+			RefreshPad();
+		}
+		
+		void debuggedProcess_DebuggeeStateChanged(object sender, ProcessEventArgs e)
+		{
+			RefreshPad();
 		}
 		
 		void CallStackListItemActivate(object sender, EventArgs e)
 		{
-			if (debuggerCore.IsPaused) {
+			if (debuggedProcess.IsPaused) {
 				Function f = (Function)(callStackList.SelectedItems[0].Tag);
 				if (f.HasSymbols) {
-					if (debuggerCore.SelectedThread != null) {
-						debuggerCore.SelectedThread.SelectedFunction = f;
-						debuggerCore.OnDebuggeeStateChanged(); // Force refresh of pads
+					if (debuggedProcess.SelectedThread != null) {
+						debuggedProcess.SelectedThread.SelectedFunction = f;
+						debuggedProcess.OnDebuggeeStateChanged(); // Force refresh of pads
 					}
 				} else {
 					MessageService.ShowMessage("${res:MainWindow.Windows.Debug.CallStack.CannotSwitchWithoutSymbols}", "${res:MainWindow.Windows.Debug.CallStack.FunctionSwitch}");
@@ -92,8 +104,8 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			
 			callStackList.BeginUpdate();
 			callStackList.Items.Clear();
-			if (debuggerCore != null && debuggerCore.SelectedThread != null && debuggerCore.IsPaused) {
-				foreach (Function f in debuggerCore.SelectedThread.Callstack) {
+			if (debuggedProcess != null && debuggedProcess.SelectedThread != null && debuggedProcess.IsPaused) {
+				foreach (Function f in debuggedProcess.SelectedThread.Callstack) {
 					ListViewItem item;
 					if (f.HasSymbols || showExternalMethods) {
 						// Show the method in the list

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/DebuggerPad.cs

@@ -16,7 +16,6 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public abstract class DebuggerPad: AbstractPadContent
 	{
 		protected WindowsDebugger debugger;
-		protected NDebugger debuggerCore;
 		
 		public DebuggerPad()
 		{
@@ -24,13 +23,10 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			
 			InitializeComponents();
 			
-			if (debugger.ServiceInitialized) {
-				InitializeDebugger();
-			} else {
-				debugger.Initialize += delegate {
-					InitializeDebugger();
-				};
-			}
+			debugger.ProcessSelected += delegate(object sender, ProcessEventArgs e) {
+				SelectProcess(e.Process);
+			};
+			SelectProcess(debugger.DebuggedProcess);
 		}
 		
 		protected virtual void InitializeComponents()
@@ -38,16 +34,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			
 		}
 		
-		void InitializeDebugger()
-		{
-			debuggerCore = debugger.DebuggerCore;
-
-			RegisterDebuggerEvents();
-			
-			RefreshPad();
-		}
-		
-		protected virtual void RegisterDebuggerEvents()
+		protected virtual void SelectProcess(Debugger.Process process)
 		{
 			
 		}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/ExceptionHistoryPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class ExceptionHistoryPad : DebuggerPad
 	{
 		ListView  exceptionHistoryList;
+		Debugger.Process debuggedProcess;
 		
 		List<Debugger.Exception> exceptions = new List<Debugger.Exception>();
 		
@@ -62,17 +63,23 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			location.Text  = ResourceService.GetString("AddIns.HtmlHelp2.Location");
 		}
 		
+		protected override void SelectProcess(Debugger.Process process)
+		{
+			if (debuggedProcess != null) {
+				debuggedProcess.ExceptionThrown -= debuggedProcess_ExceptionThrown;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.ExceptionThrown += debuggedProcess_ExceptionThrown;
+			}
+			exceptions.Clear();
+			RefreshPad();
+		}
 		
-		protected override void RegisterDebuggerEvents()
+		void debuggedProcess_ExceptionThrown(object sender, ExceptionEventArgs e)
 		{
-			debuggerCore.ProcessExited += delegate {
-				exceptions.Clear();
-				RefreshPad();
-			};
-			debuggerCore.ExceptionThrown += delegate (object sender, ExceptionEventArgs e) {
-				exceptions.Add(e.Exception);
-				RefreshPad();
-			};
+			exceptions.Add(e.Exception);
+			RefreshPad();
 		}
 		
 		void ExceptionHistoryListItemActivate(object sender, EventArgs e)

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LoadedModulesPad.cs

@@ -22,6 +22,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class LoadedModulesPad : DebuggerPad
 	{
 		ListView  loadedModulesList;
+		Debugger.Process debuggedProcess;
 		
 		ColumnHeader name        = new ColumnHeader();
 		ColumnHeader address     = new ColumnHeader();
@@ -75,39 +76,59 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		}
 		
 		
-		protected override void RegisterDebuggerEvents()
+		protected override void SelectProcess(Debugger.Process process)
 		{
-			debuggerCore.ModuleLoaded += AddModule;
-			debuggerCore.ModuleUnloaded += RemoveModule;
+			if (debuggedProcess != null) {
+				debuggedProcess.ModuleLoaded -= debuggedProcess_ModuleLoaded;
+				debuggedProcess.ModuleUnloaded -= debuggedProcess_ModuleUnloaded;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.ModuleLoaded += debuggedProcess_ModuleLoaded;
+				debuggedProcess.ModuleUnloaded += debuggedProcess_ModuleUnloaded;
+			}
+			RefreshPad();
 		}
-
+		
+		void debuggedProcess_ModuleLoaded(object sender, ModuleEventArgs e)
+		{
+			AddModule(e.Module);
+		}
+		
+		void debuggedProcess_ModuleUnloaded(object sender, ModuleEventArgs e)
+		{
+			RemoveModule(e.Module);
+		}
+		
 		public override void RefreshPad()
 		{
-            loadedModulesList.Items.Clear();
-            foreach(Module m in debuggerCore.Modules) {
-                AddModule(this, new ModuleEventArgs(m));
-            }
+			loadedModulesList.Items.Clear();
+			if (debuggedProcess != null) {
+				foreach(Module module in debuggedProcess.Modules) {
+					AddModule(module);
+				}
+			}
 		}
-
-		void AddModule(object sender, ModuleEventArgs e) 
+		
+		void AddModule(Module module)
 		{
-			ListViewItem newItem = new ListViewItem(new string[] {e.Module.Filename,
-			                                                      String.Format("{0:X8}", e.Module.BaseAdress),
-			                                                      e.Module.DirectoryName,
-			                                                      e.Module.OrderOfLoading.ToString(),
+			ListViewItem newItem = new ListViewItem(new string[] {module.Filename,
+			                                                      String.Format("{0:X8}", module.BaseAdress),
+			                                                      module.DirectoryName,
+			                                                      module.OrderOfLoading.ToString(),
 			                                                      "",
 			                                                      "",
 			                                                      "",
-			                                                      StringParser.Parse(e.Module.SymbolsLoaded ? "${res:MainWindow.Windows.Debug.HasSymbols}" : "${res:MainWindow.Windows.Debug.HasNoSymbols}")
+			                                                      StringParser.Parse(module.SymbolsLoaded ? "${res:MainWindow.Windows.Debug.HasSymbols}" : "${res:MainWindow.Windows.Debug.HasNoSymbols}")
 			                                                     });
-			newItem.Tag = e.Module;
+			newItem.Tag = module;
 			loadedModulesList.Items.Add(newItem);
 		}
 
-		void RemoveModule(object sender, ModuleEventArgs e) 
+		void RemoveModule(Module module)
 		{
 			foreach (ListViewItem item in loadedModulesList.Items) {
-				if (item.Tag == e.Module) {
+				if (item.Tag == module) {
 					item.Remove();
 				}
 			}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/LocalVarPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public class LocalVarPad : DebuggerPad
 	{
 		DebuggerTreeListView localVarList;
+		Debugger.Process debuggedProcess;
 		
 		ColumnHeader name = new ColumnHeader();
 		ColumnHeader val  = new ColumnHeader();
@@ -77,17 +78,30 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 			localVarList.Visible = true;
 		}
 		
+		protected override void SelectProcess(Debugger.Process process)
+		{
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged -= debuggedProcess_DebuggeeStateChanged;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged += debuggedProcess_DebuggeeStateChanged;
+			}
+			RefreshPad();
+		}
 		
-		protected override void RegisterDebuggerEvents()
+		void debuggedProcess_DebuggeeStateChanged(object sender, ProcessEventArgs e)
 		{
-			debuggerCore.DebuggeeStateChanged += delegate { RefreshPad(); };
+			RefreshPad();
 		}
 		
 		public override void RefreshPad()
 		{
 			localVarList.BeginUpdate();
 			localVarList.Items.Clear();
-			AddVariableCollectionToTree(debuggerCore.LocalVariables, localVarList.Items);
+			if (debuggedProcess != null) {
+				AddVariableCollectionToTree(debuggedProcess.LocalVariables, localVarList.Items);
+			}
 			localVarList.EndUpdate();
 		}
 		
@@ -114,7 +128,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		
 		void localVarList_BeforeExpand(object sender, TreeListViewCancelEventArgs e)
 		{
-			if (debuggerCore.IsPaused) {
+			if (debuggedProcess.IsPaused) {
 				if (e.Item is TreeListViewDebuggerItem) {
 					((TreeListViewDebuggerItem)e.Item).BeforeExpand();
 				}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/RunningThreadsPad.Menu.cs

@@ -55,7 +55,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 				}
 				bool suspended = (selItems[0].Tag as Thread).Suspended;
 				
-				if (!debuggerCore.IsPaused) {
+				if (!debuggedProcess.IsPaused) {
 					MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotFreezeWhileRunning}", "${res:MainWindow.Windows.Debug.Threads.Freeze}");
 					return;
 				}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Pads/RunningThreadsPad.cs

@@ -23,6 +23,7 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 	public partial class RunningThreadsPad : DebuggerPad
 	{
 		ListView  runningThreadsList;
+		Debugger.Process debuggedProcess;
 		
 		ColumnHeader id          = new ColumnHeader();
 		ColumnHeader name        = new ColumnHeader();
@@ -68,33 +69,60 @@ namespace ICSharpCode.SharpDevelop.Gui.Pads
 		}
 		
 
-		protected override void RegisterDebuggerEvents()
+		protected override void SelectProcess(Debugger.Process process)
 		{
-			debuggerCore.DebuggeeStateChanged += delegate { RefreshPad(); };
-			debuggerCore.ThreadStarted += delegate(object sender, ThreadEventArgs e) {
-				AddThread(e.Thread);
-			};
-			debuggerCore.ThreadStateChanged += delegate(object sender, ThreadEventArgs e) {
-				RefreshThread(e.Thread);
-			};
-			debuggerCore.ThreadExited += delegate(object sender, ThreadEventArgs e) {
-				RemoveThread(e.Thread);
-			};
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged -= debuggedProcess_DebuggeeStateChanged;
+				debuggedProcess.ThreadStarted        -= debuggedProcess_ThreadStarted;
+				debuggedProcess.ThreadStateChanged   -= debuggedProcess_ThreadStateChanged;
+				debuggedProcess.ThreadExited         -= debuggedProcess_ThreadExited;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggeeStateChanged += debuggedProcess_DebuggeeStateChanged;
+				debuggedProcess.ThreadStarted        += debuggedProcess_ThreadStarted;
+				debuggedProcess.ThreadStateChanged   += debuggedProcess_ThreadStateChanged;
+				debuggedProcess.ThreadExited         += debuggedProcess_ThreadExited;
+			}
+			runningThreadsList.Clear();
+			RefreshPad();
+		}
+		
+		void debuggedProcess_DebuggeeStateChanged(object sender, ProcessEventArgs e)
+		{
+			RefreshPad();
+		}
+		
+		void debuggedProcess_ThreadStarted(object sender, ThreadEventArgs e)
+		{
+			AddThread(e.Thread);
+		}
+		
+		void debuggedProcess_ThreadStateChanged(object sender, ThreadEventArgs e)
+		{
+			RefreshThread(e.Thread);
+		}
+		
+		void debuggedProcess_ThreadExited(object sender, ThreadEventArgs e)
+		{
+			RemoveThread(e.Thread);
 		}
 		
 		public override void RefreshPad()
 		{
-			foreach (Thread t in debuggerCore.Threads) {
-				RefreshThread(t);
+			if (debuggedProcess != null) {
+				foreach (Thread t in debuggedProcess.Threads) {
+					RefreshThread(t);
+				}
 			}
 		}
 
 		void RunningThreadsListItemActivate(object sender, EventArgs e)
 		{
-			if (debuggerCore.IsPaused) {
-				if (debuggerCore.SelectedProcess != null) {
-					debuggerCore.SelectedProcess.SelectedThread = (Thread)(runningThreadsList.SelectedItems[0].Tag);
-					debuggerCore.OnDebuggeeStateChanged(); // Force refresh of pads
+			if (debuggedProcess.IsPaused) {
+				if (debuggedProcess != null) {
+					debuggedProcess.SelectedThread = (Thread)(runningThreadsList.SelectedItems[0].Tag);
+					debuggedProcess.OnDebuggeeStateChanged(); // Force refresh of pads
 				}
 			} else {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotSwitchWhileRunning}", "${res:MainWindow.Windows.Debug.Threads.ThreadSwitch}");

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -40,13 +40,30 @@ namespace ICSharpCode.SharpDevelop.Services
 		Properties properties;
 		
 		bool serviceInitialized = false;
-				
+		
+		Debugger.Process debuggedProcess;
+		
+		public event EventHandler<ProcessEventArgs> ProcessSelected;
+		
 		public NDebugger DebuggerCore {
 			get {
 				return debugger;
 			}
 		}
 		
+		public Debugger.Process DebuggedProcess {
+			get {
+				return debuggedProcess;
+			}
+		}
+		
+		protected virtual void OnProcessSelected(ProcessEventArgs e)
+		{
+			if (ProcessSelected != null) {
+				ProcessSelected(this, e);
+			}
+		}
+		
 		public Properties Properties {
 			get {
 				return properties;
@@ -63,18 +80,18 @@ namespace ICSharpCode.SharpDevelop.Services
 		{
 			properties = PropertyService.Get("DebuggerProperties", new Properties());
 		}
-
+		
 		#region IDebugger Members
-
+		
 		public bool IsDebugging { 
 			get { 
-				return serviceInitialized && (debugger.Processes.Count > 0);
+				return serviceInitialized && debuggedProcess != null;
 			} 
 		}
 		
 		public bool IsProcessRunning { 
 			get { 
-				return IsDebugging && debugger.IsRunning; 
+				return IsDebugging && debuggedProcess.IsRunning; 
 			} 
 		}
 		
@@ -94,63 +111,64 @@ namespace ICSharpCode.SharpDevelop.Services
 			} else if (version == null || version.Length == 0) {
 				MessageBox.Show("Can not get .NET Framework version of program. Check that the program is managed assembly.");
 			} else {
-				debugger.Start(processStartInfo.FileName,
-				               processStartInfo.WorkingDirectory,
-							   processStartInfo.Arguments);
+				Debugger.Process process = debugger.Start(processStartInfo.FileName,
+				                                          processStartInfo.WorkingDirectory,
+				                                          processStartInfo.Arguments);
+				SelectProcess(process);
 			}
 		}
-
+		
 		public void StartWithoutDebugging(ProcessStartInfo processStartInfo)
 		{
 			System.Diagnostics.Process.Start(processStartInfo);
 		}
-
+		
 		public void Stop()
 		{
-			debugger.Terminate();
+			debuggedProcess.Terminate();
 		}
 		
 		// ExecutionControl:
 		
 		public void Break()
 		{
-			debugger.Break();
+			debuggedProcess.Break();
 		}
 		
 		public void Continue()
 		{
-			debugger.Continue();
+			debuggedProcess.Continue();
 		}
-
+		
 		// Stepping:
-
+		
 		public void StepInto()
 		{
-			if (debugger.SelectedFunction == null || debugger.IsRunning) {
+			if (debuggedProcess.SelectedFunction == null || debuggedProcess.IsRunning) {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotStepNoActiveFunction}", "${res:XML.MainMenu.DebugMenu.StepInto}");
 			} else {
-				debugger.StepInto();
+				debuggedProcess.StepInto();
 			}
 		}
 		
 		public void StepOver()
 		{
-			if (debugger.SelectedFunction == null || debugger.IsRunning) {
+			if (debuggedProcess.SelectedFunction == null || debuggedProcess.IsRunning) {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotStepNoActiveFunction}", "${res:XML.MainMenu.DebugMenu.StepOver.Description}");
 			} else {
-				debugger.StepOver();
+				debuggedProcess.StepOver();
 			}
 		}
 		
 		public void StepOut()
 		{
-			if (debugger.SelectedFunction == null || debugger.IsRunning) {
+			if (debuggedProcess.SelectedFunction == null || debuggedProcess.IsRunning) {
 				MessageService.ShowMessage("${res:MainWindow.Windows.Debug.Threads.CannotStepNoActiveFunction}", "${res:XML.MainMenu.DebugMenu.StepOut}");
 			} else {
-				debugger.StepOut();
+				debuggedProcess.StepOut();
 			}
 		}
-
+		
 		public event EventHandler DebugStarted;
 		public event EventHandler DebugStopped;
 		public event EventHandler IsProcessRunningChanged;
@@ -168,9 +186,9 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// </summary>
 		public Variable GetVariableFromName(string variableName)
 		{
-			if (debugger == null || debugger.IsRunning) return null;
+			if (debuggedProcess == null || debuggedProcess.IsRunning) return null;
 			
-			VariableCollection collection = debugger.LocalVariables;
+			VariableCollection collection = debuggedProcess.LocalVariables;
 			
 			if (collection == null) return null;
 			
@@ -214,8 +232,8 @@ namespace ICSharpCode.SharpDevelop.Services
 		
 		public bool CanSetInstructionPointer(string filename, int line, int column)
 		{
-			if (debugger != null && debugger.IsPaused && debugger.SelectedFunction != null) {
-				SourcecodeSegment seg = debugger.SelectedFunction.CanSetIP(filename, line, column);
+			if (debuggedProcess != null && debuggedProcess.IsPaused && debuggedProcess.SelectedFunction != null) {
+				SourcecodeSegment seg = debuggedProcess.SelectedFunction.CanSetIP(filename, line, column);
 				return seg != null;
 			} else {
 				return false;
@@ -225,7 +243,7 @@ namespace ICSharpCode.SharpDevelop.Services
 		public bool SetInstructionPointer(string filename, int line, int column)
 		{
 			if (CanSetInstructionPointer(filename, line, column)) {
-				SourcecodeSegment seg = debugger.SelectedFunction.SetIP(filename, line, column);
+				SourcecodeSegment seg = debuggedProcess.SelectedFunction.SetIP(filename, line, column);
 				return seg != null;
 			} else {
 				return false;
@@ -248,22 +266,17 @@ namespace ICSharpCode.SharpDevelop.Services
 				string path = RemotingConfigurationHelpper.GetLoadedAssemblyPath("Debugger.Core.dll");
 				new RemotingConfigurationHelpper(path).Configure();
 			}
-
+			
 			debugger = new NDebugger();
-
-			debugger.LogMessage              += LogMessage;
-			debugger.DebuggerTraceMessage    += TraceMessage;
-			debugger.ProcessStarted          += ProcessStarted;
-			debugger.ProcessExited           += ProcessExited;
-			debugger.DebuggingPaused         += DebuggingPaused;
-			debugger.ExceptionThrown         += ExceptionThrown;
-			debugger.DebuggeeStateChanged    += DebuggeeStateChanged;
-			debugger.DebuggingResumed        += DebuggingResumed;
-
+			
+			debugger.DebuggerTraceMessage    += debugger_TraceMessage;
+			debugger.ProcessStarted          += debugger_ProcessStarted;
+			debugger.ProcessExited           += debugger_ProcessExited;
+			
 			DebuggerService.BreakPointAdded  += delegate (object sender, BreakpointBookmarkEventArgs e) {
 				AddBreakpoint(e.BreakpointBookmark);
 			};
-
+			
 			foreach (BreakpointBookmark b in DebuggerService.Breakpoints) {
 				AddBreakpoint(b);
 			}
@@ -271,10 +284,10 @@ namespace ICSharpCode.SharpDevelop.Services
 			if (Initialize != null) {
 				Initialize(this, null);  
 			}
-
+			
 			serviceInitialized = true;
 		}
-
+		
 		void AddBreakpoint(BreakpointBookmark bookmark)
 		{
 			SourcecodeSegment seg = new SourcecodeSegment(bookmark.FileName, bookmark.LineNumber + 1); 
@@ -300,41 +313,64 @@ namespace ICSharpCode.SharpDevelop.Services
 				breakpoint.Enabled = bookmark.IsEnabled;
 			};
 		}
-
+		
 		void LogMessage(object sender, MessageEventArgs e)
 		{
 			DebuggerService.PrintDebugMessage(e.Message);
 		}
 		
-		void TraceMessage(object sender, MessageEventArgs e)
+		void debugger_TraceMessage(object sender, MessageEventArgs e)
 		{
 			LoggingService.Debug("Debugger: " + e.Message);
 		}
 		
-		void ProcessStarted(object sender, ProcessEventArgs e)
+		void debugger_ProcessStarted(object sender, ProcessEventArgs e)
 		{
 			if (debugger.Processes.Count == 1) {
 				if (DebugStarted != null) {
 					DebugStarted(this, EventArgs.Empty);
 				}
 			}
+			e.Process.LogMessage += LogMessage;
 		}
-
-		void ProcessExited(object sender, ProcessEventArgs e)
+		
+		void debugger_ProcessExited(object sender, ProcessEventArgs e)
 		{
 			if (debugger.Processes.Count == 0) {
 				if (DebugStopped != null) {
 					DebugStopped(this, e);
 				}
+				SelectProcess(null);
+			} else {
+				SelectProcess(debugger.Processes[0]);
 			}
 		}
 		
-		void DebuggingPaused(object sender, ProcessEventArgs e)
+		public void SelectProcess(Debugger.Process process)
+		{
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggingPaused         -= debuggedProcess_DebuggingPaused;
+				debuggedProcess.ExceptionThrown         -= debuggedProcess_ExceptionThrown;
+				debuggedProcess.DebuggeeStateChanged    -= debuggedProcess_DebuggeeStateChanged;
+				debuggedProcess.DebuggingResumed        -= debuggedProcess_DebuggingResumed;
+			}
+			debuggedProcess = process;
+			if (debuggedProcess != null) {
+				debuggedProcess.DebuggingPaused         += debuggedProcess_DebuggingPaused;
+				debuggedProcess.ExceptionThrown         += debuggedProcess_ExceptionThrown;
+				debuggedProcess.DebuggeeStateChanged    += debuggedProcess_DebuggeeStateChanged;
+				debuggedProcess.DebuggingResumed        += debuggedProcess_DebuggingResumed;
+			}
+			JumpToCurrentLine();
+			OnProcessSelected(new ProcessEventArgs(process));
+		}
+		
+		void debuggedProcess_DebuggingPaused(object sender, ProcessEventArgs e)
 		{
 			OnIsProcessRunningChanged(EventArgs.Empty);
 		}
 		
-		void ExceptionThrown(object sender, ExceptionEventArgs e)
+		void debuggedProcess_ExceptionThrown(object sender, ExceptionEventArgs e)
 		{
 			if (e.Exception.ExceptionType != ExceptionType.DEBUG_EXCEPTION_UNHANDLED) {
 				// Ignore the exception
@@ -351,32 +387,33 @@ namespace ICSharpCode.SharpDevelop.Services
 					e.Continue = true;
 					return;
 				case ExceptionForm.Result.Ignore:
-					debugger.SelectedThread.InterceptCurrentException();
+					e.Process.SelectedThread.InterceptCurrentException();
 					e.Continue = true; // HACK: Start interception
 					break;
 			}
 		}
 		
-		void DebuggeeStateChanged(object sender, ProcessEventArgs e)
+		void debuggedProcess_DebuggeeStateChanged(object sender, ProcessEventArgs e)
 		{
 			JumpToCurrentLine();
 		}
 		
-		void DebuggingResumed(object sender, ProcessEventArgs e)
+		void debuggedProcess_DebuggingResumed(object sender, ProcessEventArgs e)
 		{
-			if (!debugger.Evaluating) {
+			if (!e.Process.Evaluating) {
 				DebuggerService.RemoveCurrentLineMarker();
 			}
 		}
-
+		
 		public void JumpToCurrentLine()
 		{
 			WorkbenchSingleton.MainForm.Activate();
-			SourcecodeSegment nextStatement = debugger.NextStatement;
-			if (nextStatement == null) {
-				DebuggerService.RemoveCurrentLineMarker();
-			} else {
-				DebuggerService.JumpToCurrentLine(nextStatement.SourceFullFilename, nextStatement.StartLine, nextStatement.StartColumn, nextStatement.EndLine, nextStatement.EndColumn);
+			DebuggerService.RemoveCurrentLineMarker();
+			if (debuggedProcess != null) {
+				SourcecodeSegment nextStatement = debuggedProcess.NextStatement;
+				if (nextStatement != null) {
+					DebuggerService.JumpToCurrentLine(nextStatement.SourceFullFilename, nextStatement.StartLine, nextStatement.StartColumn, nextStatement.EndLine, nextStatement.EndColumn);
+				}
 			}
 		}
 	}

src/AddIns/Misc/Debugger/Debugger.BooInterpreter/Project/Src/DebugeeInterpreterContext.cs

@@ -22,7 +22,7 @@ namespace Debugger
 {
 	public class DebugeeInterpreterContext: InterpreterContext
 	{
-		NDebugger debugger;
+		Process process;
 		Variable interpreter;
 		Variable interpreter_localVariable;
 		
@@ -50,14 +50,14 @@ namespace Debugger
 				PrintLine("Error: 'Incompatible debugger'");
 				return false;
 			}
-			if (!winDebugger.IsDebugging) {
+			if (winDebugger.DebuggedProcess == null) {
 				PrintLine("Error: 'No program is debugged'");
 				return false;
 			}
-			debugger = winDebugger.DebuggerCore;
-			debugger.SelectedProcess.Expired += delegate { interpreter = null; };
-			debugger.LogMessage -= OnDebuggerLogMessage;
-			debugger.LogMessage += OnDebuggerLogMessage;
+			process = winDebugger.DebuggedProcess;
+			process.Expired += delegate { interpreter = null; };
+			process.LogMessage -= OnDebuggerLogMessage;
+			process.LogMessage += OnDebuggerLogMessage;
 			
 			Variable assembly;
 			// Boo.Lang.Interpreter.dll
@@ -65,8 +65,8 @@ namespace Debugger
 			assembly = LoadAssembly(path);
 			// Debugger.BooInterpreter.dll
 			assembly = LoadAssembly(typeof(DebugeeInteractiveInterpreter).Assembly.Location);
-			Variable interpreterType = Eval.NewString(debugger, typeof(DebugeeInteractiveInterpreter).FullName);
-			interpreter = Eval.CallFunction(debugger, typeof(Assembly), "CreateInstance", assembly, new Variable[] {interpreterType});
+			Variable interpreterType = Eval.NewString(process, typeof(DebugeeInteractiveInterpreter).FullName);
+			interpreter = Eval.CallFunction(process, typeof(Assembly), "CreateInstance", assembly, new Variable[] {interpreterType});
 			interpreter_localVariable = interpreter.Value.SubVariables["localVariable"];
 			RunCommand(
 				"import System\n" + 
@@ -80,16 +80,16 @@ namespace Debugger
 		
 		Variable LoadAssembly(string path)
 		{
-			Variable assemblyPath = Eval.NewString(debugger, path);
-			Variable assembly = Eval.CallFunction(debugger, typeof(Assembly), "LoadFrom", null, new Variable[] {assemblyPath});
+			Variable assemblyPath = Eval.NewString(process, path);
+			Variable assembly = Eval.CallFunction(process, typeof(Assembly), "LoadFrom", null, new Variable[] {assemblyPath});
 			return assembly;
 		}
 		
 		public override void RunCommand(string code)
 		{
 			if (CanLoadInterpreter) {
-				Variable cmd = Eval.NewString(debugger, code);
-				Eval.CallFunction(debugger, typeof(InteractiveInterpreter), "LoopEval", interpreter, new Variable[] {cmd});
+				Variable cmd = Eval.NewString(process, code);
+				Eval.CallFunction(process, typeof(InteractiveInterpreter), "LoopEval", interpreter, new Variable[] {cmd});
 			}
 		}
 		
@@ -101,8 +101,8 @@ namespace Debugger
 		public override string[] SuggestCodeCompletion(string code)
 		{
 			if (CanLoadInterpreter) {
-				Variable cmd = Eval.NewString(debugger, code);
-				Eval.CallFunction(debugger, typeof(AbstractInterpreter), "SuggestCodeCompletion", interpreter, new Variable[] {cmd});
+				Variable cmd = Eval.NewString(process, code);
+				Eval.CallFunction(process, typeof(AbstractInterpreter), "SuggestCodeCompletion", interpreter, new Variable[] {cmd});
 				return null;
 			} else {
 				return null;
@@ -130,19 +130,19 @@ namespace Debugger
 		{
 			Variable localVar;
 			try {
-				localVar = debugger.LocalVariables[name];
+				localVar = process.LocalVariables[name];
 			} catch (DebuggerException) {
 				return;
 			}
 			PrintLine("Getting local variable " + name);
 			// First, get out of GC unsafe point
-			Stepper stepOut = new Stepper(debugger.SelectedThread.LastFunction, "Boo interperter");
+			Stepper stepOut = new Stepper(process.SelectedThread.LastFunction, "Boo interperter");
 			stepOut.StepComplete  += delegate {
-				debugger.MTA2STA.AsyncCall(delegate {
+				process.Debugger.MTA2STA.AsyncCall(delegate {
 					if (!interpreter_localVariable.SetValue(localVar)) {
 						PrintLine("Getting of local variable " + name + " failed");
 					}
-					debugger.Continue();
+					process.Continue();
 				});
 			};
 			stepOut.StepOut();
@@ -152,7 +152,7 @@ namespace Debugger
 		{
 			Variable localVar;
 			try {
-				localVar = debugger.LocalVariables[name];
+				localVar = process.LocalVariables[name];
 			} catch (DebuggerException) {
 				return;
 			}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/NDebugger.cs

@@ -151,11 +151,12 @@ namespace Debugger
 			process.Start();
 		}
 		
-		public void Start(string filename, string workingDirectory, string arguments)		
+		public Process Start(string filename, string workingDirectory, string arguments)		
 		{
 			InitDebugger(GetProgramVersion(filename));
 			Process process = Process.CreateProcess(this, filename, workingDirectory, arguments);
 			AddProcess(process);
+			return process;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Process.cs

@@ -136,7 +136,7 @@ namespace Debugger
 			return new Process(debugger, outProcess);
 		}
 		
-		internal void Break()
+		public void Break()
 		{
 			AssertRunning();